dstepanov-yadro/neoneo-go
1
0
Fork 0
forked from TrueCloudLab/neoneo-go
Code Pull requests Activity

rpcclient/nep11: make DivisibleWriter part reusable

Browse source 
Same rationale as for BaseWriter or nep17.TokenWriter, otherwise it's hard to
build on top of plain Divisible structure.
This commit is contained in:
Roman Khimov 2022-10-27 16:18:00 +03:00
parent b590d4ca04
commit bb47d971dc
1 changed files with 13 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
pkg/rpcclient/nep11/divisible.go
View file

@ -16,10 +16,17 @@ type DivisibleReader struct {
BaseReader BaseReader
} }
// Divisible is a state-changing interface for divisible NEP-11 contract. // DivisibleWriter is a state-changing interface for divisible NEP-11 contract.
// It's mostly useful not directly, but as a reusable layer for higher-level
// structures.
type DivisibleWriter struct {
BaseWriter
}
// Divisible is a full reader interface for divisible NEP-11 contract.
type Divisible struct { type Divisible struct {
DivisibleReader DivisibleReader
BaseWriter DivisibleWriter
} }
// OwnerIterator is used for iterating over OwnerOf (for divisible NFTs) results. // OwnerIterator is used for iterating over OwnerOf (for divisible NFTs) results.
@ -38,7 +45,7 @@ func NewDivisibleReader(invoker Invoker, hash util.Uint160) *DivisibleReader {
// NewDivisible creates an instance of Divisible for a contract // NewDivisible creates an instance of Divisible for a contract
// with the given hash using the given actor. // with the given hash using the given actor.
func NewDivisible(actor Actor, hash util.Uint160) *Divisible { func NewDivisible(actor Actor, hash util.Uint160) *Divisible {
return &Divisible{*NewDivisibleReader(actor, hash), BaseWriter{hash, actor}} return &Divisible{*NewDivisibleReader(actor, hash), DivisibleWriter{BaseWriter{hash, actor}}}
} }
// OwnerOf returns returns an iterator that allows to walk through all owners of // OwnerOf returns returns an iterator that allows to walk through all owners of
@ -72,7 +79,7 @@ func (t *DivisibleReader) BalanceOfD(owner util.Uint160, token []byte) (*big.Int
// method call using the given parameters and checks for this call result, // method call using the given parameters and checks for this call result,
// failing the transaction if it's not true. The returned values are transaction // failing the transaction if it's not true. The returned values are transaction
// hash, its ValidUntilBlock value and an error if any. // hash, its ValidUntilBlock value and an error if any.
func (t *Divisible) TransferD(from util.Uint160, to util.Uint160, amount *big.Int, id []byte, data interface{}) (util.Uint256, uint32, error) { func (t *DivisibleWriter) TransferD(from util.Uint160, to util.Uint160, amount *big.Int, id []byte, data interface{}) (util.Uint256, uint32, error) {
script, err := t.transferScript(from, to, amount, id, data) script, err := t.transferScript(from, to, amount, id, data)
if err != nil { if err != nil {
return util.Uint256{}, 0, err return util.Uint256{}, 0, err
@ -85,7 +92,7 @@ func (t *Divisible) TransferD(from util.Uint160, to util.Uint160, amount *big.In
// `transfer` method call using the given parameters and checks for this call // `transfer` method call using the given parameters and checks for this call
// result, failing the transaction if it's not true. This transaction is signed, // result, failing the transaction if it's not true. This transaction is signed,
// but not sent to the network, instead it's returned to the caller. // but not sent to the network, instead it's returned to the caller.
func (t *Divisible) TransferDTransaction(from util.Uint160, to util.Uint160, amount *big.Int, id []byte, data interface{}) (*transaction.Transaction, error) { func (t *DivisibleWriter) TransferDTransaction(from util.Uint160, to util.Uint160, amount *big.Int, id []byte, data interface{}) (*transaction.Transaction, error) {
script, err := t.transferScript(from, to, amount, id, data) script, err := t.transferScript(from, to, amount, id, data)
if err != nil { if err != nil {
return nil, err return nil, err
@ -98,7 +105,7 @@ func (t *Divisible) TransferDTransaction(from util.Uint160, to util.Uint160, amo
// `transfer` method call using the given parameters and checks for this call // `transfer` method call using the given parameters and checks for this call
// result, failing the transaction if it's not true. This transaction is not // result, failing the transaction if it's not true. This transaction is not
// signed and just returned to the caller. // signed and just returned to the caller.
func (t *Divisible) TransferDUnsigned(from util.Uint160, to util.Uint160, amount *big.Int, id []byte, data interface{}) (*transaction.Transaction, error) { func (t *DivisibleWriter) TransferDUnsigned(from util.Uint160, to util.Uint160, amount *big.Int, id []byte, data interface{}) (*transaction.Transaction, error) {
script, err := t.transferScript(from, to, amount, id, data) script, err := t.transferScript(from, to, amount, id, data)
if err != nil { if err != nil {
return nil, err return nil, err