From 644baf4985810d6d4ed4ce9b93d54dc8bec5d673 Mon Sep 17 00:00:00 2001 From: Pavel Karpy Date: Mon, 15 Nov 2021 01:04:19 +0300 Subject: [PATCH] [#971] morph/balance: Add optional parameters Add optional parameters to the client call signature. Signed-off-by: Pavel Karpy --- pkg/morph/client/balance/transfer.go | 102 ++++++++++++++- pkg/morph/client/balance/wrapper/transfer.go | 123 ++++++++++++++++++- 2 files changed, 213 insertions(+), 12 deletions(-) diff --git a/pkg/morph/client/balance/transfer.go b/pkg/morph/client/balance/transfer.go index b753eede8..6df858958 100644 --- a/pkg/morph/client/balance/transfer.go +++ b/pkg/morph/client/balance/transfer.go @@ -16,6 +16,8 @@ type TransferXArgs struct { recipient []byte // recipient's wallet script hash details []byte // transfer details + + client.InvokePrmOptional } // SetAmount sets amount of funds to transfer @@ -49,6 +51,7 @@ func (c *Client) TransferX(args TransferXArgs) error { prm.SetMethod(c.transferXMethod) prm.SetArgs(args.sender, args.recipient, args.amount, args.details) + prm.InvokePrmOptional = args.InvokePrmOptional err := c.client.Invoke(prm) if err != nil { @@ -58,32 +61,119 @@ func (c *Client) TransferX(args TransferXArgs) error { return nil } +// MintPrm groups parameters of Mint operation. +type MintPrm struct { + to []byte + amount int64 + id []byte + + client.InvokePrmOptional +} + +// SetTo sets receiver of the transfer. +func (m *MintPrm) SetTo(to []byte) { + m.to = to +} + +// SetAmount sets amount of the transfer. +func (m *MintPrm) SetAmount(amount int64) { + m.amount = amount +} + +// SetID sets ID. +func (m *MintPrm) SetID(id []byte) { + m.id = id +} + // Mint invokes `mint` method of the balance contract. -func (c *Client) Mint(to []byte, amount int64, id []byte) error { +func (c *Client) Mint(args MintPrm) error { prm := client.InvokePrm{} prm.SetMethod(c.mintMethod) - prm.SetArgs(to, amount, id) + prm.SetArgs(args.to, args.amount, args.id) + prm.InvokePrmOptional = args.InvokePrmOptional return c.client.Invoke(prm) } +// BurnPrm groups parameters of Burn operation. +type BurnPrm struct { + to []byte + amount int64 + id []byte + + client.InvokePrmOptional +} + +// SetTo sets receiver. +func (b *BurnPrm) SetTo(to []byte) { + b.to = to +} + +// SetAmount sets amount. +func (b *BurnPrm) SetAmount(amount int64) { + b.amount = amount +} + +// SetID sets ID +func (b *BurnPrm) SetID(id []byte) { + b.id = id +} + // Burn invokes `burn` method of the balance contract. -func (c *Client) Burn(to []byte, amount int64, id []byte) error { +func (c *Client) Burn(args BurnPrm) error { prm := client.InvokePrm{} prm.SetMethod(c.burnMethod) - prm.SetArgs(to, amount, id) + prm.SetArgs(args.to, args.amount, args.id) + prm.InvokePrmOptional = args.InvokePrmOptional return c.client.Invoke(prm) } +// LockPrm groups parameters of Lock operation. +type LockPrm struct { + id []byte + user []byte + lock []byte + amount int64 + dueEpoch int64 + + client.InvokePrmOptional +} + +// SetID sets ID. +func (l *LockPrm) SetID(id []byte) { + l.id = id +} + +// SetUser set user. +func (l *LockPrm) SetUser(user []byte) { + l.user = user +} + +// SetLock sets lock. +func (l *LockPrm) SetLock(lock []byte) { + l.lock = lock +} + +// SetAmount sets amount. +func (l *LockPrm) SetAmount(amount int64) { + l.amount = amount +} + +// SetDueEpoch sets end of the lock. +func (l *LockPrm) SetDueEpoch(dueEpoch int64) { + l.dueEpoch = dueEpoch +} + // Lock invokes `lock` method of the balance contract. -func (c *Client) Lock(id, user, lock []byte, amount, dueEpoch int64) error { +func (c *Client) Lock(args LockPrm) error { prm := client.InvokePrm{} prm.SetMethod(c.lockMethod) - prm.SetArgs(id, user, lock, amount, dueEpoch) + prm.SetArgs(args.id, args.user, args.lock, args.amount, args.dueEpoch) + prm.InvokePrmOptional = args.InvokePrmOptional return c.client.Invoke(prm) } diff --git a/pkg/morph/client/balance/wrapper/transfer.go b/pkg/morph/client/balance/wrapper/transfer.go index e87e5ec16..9f3bb87f6 100644 --- a/pkg/morph/client/balance/wrapper/transfer.go +++ b/pkg/morph/client/balance/wrapper/transfer.go @@ -3,6 +3,7 @@ package wrapper import ( "github.com/nspcc-dev/neo-go/pkg/encoding/address" "github.com/nspcc-dev/neo-go/pkg/util" + "github.com/nspcc-dev/neofs-node/pkg/morph/client" "github.com/nspcc-dev/neofs-node/pkg/morph/client/balance" "github.com/nspcc-dev/neofs-sdk-go/owner" ) @@ -14,6 +15,8 @@ type TransferPrm struct { From, To *owner.ID Details []byte + + client.InvokePrmOptional } // TransferX transfers p.Amount of GASe-12 from p.From to p.To @@ -36,21 +39,129 @@ func (w *Wrapper) TransferX(p TransferPrm) error { args.SetRecipient(to.BytesBE()) args.SetAmount(p.Amount) args.SetDetails(p.Details) + args.InvokePrmOptional = p.InvokePrmOptional return w.client.TransferX(args) } +// MintPrm groups parameters of Mint operation. +type MintPrm struct { + to util.Uint160 + amount int64 + id []byte + + client.InvokePrmOptional +} + +// SetTo sets receiver of the transfer. +func (m *MintPrm) SetTo(to util.Uint160) { + m.to = to +} + +// SetAmount sets amount of the transfer. +func (m *MintPrm) SetAmount(amount int64) { + m.amount = amount +} + +// SetID sets ID. +func (m *MintPrm) SetID(id []byte) { + m.id = id +} + // Mint sends funds to the account. -func (w *Wrapper) Mint(to util.Uint160, amount int64, id []byte) error { - return w.client.Mint(to.BytesBE(), amount, id) +func (w *Wrapper) Mint(prm MintPrm) error { + args := balance.MintPrm{} + + args.SetTo(prm.to.BytesBE()) + args.SetAmount(prm.amount) + args.SetID(prm.id) + args.InvokePrmOptional = prm.InvokePrmOptional + + return w.client.Mint(args) +} + +// BurnPrm groups parameters of Burn operation. +type BurnPrm struct { + to util.Uint160 + amount int64 + id []byte + + client.InvokePrmOptional +} + +// SetTo sets receiver. +func (b *BurnPrm) SetTo(to util.Uint160) { + b.to = to +} + +// SetAmount sets amount. +func (b *BurnPrm) SetAmount(amount int64) { + b.amount = amount +} + +// SetID sets ID +func (b *BurnPrm) SetID(id []byte) { + b.id = id } // Burn destroys funds from the account. -func (w *Wrapper) Burn(to util.Uint160, amount int64, id []byte) error { - return w.client.Burn(to.BytesBE(), amount, id) +func (w *Wrapper) Burn(prm BurnPrm) error { + args := balance.BurnPrm{} + + args.SetTo(prm.to.BytesBE()) + args.SetAmount(prm.amount) + args.SetID(prm.id) + args.InvokePrmOptional = prm.InvokePrmOptional + + return w.client.Burn(args) +} + +// LockPrm groups parameters of Lock operation. +type LockPrm struct { + id []byte + user util.Uint160 + lock util.Uint160 + amount int64 + dueEpoch int64 + + client.InvokePrmOptional +} + +// SetID sets ID. +func (l *LockPrm) SetID(id []byte) { + l.id = id +} + +// SetUser set user. +func (l *LockPrm) SetUser(user util.Uint160) { + l.user = user +} + +// SetLock sets lock. +func (l *LockPrm) SetLock(lock util.Uint160) { + l.lock = lock +} + +// SetAmount sets amount. +func (l *LockPrm) SetAmount(amount int64) { + l.amount = amount +} + +// SetDueEpoch sets end of the lock. +func (l *LockPrm) SetDueEpoch(dueEpoch int64) { + l.dueEpoch = dueEpoch } // Lock locks fund on the user account. -func (w *Wrapper) Lock(id []byte, user, lock util.Uint160, amount, dueEpoch int64) error { - return w.client.Lock(id, user.BytesBE(), lock.BytesBE(), amount, dueEpoch) +func (w *Wrapper) Lock(prm LockPrm) error { + args := balance.LockPrm{} + + args.SetID(prm.id) + args.SetUser(prm.user.BytesBE()) + args.SetLock(prm.lock.BytesBE()) + args.SetAmount(prm.amount) + args.SetDueEpoch(prm.dueEpoch) + args.InvokePrmOptional = prm.InvokePrmOptional + + return w.client.Lock(args) }