TrueCloudLab/neo-go
8
0
Fork 0
mirror of https://github.com/nspcc-dev/neo-go.git synced 2025-03-12 23:18:36 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #3804 from nspcc-dev/toscparameter

Browse source 
rpcbinding: expand struct generator with ToSCParameter
This commit is contained in:
Roman Khimov 2025-02-04 17:52:41 +03:00 • committed by GitHub
commit 3fa02d062b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 1938 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
cli/smartcontract/testdata/rpcbindings/nft-nd/rpcbindings.out vendored
View file

@ -211,6 +211,9 @@ func itemToNftRoyaltyRecipientShare(item stackitem.Item, err error) (*NftRoyalty
// Ensure *NftRoyaltyRecipientShare is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&NftRoyaltyRecipientShare{})
// Ensure *NftRoyaltyRecipientShare is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&NftRoyaltyRecipientShare{})
// FromStackItem retrieves fields of NftRoyaltyRecipientShare from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -278,3 +281,31 @@ func (res *NftRoyaltyRecipientShare) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing NftRoyaltyRecipientShare.
// It implements [smartcontract.Convertible] interface so that NftRoyaltyRecipientShare
// could be used with invokers.
func (res *NftRoyaltyRecipientShare) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.Address)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Address: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Share)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Share: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}

31
cli/smartcontract/testdata/rpcbindings/nft-nd/rpcbindings_dynamic_hash.out vendored
View file

@ -206,6 +206,9 @@ func itemToNftRoyaltyRecipientShare(item stackitem.Item, err error) (*NftRoyalty
// Ensure *NftRoyaltyRecipientShare is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&NftRoyaltyRecipientShare{})
// Ensure *NftRoyaltyRecipientShare is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&NftRoyaltyRecipientShare{})
// FromStackItem retrieves fields of NftRoyaltyRecipientShare from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -273,3 +276,31 @@ func (res *NftRoyaltyRecipientShare) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing NftRoyaltyRecipientShare.
// It implements [smartcontract.Convertible] interface so that NftRoyaltyRecipientShare
// could be used with invokers.
func (res *NftRoyaltyRecipientShare) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.Address)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Address: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Share)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Share: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}

57
cli/smartcontract/testdata/rpcbindings/notifications/rpcbindings_extended.out vendored
View file

@ -8,6 +8,7 @@ import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/core/transaction"
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"math/big"
@ -203,6 +204,9 @@ func itemToCrazyStruct(item stackitem.Item, err error) (*CrazyStruct, error) {
// Ensure *CrazyStruct is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&CrazyStruct{})
// Ensure *CrazyStruct is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&CrazyStruct{})
// FromStackItem retrieves fields of CrazyStruct from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -261,6 +265,34 @@ func (res *CrazyStruct) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing CrazyStruct.
// It implements [smartcontract.Convertible] interface so that CrazyStruct
// could be used with invokers.
func (res *CrazyStruct) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.I)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field I: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.B)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field B: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToSimpleStruct converts stack item into *SimpleStruct.
// NULL item is returned as nil pointer without error.
func itemToSimpleStruct(item stackitem.Item, err error) (*SimpleStruct, error) {
@ -279,6 +311,9 @@ func itemToSimpleStruct(item stackitem.Item, err error) (*SimpleStruct, error) {
// Ensure *SimpleStruct is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&SimpleStruct{})
// Ensure *SimpleStruct is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&SimpleStruct{})
// FromStackItem retrieves fields of SimpleStruct from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -325,6 +360,28 @@ func (res *SimpleStruct) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing SimpleStruct.
// It implements [smartcontract.Convertible] interface so that SimpleStruct
// could be used with invokers.
func (res *SimpleStruct) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 1)
)
prm, err = smartcontract.NewParameterFromValue(res.I)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field I: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// ComplicatedNameEventsFromApplicationLog retrieves a set of all emitted events
// with "! complicated name %$#" name from the provided [result.ApplicationLog].
func ComplicatedNameEventsFromApplicationLog(log *result.ApplicationLog) ([]*ComplicatedNameEvent, error) {

57
cli/smartcontract/testdata/rpcbindings/notifications/rpcbindings_guessed.out vendored
View file

@ -8,6 +8,7 @@ import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/core/transaction"
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"math/big"
@ -203,6 +204,9 @@ func itemToUnnamed(item stackitem.Item, err error) (*Unnamed, error) {
// Ensure *Unnamed is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&Unnamed{})
// Ensure *Unnamed is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&Unnamed{})
// FromStackItem retrieves fields of Unnamed from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -261,6 +265,34 @@ func (res *Unnamed) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing Unnamed.
// It implements [smartcontract.Convertible] interface so that Unnamed
// could be used with invokers.
func (res *Unnamed) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.I)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field I: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.B)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field B: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToUnnamedX converts stack item into *UnnamedX.
// NULL item is returned as nil pointer without error.
func itemToUnnamedX(item stackitem.Item, err error) (*UnnamedX, error) {
@ -279,6 +311,9 @@ func itemToUnnamedX(item stackitem.Item, err error) (*UnnamedX, error) {
// Ensure *UnnamedX is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&UnnamedX{})
// Ensure *UnnamedX is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&UnnamedX{})
// FromStackItem retrieves fields of UnnamedX from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -325,6 +360,28 @@ func (res *UnnamedX) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing UnnamedX.
// It implements [smartcontract.Convertible] interface so that UnnamedX
// could be used with invokers.
func (res *UnnamedX) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 1)
)
prm, err = smartcontract.NewParameterFromValue(res.I)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field I: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// ComplicatedNameEventsFromApplicationLog retrieves a set of all emitted events
// with "! complicated name %$#" name from the provided [result.ApplicationLog].
func ComplicatedNameEventsFromApplicationLog(log *result.ApplicationLog) ([]*ComplicatedNameEvent, error) {

774
cli/smartcontract/testdata/rpcbindings/structs/rpcbindings.out vendored
View file

@ -10,6 +10,7 @@ import (
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"math/big"
@ -178,6 +179,9 @@ func itemToLedgerBlock(item stackitem.Item, err error) (*LedgerBlock, error) {
// Ensure *LedgerBlock is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&LedgerBlock{})
// Ensure *LedgerBlock is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&LedgerBlock{})
// FromStackItem retrieves fields of LedgerBlock from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -372,6 +376,82 @@ func (res *LedgerBlock) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing LedgerBlock.
// It implements [smartcontract.Convertible] interface so that LedgerBlock
// could be used with invokers.
func (res *LedgerBlock) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 10)
)
prm, err = smartcontract.NewParameterFromValue(res.Hash)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Hash: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Version)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Version: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.PrevHash)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PrevHash: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.MerkleRoot)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field MerkleRoot: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Timestamp)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Timestamp: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Nonce)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Nonce: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Index)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Index: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.PrimaryIndex)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PrimaryIndex: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.NextConsensus)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field NextConsensus: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.TransactionsLength)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field TransactionsLength: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToLedgerTransaction converts stack item into *LedgerTransaction.
// NULL item is returned as nil pointer without error.
func itemToLedgerTransaction(item stackitem.Item, err error) (*LedgerTransaction, error) {
@ -390,6 +470,9 @@ func itemToLedgerTransaction(item stackitem.Item, err error) (*LedgerTransaction
// Ensure *LedgerTransaction is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&LedgerTransaction{})
// Ensure *LedgerTransaction is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&LedgerTransaction{})
// FromStackItem retrieves fields of LedgerTransaction from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -540,6 +623,70 @@ func (res *LedgerTransaction) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing LedgerTransaction.
// It implements [smartcontract.Convertible] interface so that LedgerTransaction
// could be used with invokers.
func (res *LedgerTransaction) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 8)
)
prm, err = smartcontract.NewParameterFromValue(res.Hash)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Hash: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Version)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Version: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Nonce)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Nonce: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Sender)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Sender: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.SysFee)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field SysFee: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.NetFee)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field NetFee: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.ValidUntilBlock)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ValidUntilBlock: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Script)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Script: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementABI converts stack item into *ManagementABI.
// NULL item is returned as nil pointer without error.
func itemToManagementABI(item stackitem.Item, err error) (*ManagementABI, error) {
@ -558,6 +705,9 @@ func itemToManagementABI(item stackitem.Item, err error) (*ManagementABI, error)
// Ensure *ManagementABI is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementABI{})
// Ensure *ManagementABI is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementABI{})
// FromStackItem retrieves fields of ManagementABI from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -670,6 +820,62 @@ func (res *ManagementABI) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementABI.
// It implements [smartcontract.Convertible] interface so that ManagementABI
// could be used with invokers.
func (res *ManagementABI) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = func(in []*ManagementMethod) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Methods)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Methods: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementEvent) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Events)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Events: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementContract converts stack item into *ManagementContract.
// NULL item is returned as nil pointer without error.
func itemToManagementContract(item stackitem.Item, err error) (*ManagementContract, error) {
@ -688,6 +894,9 @@ func itemToManagementContract(item stackitem.Item, err error) (*ManagementContra
// Ensure *ManagementContract is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementContract{})
// Ensure *ManagementContract is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementContract{})
// FromStackItem retrieves fields of ManagementContract from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -792,6 +1001,52 @@ func (res *ManagementContract) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementContract.
// It implements [smartcontract.Convertible] interface so that ManagementContract
// could be used with invokers.
func (res *ManagementContract) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 5)
)
prm, err = smartcontract.NewParameterFromValue(res.ID)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ID: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.UpdateCounter)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field UpdateCounter: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Hash)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Hash: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.NEF)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field NEF: %w", err)
}
prms = append(prms, prm)
prm, err = res.Manifest.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Manifest: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementEvent converts stack item into *ManagementEvent.
// NULL item is returned as nil pointer without error.
func itemToManagementEvent(item stackitem.Item, err error) (*ManagementEvent, error) {
@ -810,6 +1065,9 @@ func itemToManagementEvent(item stackitem.Item, err error) (*ManagementEvent, er
// Ensure *ManagementEvent is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementEvent{})
// Ensure *ManagementEvent is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementEvent{})
// FromStackItem retrieves fields of ManagementEvent from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -904,6 +1162,48 @@ func (res *ManagementEvent) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementEvent.
// It implements [smartcontract.Convertible] interface so that ManagementEvent
// could be used with invokers.
func (res *ManagementEvent) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.Name)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Name: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementParameter) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Params)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Params: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementGroup converts stack item into *ManagementGroup.
// NULL item is returned as nil pointer without error.
func itemToManagementGroup(item stackitem.Item, err error) (*ManagementGroup, error) {
@ -922,6 +1222,9 @@ func itemToManagementGroup(item stackitem.Item, err error) (*ManagementGroup, er
// Ensure *ManagementGroup is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementGroup{})
// Ensure *ManagementGroup is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementGroup{})
// FromStackItem retrieves fields of ManagementGroup from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -990,6 +1293,34 @@ func (res *ManagementGroup) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementGroup.
// It implements [smartcontract.Convertible] interface so that ManagementGroup
// could be used with invokers.
func (res *ManagementGroup) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.PublicKey)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PublicKey: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Signature)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Signature: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementManifest converts stack item into *ManagementManifest.
// NULL item is returned as nil pointer without error.
func itemToManagementManifest(item stackitem.Item, err error) (*ManagementManifest, error) {
@ -1008,6 +1339,9 @@ func itemToManagementManifest(item stackitem.Item, err error) (*ManagementManife
// Ensure *ManagementManifest is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementManifest{})
// Ensure *ManagementManifest is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementManifest{})
// FromStackItem retrieves fields of ManagementManifest from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -1328,6 +1662,144 @@ func (res *ManagementManifest) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementManifest.
// It implements [smartcontract.Convertible] interface so that ManagementManifest
// could be used with invokers.
func (res *ManagementManifest) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 8)
)
prm, err = smartcontract.NewParameterFromValue(res.Name)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Name: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementGroup) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Groups)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Groups: %w", err)
}
prms = append(prms, prm)
prm, err = func(in map[string]string) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.ParameterPair, 0, len(in))
for k, v := range in {
iKey, err := smartcontract.NewParameterFromValue(k)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v: %w", k, err)
}
iVal, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v, wrong value: %w", k, err)
}
prms = append(prms, smartcontract.ParameterPair{Key: iKey, Value: iVal})
}
return smartcontract.Parameter{Type: smartcontract.MapType, Value: prms}, nil
}(res.Features)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Features: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []string) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.SupportedStandards)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field SupportedStandards: %w", err)
}
prms = append(prms, prm)
prm, err = res.ABI.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ABI: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementPermission) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Permissions)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Permissions: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []util.Uint160) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Trusts)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Trusts: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Extra)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Extra: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementMethod converts stack item into *ManagementMethod.
// NULL item is returned as nil pointer without error.
func itemToManagementMethod(item stackitem.Item, err error) (*ManagementMethod, error) {
@ -1346,6 +1818,9 @@ func itemToManagementMethod(item stackitem.Item, err error) (*ManagementMethod,
// Ensure *ManagementMethod is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementMethod{})
// Ensure *ManagementMethod is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementMethod{})
// FromStackItem retrieves fields of ManagementMethod from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -1476,6 +1951,66 @@ func (res *ManagementMethod) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementMethod.
// It implements [smartcontract.Convertible] interface so that ManagementMethod
// could be used with invokers.
func (res *ManagementMethod) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 5)
)
prm, err = smartcontract.NewParameterFromValue(res.Name)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Name: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementParameter) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Params)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Params: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.ReturnType)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ReturnType: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Offset)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Offset: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Safe)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Safe: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementParameter converts stack item into *ManagementParameter.
// NULL item is returned as nil pointer without error.
func itemToManagementParameter(item stackitem.Item, err error) (*ManagementParameter, error) {
@ -1494,6 +2029,9 @@ func itemToManagementParameter(item stackitem.Item, err error) (*ManagementParam
// Ensure *ManagementParameter is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementParameter{})
// Ensure *ManagementParameter is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementParameter{})
// FromStackItem retrieves fields of ManagementParameter from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -1561,6 +2099,34 @@ func (res *ManagementParameter) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementParameter.
// It implements [smartcontract.Convertible] interface so that ManagementParameter
// could be used with invokers.
func (res *ManagementParameter) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.Name)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Name: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Type)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Type: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementPermission converts stack item into *ManagementPermission.
// NULL item is returned as nil pointer without error.
func itemToManagementPermission(item stackitem.Item, err error) (*ManagementPermission, error) {
@ -1579,6 +2145,9 @@ func itemToManagementPermission(item stackitem.Item, err error) (*ManagementPerm
// Ensure *ManagementPermission is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementPermission{})
// Ensure *ManagementPermission is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementPermission{})
// FromStackItem retrieves fields of ManagementPermission from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -1683,6 +2252,48 @@ func (res *ManagementPermission) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementPermission.
// It implements [smartcontract.Convertible] interface so that ManagementPermission
// could be used with invokers.
func (res *ManagementPermission) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.Contract)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Contract: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []string) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Methods)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Methods: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToStructsInternal converts stack item into *StructsInternal.
// NULL item is returned as nil pointer without error.
func itemToStructsInternal(item stackitem.Item, err error) (*StructsInternal, error) {
@ -1701,6 +2312,9 @@ func itemToStructsInternal(item stackitem.Item, err error) (*StructsInternal, er
// Ensure *StructsInternal is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&StructsInternal{})
// Ensure *StructsInternal is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&StructsInternal{})
// FromStackItem retrieves fields of StructsInternal from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -2088,3 +2702,163 @@ func (res *StructsInternal) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing StructsInternal.
// It implements [smartcontract.Convertible] interface so that StructsInternal
// could be used with invokers.
func (res *StructsInternal) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 14)
)
prm, err = smartcontract.NewParameterFromValue(res.Bool)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Bool: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Int)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Int: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Bytes)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Bytes: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.String)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field String: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.H160)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field H160: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.H256)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field H256: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.PK)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PK: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.PubKey)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PubKey: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Sign)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Sign: %w", err)
}
prms = append(prms, prm)
prm, err = func(in [][]byte) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.ArrOfBytes)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ArrOfBytes: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []util.Uint160) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.ArrOfH160)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ArrOfH160: %w", err)
}
prms = append(prms, prm)
prm, err = func(in map[*big.Int]keys.PublicKeys) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.ParameterPair, 0, len(in))
for k, v := range in {
iKey, err := smartcontract.NewParameterFromValue(k)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v: %w", k, err)
}
iVal, err := func(in keys.PublicKeys) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v, wrong value: %w", k, err)
}
prms = append(prms, smartcontract.ParameterPair{Key: iKey, Value: iVal})
}
return smartcontract.Parameter{Type: smartcontract.MapType, Value: prms}, nil
}(res.Map)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Map: %w", err)
}
prms = append(prms, prm)
prm, err = res.Struct.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Struct: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.UnexportedField)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field UnexportedField: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}

774
cli/smartcontract/testdata/rpcbindings/structs/rpcbindings_dynamic_hash.out vendored
View file

@ -10,6 +10,7 @@ import (
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"math/big"
@ -174,6 +175,9 @@ func itemToLedgerBlock(item stackitem.Item, err error) (*LedgerBlock, error) {
// Ensure *LedgerBlock is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&LedgerBlock{})
// Ensure *LedgerBlock is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&LedgerBlock{})
// FromStackItem retrieves fields of LedgerBlock from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -368,6 +372,82 @@ func (res *LedgerBlock) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing LedgerBlock.
// It implements [smartcontract.Convertible] interface so that LedgerBlock
// could be used with invokers.
func (res *LedgerBlock) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 10)
)
prm, err = smartcontract.NewParameterFromValue(res.Hash)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Hash: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Version)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Version: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.PrevHash)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PrevHash: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.MerkleRoot)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field MerkleRoot: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Timestamp)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Timestamp: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Nonce)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Nonce: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Index)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Index: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.PrimaryIndex)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PrimaryIndex: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.NextConsensus)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field NextConsensus: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.TransactionsLength)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field TransactionsLength: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToLedgerTransaction converts stack item into *LedgerTransaction.
// NULL item is returned as nil pointer without error.
func itemToLedgerTransaction(item stackitem.Item, err error) (*LedgerTransaction, error) {
@ -386,6 +466,9 @@ func itemToLedgerTransaction(item stackitem.Item, err error) (*LedgerTransaction
// Ensure *LedgerTransaction is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&LedgerTransaction{})
// Ensure *LedgerTransaction is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&LedgerTransaction{})
// FromStackItem retrieves fields of LedgerTransaction from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -536,6 +619,70 @@ func (res *LedgerTransaction) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing LedgerTransaction.
// It implements [smartcontract.Convertible] interface so that LedgerTransaction
// could be used with invokers.
func (res *LedgerTransaction) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 8)
)
prm, err = smartcontract.NewParameterFromValue(res.Hash)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Hash: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Version)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Version: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Nonce)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Nonce: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Sender)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Sender: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.SysFee)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field SysFee: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.NetFee)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field NetFee: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.ValidUntilBlock)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ValidUntilBlock: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Script)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Script: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementABI converts stack item into *ManagementABI.
// NULL item is returned as nil pointer without error.
func itemToManagementABI(item stackitem.Item, err error) (*ManagementABI, error) {
@ -554,6 +701,9 @@ func itemToManagementABI(item stackitem.Item, err error) (*ManagementABI, error)
// Ensure *ManagementABI is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementABI{})
// Ensure *ManagementABI is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementABI{})
// FromStackItem retrieves fields of ManagementABI from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -666,6 +816,62 @@ func (res *ManagementABI) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementABI.
// It implements [smartcontract.Convertible] interface so that ManagementABI
// could be used with invokers.
func (res *ManagementABI) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = func(in []*ManagementMethod) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Methods)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Methods: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementEvent) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Events)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Events: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementContract converts stack item into *ManagementContract.
// NULL item is returned as nil pointer without error.
func itemToManagementContract(item stackitem.Item, err error) (*ManagementContract, error) {
@ -684,6 +890,9 @@ func itemToManagementContract(item stackitem.Item, err error) (*ManagementContra
// Ensure *ManagementContract is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementContract{})
// Ensure *ManagementContract is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementContract{})
// FromStackItem retrieves fields of ManagementContract from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -788,6 +997,52 @@ func (res *ManagementContract) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementContract.
// It implements [smartcontract.Convertible] interface so that ManagementContract
// could be used with invokers.
func (res *ManagementContract) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 5)
)
prm, err = smartcontract.NewParameterFromValue(res.ID)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ID: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.UpdateCounter)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field UpdateCounter: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Hash)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Hash: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.NEF)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field NEF: %w", err)
}
prms = append(prms, prm)
prm, err = res.Manifest.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Manifest: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementEvent converts stack item into *ManagementEvent.
// NULL item is returned as nil pointer without error.
func itemToManagementEvent(item stackitem.Item, err error) (*ManagementEvent, error) {
@ -806,6 +1061,9 @@ func itemToManagementEvent(item stackitem.Item, err error) (*ManagementEvent, er
// Ensure *ManagementEvent is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementEvent{})
// Ensure *ManagementEvent is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementEvent{})
// FromStackItem retrieves fields of ManagementEvent from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -900,6 +1158,48 @@ func (res *ManagementEvent) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementEvent.
// It implements [smartcontract.Convertible] interface so that ManagementEvent
// could be used with invokers.
func (res *ManagementEvent) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.Name)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Name: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementParameter) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Params)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Params: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementGroup converts stack item into *ManagementGroup.
// NULL item is returned as nil pointer without error.
func itemToManagementGroup(item stackitem.Item, err error) (*ManagementGroup, error) {
@ -918,6 +1218,9 @@ func itemToManagementGroup(item stackitem.Item, err error) (*ManagementGroup, er
// Ensure *ManagementGroup is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementGroup{})
// Ensure *ManagementGroup is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementGroup{})
// FromStackItem retrieves fields of ManagementGroup from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -986,6 +1289,34 @@ func (res *ManagementGroup) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementGroup.
// It implements [smartcontract.Convertible] interface so that ManagementGroup
// could be used with invokers.
func (res *ManagementGroup) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.PublicKey)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PublicKey: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Signature)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Signature: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementManifest converts stack item into *ManagementManifest.
// NULL item is returned as nil pointer without error.
func itemToManagementManifest(item stackitem.Item, err error) (*ManagementManifest, error) {
@ -1004,6 +1335,9 @@ func itemToManagementManifest(item stackitem.Item, err error) (*ManagementManife
// Ensure *ManagementManifest is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementManifest{})
// Ensure *ManagementManifest is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementManifest{})
// FromStackItem retrieves fields of ManagementManifest from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -1324,6 +1658,144 @@ func (res *ManagementManifest) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementManifest.
// It implements [smartcontract.Convertible] interface so that ManagementManifest
// could be used with invokers.
func (res *ManagementManifest) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 8)
)
prm, err = smartcontract.NewParameterFromValue(res.Name)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Name: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementGroup) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Groups)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Groups: %w", err)
}
prms = append(prms, prm)
prm, err = func(in map[string]string) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.ParameterPair, 0, len(in))
for k, v := range in {
iKey, err := smartcontract.NewParameterFromValue(k)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v: %w", k, err)
}
iVal, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v, wrong value: %w", k, err)
}
prms = append(prms, smartcontract.ParameterPair{Key: iKey, Value: iVal})
}
return smartcontract.Parameter{Type: smartcontract.MapType, Value: prms}, nil
}(res.Features)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Features: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []string) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.SupportedStandards)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field SupportedStandards: %w", err)
}
prms = append(prms, prm)
prm, err = res.ABI.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ABI: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementPermission) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Permissions)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Permissions: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []util.Uint160) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Trusts)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Trusts: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Extra)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Extra: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementMethod converts stack item into *ManagementMethod.
// NULL item is returned as nil pointer without error.
func itemToManagementMethod(item stackitem.Item, err error) (*ManagementMethod, error) {
@ -1342,6 +1814,9 @@ func itemToManagementMethod(item stackitem.Item, err error) (*ManagementMethod,
// Ensure *ManagementMethod is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementMethod{})
// Ensure *ManagementMethod is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementMethod{})
// FromStackItem retrieves fields of ManagementMethod from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -1472,6 +1947,66 @@ func (res *ManagementMethod) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementMethod.
// It implements [smartcontract.Convertible] interface so that ManagementMethod
// could be used with invokers.
func (res *ManagementMethod) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 5)
)
prm, err = smartcontract.NewParameterFromValue(res.Name)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Name: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []*ManagementParameter) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := v.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Params)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Params: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.ReturnType)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ReturnType: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Offset)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Offset: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Safe)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Safe: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementParameter converts stack item into *ManagementParameter.
// NULL item is returned as nil pointer without error.
func itemToManagementParameter(item stackitem.Item, err error) (*ManagementParameter, error) {
@ -1490,6 +2025,9 @@ func itemToManagementParameter(item stackitem.Item, err error) (*ManagementParam
// Ensure *ManagementParameter is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementParameter{})
// Ensure *ManagementParameter is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementParameter{})
// FromStackItem retrieves fields of ManagementParameter from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -1557,6 +2095,34 @@ func (res *ManagementParameter) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementParameter.
// It implements [smartcontract.Convertible] interface so that ManagementParameter
// could be used with invokers.
func (res *ManagementParameter) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.Name)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Name: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Type)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Type: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToManagementPermission converts stack item into *ManagementPermission.
// NULL item is returned as nil pointer without error.
func itemToManagementPermission(item stackitem.Item, err error) (*ManagementPermission, error) {
@ -1575,6 +2141,9 @@ func itemToManagementPermission(item stackitem.Item, err error) (*ManagementPerm
// Ensure *ManagementPermission is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&ManagementPermission{})
// Ensure *ManagementPermission is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&ManagementPermission{})
// FromStackItem retrieves fields of ManagementPermission from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -1679,6 +2248,48 @@ func (res *ManagementPermission) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing ManagementPermission.
// It implements [smartcontract.Convertible] interface so that ManagementPermission
// could be used with invokers.
func (res *ManagementPermission) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.Contract)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Contract: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []string) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.Methods)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Methods: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToStructsInternal converts stack item into *StructsInternal.
// NULL item is returned as nil pointer without error.
func itemToStructsInternal(item stackitem.Item, err error) (*StructsInternal, error) {
@ -1697,6 +2308,9 @@ func itemToStructsInternal(item stackitem.Item, err error) (*StructsInternal, er
// Ensure *StructsInternal is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&StructsInternal{})
// Ensure *StructsInternal is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&StructsInternal{})
// FromStackItem retrieves fields of StructsInternal from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -2084,3 +2698,163 @@ func (res *StructsInternal) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing StructsInternal.
// It implements [smartcontract.Convertible] interface so that StructsInternal
// could be used with invokers.
func (res *StructsInternal) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 14)
)
prm, err = smartcontract.NewParameterFromValue(res.Bool)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Bool: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Int)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Int: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Bytes)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Bytes: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.String)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field String: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.H160)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field H160: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.H256)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field H256: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.PK)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PK: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.PubKey)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field PubKey: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.Sign)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Sign: %w", err)
}
prms = append(prms, prm)
prm, err = func(in [][]byte) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.ArrOfBytes)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ArrOfBytes: %w", err)
}
prms = append(prms, prm)
prm, err = func(in []util.Uint160) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(res.ArrOfH160)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field ArrOfH160: %w", err)
}
prms = append(prms, prm)
prm, err = func(in map[*big.Int]keys.PublicKeys) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.ParameterPair, 0, len(in))
for k, v := range in {
iKey, err := smartcontract.NewParameterFromValue(k)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v: %w", k, err)
}
iVal, err := func(in keys.PublicKeys) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := smartcontract.NewParameterFromValue(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(v)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v, wrong value: %w", k, err)
}
prms = append(prms, smartcontract.ParameterPair{Key: iKey, Value: iVal})
}
return smartcontract.Parameter{Type: smartcontract.MapType, Value: prms}, nil
}(res.Map)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Map: %w", err)
}
prms = append(prms, prm)
prm, err = res.Struct.ToSCParameter()
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field Struct: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.UnexportedField)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field UnexportedField: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}

57
cli/smartcontract/testdata/rpcbindings/types/rpcbindings.out vendored
View file

@ -9,6 +9,7 @@ import (
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"math/big"
@ -387,6 +388,9 @@ func itemToUnnamed(item stackitem.Item, err error) (*Unnamed, error) {
// Ensure *Unnamed is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&Unnamed{})
// Ensure *Unnamed is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&Unnamed{})
// FromStackItem retrieves fields of Unnamed from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -433,6 +437,28 @@ func (res *Unnamed) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing Unnamed.
// It implements [smartcontract.Convertible] interface so that Unnamed
// could be used with invokers.
func (res *Unnamed) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 1)
)
prm, err = smartcontract.NewParameterFromValue(res.I)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field I: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToUnnamedX converts stack item into *UnnamedX.
// NULL item is returned as nil pointer without error.
func itemToUnnamedX(item stackitem.Item, err error) (*UnnamedX, error) {
@ -451,6 +477,9 @@ func itemToUnnamedX(item stackitem.Item, err error) (*UnnamedX, error) {
// Ensure *UnnamedX is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&UnnamedX{})
// Ensure *UnnamedX is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&UnnamedX{})
// FromStackItem retrieves fields of UnnamedX from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -508,3 +537,31 @@ func (res *UnnamedX) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing UnnamedX.
// It implements [smartcontract.Convertible] interface so that UnnamedX
// could be used with invokers.
func (res *UnnamedX) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.I)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field I: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.B)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field B: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}

57
cli/smartcontract/testdata/rpcbindings/types/rpcbindings_dynamic_hash.out vendored
View file

@ -9,6 +9,7 @@ import (
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"math/big"
@ -383,6 +384,9 @@ func itemToUnnamed(item stackitem.Item, err error) (*Unnamed, error) {
// Ensure *Unnamed is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&Unnamed{})
// Ensure *Unnamed is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&Unnamed{})
// FromStackItem retrieves fields of Unnamed from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -429,6 +433,28 @@ func (res *Unnamed) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing Unnamed.
// It implements [smartcontract.Convertible] interface so that Unnamed
// could be used with invokers.
func (res *Unnamed) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 1)
)
prm, err = smartcontract.NewParameterFromValue(res.I)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field I: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
// itemToUnnamedX converts stack item into *UnnamedX.
// NULL item is returned as nil pointer without error.
func itemToUnnamedX(item stackitem.Item, err error) (*UnnamedX, error) {
@ -447,6 +473,9 @@ func itemToUnnamedX(item stackitem.Item, err error) (*UnnamedX, error) {
// Ensure *UnnamedX is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&UnnamedX{})
// Ensure *UnnamedX is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&UnnamedX{})
// FromStackItem retrieves fields of UnnamedX from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -504,3 +533,31 @@ func (res *UnnamedX) ToStackItem() (stackitem.Item, error) {
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing UnnamedX.
// It implements [smartcontract.Convertible] interface so that UnnamedX
// could be used with invokers.
func (res *UnnamedX) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, 2)
)
prm, err = smartcontract.NewParameterFromValue(res.I)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field I: %w", err)
}
prms = append(prms, prm)
prm, err = smartcontract.NewParameterFromValue(res.B)
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field B: %w", err)
}
prms = append(prms, prm)
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}

100
pkg/smartcontract/rpcbinding/binding.go
View file

@ -262,6 +262,9 @@ func itemTo{{toTypeName $typ.Name}}(item stackitem.Item, err error) (*{{toTypeNa
// Ensure *{{toTypeName $typ.Name}} is a proper [stackitem.Convertible].
var _ = stackitem.Convertible(&{{toTypeName $typ.Name}}{})
// Ensure *{{toTypeName $typ.Name}} is a proper [smartcontract.Convertible].
var _ = smartcontract.Convertible(&{{toTypeName $typ.Name}}{})
// FromStackItem retrieves fields of {{toTypeName $typ.Name}} from the given
// [stackitem.Item] or returns an error if it's not possible to do to so.
// It implements [stackitem.Convertible] interface.
@ -311,6 +314,30 @@ func (res *{{toTypeName $typ.Name}}) ToStackItem() (stackitem.Item, error) {
{{end}}
return stackitem.NewStruct(items), nil
}
// ToSCParameter creates [smartcontract.Parameter] representing {{toTypeName $typ.Name}}.
// It implements [smartcontract.Convertible] interface so that {{toTypeName $typ.Name}}
// could be used with invokers.
func (res *{{toTypeName $typ.Name}}) ToSCParameter() (smartcontract.Parameter, error) {
if res == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var (
err error
prm smartcontract.Parameter
prms = make([]smartcontract.Parameter, 0, {{len .Fields}})
)
{{- range $m := $typ.Fields}}
prm, err = {{scTypeConverter .ExtendedType (print "res." (upperFirst .Field))}}
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("field {{ upperFirst .Field}}: %w", err)
}
prms = append(prms, prm)
{{end}}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}
{{ end -}}
{{- range $e := .CustomEvents }}
// {{$e.Name}}sFromApplicationLog retrieves a set of all emitted events
@ -531,6 +558,7 @@ func Generate(cfg binding.Config) error {
return r
},
"goTypeConverter": goTypeConverter,
"scTypeConverter": scTypeConverter,
"toTypeName": toTypeName,
"cutPointer": cutPointer,
"upperFirst": upperFirst,
@ -871,6 +899,77 @@ func goTypeConverter(et binding.ExtendedType, v string) string {
}
}
func scTypeConverter(et binding.ExtendedType, v string) string {
switch et.Base {
case smartcontract.AnyType, smartcontract.BoolType, smartcontract.IntegerType,
smartcontract.ByteArrayType, smartcontract.SignatureType, smartcontract.StringType,
smartcontract.Hash160Type, smartcontract.Hash256Type, smartcontract.PublicKeyType,
smartcontract.InteropInterfaceType, smartcontract.VoidType:
return "smartcontract.NewParameterFromValue(" + v + ")"
case smartcontract.ArrayType:
if len(et.Name) > 0 {
return v + ".ToSCParameter()"
} else if et.Value != nil {
at, _ := extendedTypeToGo(et, nil)
return `func(in ` + at + `) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.Parameter, 0, len(in))
for i, v := range in {
prm, err := ` + scTypeConverter(*et.Value, "v") + `
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("item %d: %w", i, err)
}
prms = append(prms, prm)
}
return smartcontract.Parameter{Type: smartcontract.ArrayType, Value: prms}, nil
}(` + v + `)`
}
return scTypeConverter(binding.ExtendedType{
Base: smartcontract.ArrayType,
Value: &binding.ExtendedType{
Base: smartcontract.AnyType,
},
}, v)
case smartcontract.MapType:
if et.Value != nil {
at, _ := extendedTypeToGo(et, nil)
return `func(in ` + at + `) (smartcontract.Parameter, error) {
if in == nil {
return smartcontract.Parameter{Type: smartcontract.AnyType}, nil
}
var prms = make([]smartcontract.ParameterPair, 0, len(in))
for k, v := range in {
iKey, err := ` + scTypeConverter(binding.ExtendedType{Base: et.Key}, "k") + `
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v: %w", k, err)
}
iVal, err := ` + scTypeConverter(*et.Value, "v") + `
if err != nil {
return smartcontract.Parameter{}, fmt.Errorf("key %v, wrong value: %w", k, err)
}
prms = append(prms, smartcontract.ParameterPair{Key: iKey, Value: iVal})
}
return smartcontract.Parameter{Type: smartcontract.MapType, Value: prms}, nil
}(` + v + `)`
}
return goTypeConverter(binding.ExtendedType{
Base: smartcontract.MapType,
Key: et.Key,
Value: &binding.ExtendedType{
Base: smartcontract.AnyType,
},
}, v)
default:
panic("unreachable")
}
}
func scTypeToGo(name string, typ smartcontract.ParamType, cfg *binding.Config) (string, string) {
et, ok := cfg.Types[name]
if !ok {
@ -911,6 +1010,7 @@ func scTemplateToRPC(cfg binding.Config, ctr ContractTmpl, imports map[string]st
}
if len(cfg.NamedTypes) > 0 {
imports["errors"] = struct{}{}
imports["github.com/nspcc-dev/neo-go/pkg/smartcontract"] = struct{}{}
}
for _, abiEvent := range cfg.Manifest.ABI.Events {
eBindingName := ToEventBindingName(abiEvent.Name)