neo-go/pkg/compiler/interop_test.go
2024-05-14 09:39:53 +03:00

767 lines
24 KiB
Go

package compiler_test
import (
"errors"
"fmt"
"math/big"
"strconv"
"strings"
"testing"
"github.com/nspcc-dev/neo-go/internal/fakechain"
"github.com/nspcc-dev/neo-go/pkg/compiler"
"github.com/nspcc-dev/neo-go/pkg/config"
"github.com/nspcc-dev/neo-go/pkg/core"
"github.com/nspcc-dev/neo-go/pkg/core/dao"
"github.com/nspcc-dev/neo-go/pkg/core/interop"
"github.com/nspcc-dev/neo-go/pkg/core/native"
"github.com/nspcc-dev/neo-go/pkg/core/native/nativehashes"
"github.com/nspcc-dev/neo-go/pkg/core/state"
"github.com/nspcc-dev/neo-go/pkg/core/storage"
"github.com/nspcc-dev/neo-go/pkg/core/transaction"
"github.com/nspcc-dev/neo-go/pkg/crypto/hash"
"github.com/nspcc-dev/neo-go/pkg/encoding/address"
"github.com/nspcc-dev/neo-go/pkg/encoding/base58"
cinterop "github.com/nspcc-dev/neo-go/pkg/interop"
"github.com/nspcc-dev/neo-go/pkg/neotest"
"github.com/nspcc-dev/neo-go/pkg/neotest/chain"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
"github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm"
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/stretchr/testify/require"
"go.uber.org/zap/zaptest"
)
func TestTypeConstantSize(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop"
var a %T // type declaration is always ok
func Main() any {
return %#v
}`
t.Run("Hash160", func(t *testing.T) {
t.Run("good", func(t *testing.T) {
a := make(cinterop.Hash160, smartcontract.Hash160Len)
src := fmt.Sprintf(src, a, a)
eval(t, src, []byte(a))
})
t.Run("bad", func(t *testing.T) {
a := make(cinterop.Hash160, 19)
src := fmt.Sprintf(src, a, a)
_, err := compiler.Compile("foo.go", strings.NewReader(src))
require.Error(t, err)
})
})
t.Run("Hash256", func(t *testing.T) {
t.Run("good", func(t *testing.T) {
a := make(cinterop.Hash256, smartcontract.Hash256Len)
src := fmt.Sprintf(src, a, a)
eval(t, src, []byte(a))
})
t.Run("bad", func(t *testing.T) {
a := make(cinterop.Hash256, 31)
src := fmt.Sprintf(src, a, a)
_, err := compiler.Compile("foo.go", strings.NewReader(src))
require.Error(t, err)
})
})
}
func TestAddressToHash160BuiltinConversion(t *testing.T) {
a := "NQRLhCpAru9BjGsMwk67vdMwmzKMRgsnnN"
h, err := address.StringToUint160(a)
require.NoError(t, err)
a2 := "NPAsqZkx9WhNd4P72uhZxBhLinSuNkxfB8"
addr2, err := address.StringToUint160(a2)
require.NoError(t, err)
t.Run("builtin conversion", func(t *testing.T) {
src := `package foo
import (
"github.com/nspcc-dev/neo-go/pkg/interop"
"github.com/nspcc-dev/neo-go/pkg/interop/lib/address"
)
var addr = address.ToHash160("` + a + `")
func Main() interop.Hash160 {
return addr
}`
prog := eval(t, src, h.BytesBE())
// Address BE bytes expected to be present at program, which indicates that address conversion
// was performed at compile-time.
require.True(t, strings.Contains(string(prog), string(h.BytesBE())))
// On the contrary, there should be no address string.
require.False(t, strings.Contains(string(prog), a))
})
t.Run("generate code", func(t *testing.T) {
src := `package foo
import (
"github.com/nspcc-dev/neo-go/pkg/interop"
"github.com/nspcc-dev/neo-go/pkg/interop/lib/address"
)
var addr = "` + a + `"
func Main() interop.Hash160 {
return address.ToHash160(addr)
}`
// Error on CALLT (std.Base58CheckDecode - method of StdLib native contract) is expected, which means
// that address.ToHash160 code was honestly generated by the compiler without any optimisations.
prog := evalWithError(t, src, "(CALLT): runtime error: invalid memory address or nil pointer dereference")
// Address BE bytes expected not to be present at program, which indicates that address conversion
// was not performed at compile-time.
require.False(t, strings.Contains(string(prog), string(h.BytesBE())))
// On the contrary, there should be an address string.
require.True(t, strings.Contains(string(prog), a))
})
t.Run("AliasPackage", func(t *testing.T) {
src := `
package foo
import ad "github.com/nspcc-dev/neo-go/pkg/interop/lib/address"
func Main() []byte {
addr1 := ad.ToHash160("` + a + `")
addr2 := ad.ToHash160("` + a2 + `")
sum := append(addr1, addr2...)
return sum
}`
eval(t, src, append(h.BytesBE(), addr2.BytesBE()...))
})
}
func TestInvokeAddressToFromHash160(t *testing.T) {
a := "NQRLhCpAru9BjGsMwk67vdMwmzKMRgsnnN"
h, err := address.StringToUint160(a)
require.NoError(t, err)
bc, acc := chain.NewSingle(t)
e := neotest.NewExecutor(t, bc, acc, acc)
src := `package foo
import (
"github.com/nspcc-dev/neo-go/pkg/interop"
"github.com/nspcc-dev/neo-go/pkg/interop/lib/address"
)
const addr = "` + a + `"
func ToHash160(a string) interop.Hash160 {
return address.ToHash160(a)
}
func ToHash160AtCompileTime() interop.Hash160 {
return address.ToHash160(addr)
}
func FromHash160(hash interop.Hash160) string {
return address.FromHash160(hash)
}`
ctr := neotest.CompileSource(t, e.CommitteeHash, strings.NewReader(src), &compiler.Options{Name: "Helper"})
e.DeployContract(t, ctr, nil)
c := e.CommitteeInvoker(ctr.Hash)
t.Run("ToHash160", func(t *testing.T) {
t.Run("invalid address length", func(t *testing.T) {
c.InvokeFail(t, "invalid address length", "toHash160", base58.CheckEncode(make([]byte, util.Uint160Size+1+1)))
})
t.Run("invalid prefix", func(t *testing.T) {
c.InvokeFail(t, "invalid address prefix", "toHash160", base58.CheckEncode(append([]byte{address.NEO2Prefix}, h.BytesBE()...)))
})
t.Run("good", func(t *testing.T) {
c.Invoke(t, stackitem.NewBuffer(h.BytesBE()), "toHash160", a)
})
})
t.Run("ToHash160Constant", func(t *testing.T) {
t.Run("good", func(t *testing.T) {
c.Invoke(t, stackitem.NewBuffer(h.BytesBE()), "toHash160AtCompileTime")
})
})
t.Run("FromHash160", func(t *testing.T) {
t.Run("good", func(t *testing.T) {
c.Invoke(t, stackitem.NewByteArray([]byte(a)), "fromHash160", h.BytesBE())
})
t.Run("invalid length", func(t *testing.T) {
c.InvokeFail(t, "invalid Hash160 length", "fromHash160", h.BytesBE()[:15])
})
})
}
func TestAbort(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/util"
func Main() int {
util.Abort()
return 1
}`
v := vmAndCompile(t, src)
require.Error(t, v.Run())
require.True(t, v.HasFailed())
}
func TestAbortMsg(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/util"
func Main() int {
util.AbortMsg("some message")
return 1
}`
v := vmAndCompile(t, src)
err := v.Run()
require.Error(t, err)
require.True(t, v.HasFailed())
require.True(t, strings.Contains(err.Error(), "ABORTMSG is executed. Reason: some message"), err)
}
func TestAssert(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/util"
func Main(ok bool) int {
util.Assert(ok)
return 1
}`
// assert OK
evalWithArgs(t, src, nil, []stackitem.Item{stackitem.Make(true)}, big.NewInt(1))
// assert FALSE
v := vmAndCompile(t, src)
v.Estack().PushVal(false)
err := v.Run()
require.Error(t, err)
require.True(t, v.HasFailed())
require.True(t, strings.Contains(err.Error(), "ASSERT"), err)
}
func TestAssertMsg(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/util"
func Main(ok bool) int {
util.AssertMsg(ok, "some message")
return 1
}`
// assert OK
evalWithArgs(t, src, nil, []stackitem.Item{stackitem.Make(true)}, big.NewInt(1))
// assert FALSE
v := vmAndCompile(t, src)
v.Estack().PushVal(false)
err := v.Run()
require.Error(t, err)
require.True(t, v.HasFailed())
require.True(t, strings.Contains(err.Error(), "ASSERTMSG is executed with false result. Reason: some message"), err)
}
func TestCurrentSigners(t *testing.T) {
bc, acc := chain.NewSingle(t)
e := neotest.NewExecutor(t, bc, acc, acc)
src := `package foo
import (
"github.com/nspcc-dev/neo-go/pkg/interop/native/ledger"
"github.com/nspcc-dev/neo-go/pkg/interop/runtime"
)
func Main() []ledger.TransactionSigner {
return runtime.CurrentSigners()
}`
ctr := neotest.CompileSource(t, e.CommitteeHash, strings.NewReader(src), &compiler.Options{Name: "Helper"})
e.DeployContract(t, ctr, nil)
c := e.CommitteeInvoker(ctr.Hash)
t.Run("non-empty", func(t *testing.T) {
expected := stackitem.NewArray([]stackitem.Item{
stackitem.NewArray([]stackitem.Item{
stackitem.NewByteArray(e.CommitteeHash.BytesBE()),
stackitem.NewBigInteger(big.NewInt(int64(transaction.Global))),
stackitem.NewArray([]stackitem.Item{}),
stackitem.NewArray([]stackitem.Item{}),
stackitem.NewArray([]stackitem.Item{}),
}),
})
c.Invoke(t, expected, "main")
})
}
func TestStdLib_StrLen(t *testing.T) {
bc, acc := chain.NewSingle(t)
e := neotest.NewExecutor(t, bc, acc, acc)
src := `package foo
import (
"github.com/nspcc-dev/neo-go/pkg/interop/native/std"
)
func Main(s string) int {
return std.StrLen(s)
}`
ctr := neotest.CompileSource(t, e.CommitteeHash, strings.NewReader(src), &compiler.Options{Name: "Helper"})
e.DeployContract(t, ctr, nil)
c := e.CommitteeInvoker(ctr.Hash)
expected := stackitem.Make(1)
c.Invoke(t, expected, "main", "🦆")
c.Invoke(t, expected, "main", "ã")
c.Invoke(t, expected, "main", "a")
expected = stackitem.Make(7)
c.Invoke(t, expected, "main", "abc 123")
}
func spawnVM(t *testing.T, ic *interop.Context, src string) *vm.VM {
b, di, err := compiler.CompileWithOptions("foo.go", strings.NewReader(src), nil)
require.NoError(t, err)
v := core.SpawnVM(ic)
invokeMethod(t, testMainIdent, b.Script, v, di)
v.LoadScriptWithFlags(b.Script, callflag.All)
return v
}
func TestAppCall(t *testing.T) {
srcDeep := `package foo
func Get42() int {
return 42
}`
barCtr, di, err := compiler.CompileWithOptions("bar.go", strings.NewReader(srcDeep), nil)
require.NoError(t, err)
mBar, err := di.ConvertToManifest(&compiler.Options{Name: "Bar"})
require.NoError(t, err)
barH := hash.Hash160(barCtr.Script)
srcInner := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/contract"
import "github.com/nspcc-dev/neo-go/pkg/interop"
var a int = 3
func Main(a []byte, b []byte) []byte {
panic("Main was called")
}
func Append(a []byte, b []byte) []byte {
return append(a, b...)
}
func Add3(n int) int {
return a + n
}
func CallInner() int {
return contract.Call(%s, "get42", contract.All).(int)
}`
srcInner = fmt.Sprintf(srcInner,
fmt.Sprintf("%#v", cinterop.Hash160(barH.BytesBE())))
inner, di, err := compiler.CompileWithOptions("foo.go", strings.NewReader(srcInner), nil)
require.NoError(t, err)
m, err := di.ConvertToManifest(&compiler.Options{
Name: "Foo",
Permissions: []manifest.Permission{
*manifest.NewPermission(manifest.PermissionWildcard),
},
})
require.NoError(t, err)
ih := hash.Hash160(inner.Script)
var contractGetter = func(_ *dao.Simple, h util.Uint160) (*state.Contract, error) {
if h.Equals(ih) {
return &state.Contract{
ContractBase: state.ContractBase{
Hash: ih,
NEF: *inner,
Manifest: *m,
},
}, nil
} else if h.Equals(barH) {
return &state.Contract{
ContractBase: state.ContractBase{
Hash: barH,
NEF: *barCtr,
Manifest: *mBar,
},
}, nil
}
return nil, errors.New("not found")
}
fc := fakechain.NewFakeChain()
ic := interop.NewContext(trigger.Application, fc, dao.NewSimple(storage.NewMemoryStore(), false),
interop.DefaultBaseExecFee, native.DefaultStoragePrice, contractGetter, nil, nil, nil, nil, zaptest.NewLogger(t))
t.Run("valid script", func(t *testing.T) {
src := getAppCallScript(fmt.Sprintf("%#v", ih.BytesBE()))
v := spawnVM(t, ic, src)
require.NoError(t, v.Run())
assertResult(t, v, []byte{1, 2, 3, 4})
})
t.Run("callEx, valid", func(t *testing.T) {
src := getCallExScript(fmt.Sprintf("%#v", ih.BytesBE()), "contract.ReadStates|contract.AllowCall")
v := spawnVM(t, ic, src)
require.NoError(t, v.Run())
assertResult(t, v, big.NewInt(42))
})
t.Run("callEx, missing flags", func(t *testing.T) {
src := getCallExScript(fmt.Sprintf("%#v", ih.BytesBE()), "contract.NoneFlag")
v := spawnVM(t, ic, src)
require.Error(t, v.Run())
})
t.Run("missing script", func(t *testing.T) {
h := ih
h[0] = ^h[0]
src := getAppCallScript(fmt.Sprintf("%#v", h.BytesBE()))
v := spawnVM(t, ic, src)
require.Error(t, v.Run())
})
t.Run("convert from string constant", func(t *testing.T) {
src := `
package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/contract"
const scriptHash = ` + fmt.Sprintf("%#v", string(ih.BytesBE())) + `
func Main() []byte {
x := []byte{1, 2}
y := []byte{3, 4}
result := contract.Call([]byte(scriptHash), "append", contract.All, x, y)
return result.([]byte)
}
`
v := spawnVM(t, ic, src)
require.NoError(t, v.Run())
assertResult(t, v, []byte{1, 2, 3, 4})
})
t.Run("convert from var", func(t *testing.T) {
src := `
package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/contract"
func Main() []byte {
x := []byte{1, 2}
y := []byte{3, 4}
var addr = []byte(` + fmt.Sprintf("%#v", string(ih.BytesBE())) + `)
result := contract.Call(addr, "append", contract.All, x, y)
return result.([]byte)
}
`
v := spawnVM(t, ic, src)
require.NoError(t, v.Run())
assertResult(t, v, []byte{1, 2, 3, 4})
})
t.Run("InitializedGlobals", func(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/contract"
func Main() int {
var addr = []byte(` + fmt.Sprintf("%#v", string(ih.BytesBE())) + `)
result := contract.Call(addr, "add3", contract.All, 39)
return result.(int)
}`
v := spawnVM(t, ic, src)
require.NoError(t, v.Run())
assertResult(t, v, big.NewInt(42))
})
t.Run("AliasPackage", func(t *testing.T) {
src := `package foo
import ee "github.com/nspcc-dev/neo-go/pkg/interop/contract"
func Main() int {
var addr = []byte(` + fmt.Sprintf("%#v", string(ih.BytesBE())) + `)
result := ee.Call(addr, "add3", ee.All, 39)
return result.(int)
}`
v := spawnVM(t, ic, src)
require.NoError(t, v.Run())
assertResult(t, v, big.NewInt(42))
})
}
func getAppCallScript(h string) string {
return `
package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/contract"
func Main() []byte {
x := []byte{1, 2}
y := []byte{3, 4}
result := contract.Call(` + h + `, "append", contract.All, x, y)
return result.([]byte)
}
`
}
func getCallExScript(h string, flags string) string {
return `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/contract"
func Main() int {
result := contract.Call(` + h + `, "callInner", ` + flags + `)
return result.(int)
}`
}
func TestBuiltinDoesNotCompile(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/util"
func Main() bool {
a := 1
b := 2
return util.Equals(a, b)
}`
v := vmAndCompile(t, src)
ctx := v.Context()
retCount := 0
for op, _, err := ctx.Next(); err == nil; op, _, err = ctx.Next() {
if ctx.IP() >= len(ctx.Program()) {
break
}
if op == opcode.RET {
retCount++
}
}
require.Equal(t, 1, retCount)
}
func TestInteropPackage(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/compiler/testdata/block"
func Main() int {
b := block.Block{}
a := block.GetTransactionCount(b)
return a
}`
eval(t, src, big.NewInt(42))
}
func TestBuiltinPackage(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/compiler/testdata/util"
func Main() int {
if util.Equals(1, 2) { // always returns true
return 1
}
return 2
}`
eval(t, src, big.NewInt(1))
}
func TestLenForNil(t *testing.T) {
src := `
package foo
func Main() bool {
var a []int = nil
return len(a) == 0
}`
eval(t, src, true)
}
func TestCallTConversionErrors(t *testing.T) {
t.Run("variable hash", func(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/neogointernal"
func Main() int {
var hash string
return neogointernal.CallWithToken(hash, "method", 0).(int)
}`
_, err := compiler.Compile("foo.go", strings.NewReader(src))
require.Error(t, err)
})
t.Run("bad hash", func(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/neogointernal"
func Main() int {
return neogointernal.CallWithToken("badstring", "method", 0).(int)
}`
_, err := compiler.Compile("foo.go", strings.NewReader(src))
require.Error(t, err)
})
t.Run("variable method", func(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/neogointernal"
func Main() int {
var method string
return neogointernal.CallWithToken("\xf5\x63\xea\x40\xbc\x28\x3d\x4d\x0e\x05\xc4\x8e\xa3\x05\xb3\xf2\xa0\x73\x40\xef", method, 0).(int)
}`
_, err := compiler.Compile("foo.go", strings.NewReader(src))
require.Error(t, err)
})
t.Run("variable flags", func(t *testing.T) {
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/neogointernal"
func Main() {
var flags int
neogointernal.CallWithTokenNoRet("\xf5\x63\xea\x40\xbc\x28\x3d\x4d\x0e\x05\xc4\x8e\xa3\x05\xb3\xf2\xa0\x73\x40\xef", "method", flags)
}`
_, err := compiler.Compile("foo.go", strings.NewReader(src))
require.Error(t, err)
})
}
func TestCallWithVersion(t *testing.T) {
bc, acc := chain.NewSingle(t)
e := neotest.NewExecutor(t, bc, acc, acc)
src := `package foo
import (
"github.com/nspcc-dev/neo-go/pkg/interop"
"github.com/nspcc-dev/neo-go/pkg/interop/contract"
util "github.com/nspcc-dev/neo-go/pkg/interop/lib/contract"
)
func CallWithVersion(hash interop.Hash160, version int, method string) any {
return util.CallWithVersion(hash, version, method, contract.All)
}`
ctr := neotest.CompileSource(t, e.CommitteeHash, strings.NewReader(src), &compiler.Options{Name: "Helper"})
e.DeployContract(t, ctr, nil)
c := e.CommitteeInvoker(ctr.Hash)
policyH := nativehashes.PolicyContract
t.Run("good", func(t *testing.T) {
c.Invoke(t, e.Chain.GetBaseExecFee(), "callWithVersion", policyH.BytesBE(), 0, "getExecFeeFactor")
})
t.Run("unknown contract", func(t *testing.T) {
c.InvokeFail(t, "unknown contract", "callWithVersion", util.Uint160{1, 2, 3}.BytesBE(), 0, "getExecFeeFactor")
})
t.Run("invalid version", func(t *testing.T) {
c.InvokeFail(t, "contract version mismatch", "callWithVersion", policyH.BytesBE(), 1, "getExecFeeFactor")
})
}
func TestForcedNotifyArgumentsConversion(t *testing.T) {
const methodWithEllipsis = "withEllipsis"
const methodWithoutEllipsis = "withoutEllipsis"
check := func(t *testing.T, method string, targetSCParamTypes []smartcontract.ParamType, expectedVMParamTypes []stackitem.Type, noEventsCheck bool) {
bc, acc := chain.NewSingleWithCustomConfig(t, func(blockchain *config.Blockchain) {
blockchain.Hardforks = map[string]uint32{config.HFBasilisk.String(): 100500} // Disable runtime notifications check to reuse the same contract for different event parameter types.
})
e := neotest.NewExecutor(t, bc, acc, acc)
src := `package foo
import "github.com/nspcc-dev/neo-go/pkg/interop/runtime"
const arg4 = 4 // Const value.
func WithoutEllipsis() {
var arg0 int // Default value.
var arg1 int = 1 // Initialized value.
arg2 := 2 // Short decl.
var arg3 int
arg3 = 3 // Declare first, change value afterwards.
runtime.Notify("withoutEllipsis", arg0, arg1, arg2, arg3, arg4, 5, f(6)) // The fifth argument is basic literal.
}
func WithEllipsis() {
arg := []any{0, 1, f(2), 3, 4, 5, 6}
runtime.Notify("withEllipsis", arg...)
}
func f(i int) int {
return i
}`
count := len(targetSCParamTypes)
if count != len(expectedVMParamTypes) {
t.Fatalf("parameters count mismatch: %d vs %d", count, len(expectedVMParamTypes))
}
scParams := make([]compiler.HybridParameter, len(targetSCParamTypes))
vmParams := make([]stackitem.Item, len(expectedVMParamTypes))
for i := range scParams {
scParams[i] = compiler.HybridParameter{Parameter: manifest.Parameter{
Name: strconv.Itoa(i),
Type: targetSCParamTypes[i],
}}
defaultValue := stackitem.NewBigInteger(big.NewInt(int64(i)))
var (
val stackitem.Item
err error
)
if expectedVMParamTypes[i] == stackitem.IntegerT {
val = defaultValue
} else {
val, err = defaultValue.Convert(expectedVMParamTypes[i]) // exactly the same conversion should be emitted by compiler and performed by the contract code.
require.NoError(t, err)
}
vmParams[i] = val
}
ctr := neotest.CompileSource(t, e.CommitteeHash, strings.NewReader(src), &compiler.Options{
Name: "Helper",
ContractEvents: []compiler.HybridEvent{
{
Name: methodWithoutEllipsis,
Parameters: scParams,
},
{
Name: methodWithEllipsis,
Parameters: scParams,
},
},
NoEventsCheck: noEventsCheck,
})
e.DeployContract(t, ctr, nil)
c := e.CommitteeInvoker(ctr.Hash)
t.Run(method, func(t *testing.T) {
h := c.Invoke(t, stackitem.Null{}, method)
aer := c.GetTxExecResult(t, h)
require.Equal(t, 1, len(aer.Events))
require.Equal(t, stackitem.NewArray(vmParams), aer.Events[0].Item)
})
}
checkSingleType := func(t *testing.T, method string, targetSCEventType smartcontract.ParamType, expectedVMType stackitem.Type, noEventsCheck ...bool) {
count := 7
scParams := make([]smartcontract.ParamType, count)
vmParams := make([]stackitem.Type, count)
for i := range scParams {
scParams[i] = targetSCEventType
vmParams[i] = expectedVMType
}
var noEvents bool
if len(noEventsCheck) > 0 {
noEvents = noEventsCheck[0]
}
check(t, method, scParams, vmParams, noEvents)
}
t.Run("good, single type, default values", func(t *testing.T) {
checkSingleType(t, methodWithoutEllipsis, smartcontract.IntegerType, stackitem.IntegerT)
})
t.Run("good, single type, conversion to BooleanT", func(t *testing.T) {
checkSingleType(t, methodWithoutEllipsis, smartcontract.BoolType, stackitem.BooleanT)
})
t.Run("good, single type, Hash160Type->ByteArray", func(t *testing.T) {
checkSingleType(t, methodWithoutEllipsis, smartcontract.Hash160Type, stackitem.ByteArrayT)
})
t.Run("good, single type, Hash256Type->ByteArray", func(t *testing.T) {
checkSingleType(t, methodWithoutEllipsis, smartcontract.Hash256Type, stackitem.ByteArrayT)
})
t.Run("good, single type, Signature->ByteArray", func(t *testing.T) {
checkSingleType(t, methodWithoutEllipsis, smartcontract.SignatureType, stackitem.ByteArrayT)
})
t.Run("good, single type, String->ByteArray", func(t *testing.T) {
checkSingleType(t, methodWithoutEllipsis, smartcontract.StringType, stackitem.ByteArrayT) // Special case, runtime.Notify will convert any Buffer to ByteArray.
})
t.Run("good, single type, PublicKeyType->ByteArray", func(t *testing.T) {
checkSingleType(t, methodWithoutEllipsis, smartcontract.PublicKeyType, stackitem.ByteArrayT)
})
t.Run("good, single type, AnyType->do not change initial type", func(t *testing.T) {
checkSingleType(t, methodWithoutEllipsis, smartcontract.AnyType, stackitem.IntegerT) // Special case, compiler should leave the type "as is" and do not emit conversion code.
})
// Test for InteropInterface->... is missing, because we don't enforce conversion to stackitem.InteropInterface,
// but compiler still checks these notifications against expected manifest.
t.Run("good, multiple types, check the conversion order", func(t *testing.T) {
check(t, methodWithoutEllipsis, []smartcontract.ParamType{
smartcontract.IntegerType,
smartcontract.BoolType,
smartcontract.ByteArrayType,
smartcontract.PublicKeyType,
smartcontract.Hash160Type,
smartcontract.AnyType, // leave initial type
smartcontract.StringType,
}, []stackitem.Type{
stackitem.IntegerT,
stackitem.BooleanT,
stackitem.ByteArrayT,
stackitem.ByteArrayT,
stackitem.ByteArrayT,
stackitem.IntegerT, // leave initial type
stackitem.ByteArrayT,
}, false)
})
t.Run("with ellipsis, do not emit conversion code", func(t *testing.T) {
checkSingleType(t, methodWithEllipsis, smartcontract.IntegerType, stackitem.IntegerT)
checkSingleType(t, methodWithEllipsis, smartcontract.BoolType, stackitem.IntegerT)
checkSingleType(t, methodWithEllipsis, smartcontract.ByteArrayType, stackitem.IntegerT)
})
t.Run("no events check => no conversion code", func(t *testing.T) {
checkSingleType(t, methodWithoutEllipsis, smartcontract.PublicKeyType, stackitem.IntegerT, true)
})
}