github.com/nspcc-dev/neo-go@v0.105.2-0.20240517133400-6be757af3eba/pkg/core/state/contract_test.go (about)

     1  package state
     2  
     3  import (
     4  	"math"
     5  	"testing"
     6  
     7  	"github.com/nspcc-dev/neo-go/internal/testserdes"
     8  	"github.com/nspcc-dev/neo-go/pkg/crypto/hash"
     9  	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
    10  	"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
    11  	"github.com/nspcc-dev/neo-go/pkg/smartcontract/nef"
    12  	"github.com/nspcc-dev/neo-go/pkg/util"
    13  	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  func TestContractStateToFromSI(t *testing.T) {
    18  	script := []byte("testscript")
    19  
    20  	h := hash.Hash160(script)
    21  	m := manifest.NewManifest("Test")
    22  	m.ABI.Methods = []manifest.Method{{
    23  		Name: "main",
    24  		Parameters: []manifest.Parameter{
    25  			{
    26  				Name: "amount",
    27  				Type: smartcontract.IntegerType,
    28  			},
    29  			{
    30  				Name: "hash",
    31  				Type: smartcontract.Hash160Type,
    32  			},
    33  		},
    34  		ReturnType: smartcontract.BoolType,
    35  	}}
    36  	contract := &Contract{
    37  		UpdateCounter: 42,
    38  		ContractBase: ContractBase{
    39  			ID:   123,
    40  			Hash: h,
    41  			NEF: nef.File{
    42  				Header: nef.Header{
    43  					Magic:    nef.Magic,
    44  					Compiler: "neo-go.test-test",
    45  				},
    46  				Tokens:   []nef.MethodToken{},
    47  				Script:   script,
    48  				Checksum: 0,
    49  			},
    50  			Manifest: *m,
    51  		},
    52  	}
    53  	contract.NEF.Checksum = contract.NEF.CalculateChecksum()
    54  
    55  	t.Run("Convertible", func(t *testing.T) {
    56  		contractDecoded := new(Contract)
    57  		testserdes.ToFromStackItem(t, contract, contractDecoded)
    58  
    59  		t.Run("preserve wildcard trusts", func(t *testing.T) {
    60  			contract.Manifest.Trusts.Value = nil
    61  			require.True(t, contract.Manifest.Trusts.IsWildcard())
    62  			actual := new(Contract)
    63  			item, err := contract.ToStackItem()
    64  			require.NoError(t, err)
    65  			require.NoError(t, actual.FromStackItem(item))
    66  			require.True(t, actual.Manifest.Trusts.IsWildcard())
    67  		})
    68  	})
    69  	t.Run("JSON", func(t *testing.T) {
    70  		contractDecoded := new(Contract)
    71  		testserdes.MarshalUnmarshalJSON(t, contract, contractDecoded)
    72  	})
    73  }
    74  
    75  func TestCreateContractHash(t *testing.T) {
    76  	var neff = nef.File{
    77  		Header: nef.Header{
    78  			Compiler: "test",
    79  			Magic:    nef.Magic,
    80  		},
    81  		Tokens: []nef.MethodToken{},
    82  		Script: []byte{1, 2, 3},
    83  	}
    84  	var sender util.Uint160
    85  	var err error
    86  
    87  	neff.Checksum = neff.CalculateChecksum()
    88  	require.Equal(t, "9b9628e4f1611af90e761eea8cc21372380c74b6", CreateContractHash(sender, neff.Checksum, "").StringLE())
    89  	sender, err = util.Uint160DecodeStringLE("a400ff00ff00ff00ff00ff00ff00ff00ff00ff01")
    90  	require.NoError(t, err)
    91  	require.Equal(t, "66eec404d86b918d084e62a29ac9990e3b6f4286", CreateContractHash(sender, neff.Checksum, "").StringLE())
    92  }
    93  
    94  func TestContractFromStackItem(t *testing.T) {
    95  	var (
    96  		id           = stackitem.Make(42)
    97  		counter      = stackitem.Make(11)
    98  		chash        = stackitem.Make(util.Uint160{1, 2, 3}.BytesBE())
    99  		script       = []byte{0, 9, 8}
   100  		nefFile, _   = nef.NewFile(script)
   101  		rawNef, _    = nefFile.Bytes()
   102  		nefItem      = stackitem.NewByteArray(rawNef)
   103  		manifest     = manifest.DefaultManifest("stack item")
   104  		manifItem, _ = manifest.ToStackItem()
   105  
   106  		badCases = []struct {
   107  			name string
   108  			item stackitem.Item
   109  		}{
   110  			{"not an array", stackitem.Make(1)},
   111  			{"wrong array", stackitem.Make([]stackitem.Item{})},
   112  			{"id is not a number", stackitem.Make([]stackitem.Item{manifItem, counter, chash, nefItem, manifItem})},
   113  			{"id is out of range", stackitem.Make([]stackitem.Item{stackitem.Make(math.MaxUint32), counter, chash, nefItem, manifItem})},
   114  			{"counter is not a number", stackitem.Make([]stackitem.Item{id, manifItem, chash, nefItem, manifItem})},
   115  			{"counter is out of range", stackitem.Make([]stackitem.Item{id, stackitem.Make(100500), chash, nefItem, manifItem})},
   116  			{"hash is not a byte string", stackitem.Make([]stackitem.Item{id, counter, stackitem.NewArray(nil), nefItem, manifItem})},
   117  			{"hash is not a hash", stackitem.Make([]stackitem.Item{id, counter, stackitem.Make([]byte{1, 2, 3}), nefItem, manifItem})},
   118  			{"nef is not a byte string", stackitem.Make([]stackitem.Item{id, counter, chash, stackitem.NewArray(nil), manifItem})},
   119  			{"manifest is not an array", stackitem.Make([]stackitem.Item{id, counter, chash, nefItem, stackitem.NewByteArray(nil)})},
   120  			{"manifest is not correct", stackitem.Make([]stackitem.Item{id, counter, chash, nefItem, stackitem.NewArray([]stackitem.Item{stackitem.Make(100500)})})},
   121  		}
   122  	)
   123  	for _, cs := range badCases {
   124  		t.Run(cs.name, func(t *testing.T) {
   125  			var c = new(Contract)
   126  			err := c.FromStackItem(cs.item)
   127  			require.Error(t, err)
   128  		})
   129  	}
   130  	var c = new(Contract)
   131  	err := c.FromStackItem(stackitem.Make([]stackitem.Item{id, counter, chash, nefItem, manifItem}))
   132  	require.NoError(t, err)
   133  }