package compiler_test

import (
	"errors"
	"fmt"
	"math/big"
	"strconv"
	"strings"
	"testing"

	"git.marketally.com/tutus-one/tutus-chain/internal/fakechain"
	"git.marketally.com/tutus-one/tutus-chain/pkg/compiler"
	"git.marketally.com/tutus-one/tutus-chain/pkg/config"
	"git.marketally.com/tutus-one/tutus-chain/pkg/core"
	"git.marketally.com/tutus-one/tutus-chain/pkg/core/dao"
	"git.marketally.com/tutus-one/tutus-chain/pkg/core/interop"
	"git.marketally.com/tutus-one/tutus-chain/pkg/core/native"
	"git.marketally.com/tutus-one/tutus-chain/pkg/core/native/nativehashes"
	"git.marketally.com/tutus-one/tutus-chain/pkg/core/state"
	"git.marketally.com/tutus-one/tutus-chain/pkg/core/storage"
	"git.marketally.com/tutus-one/tutus-chain/pkg/core/transaction"
	"git.marketally.com/tutus-one/tutus-chain/pkg/crypto/hash"
	"git.marketally.com/tutus-one/tutus-chain/pkg/encoding/address"
	"git.marketally.com/tutus-one/tutus-chain/pkg/encoding/base58"
	cinterop "git.marketally.com/tutus-one/tutus-chain/pkg/interop"
	"git.marketally.com/tutus-one/tutus-chain/pkg/tutustest"
	"git.marketally.com/tutus-one/tutus-chain/pkg/tutustest/chain"
	"git.marketally.com/tutus-one/tutus-chain/pkg/smartcontract"
	"git.marketally.com/tutus-one/tutus-chain/pkg/smartcontract/callflag"
	"git.marketally.com/tutus-one/tutus-chain/pkg/smartcontract/manifest"
	"git.marketally.com/tutus-one/tutus-chain/pkg/smartcontract/trigger"
	"git.marketally.com/tutus-one/tutus-chain/pkg/util"
	"git.marketally.com/tutus-one/tutus-chain/pkg/vm"
	"git.marketally.com/tutus-one/tutus-chain/pkg/vm/opcode"
	"git.marketally.com/tutus-one/tutus-chain/pkg/vm/stackitem"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap/zaptest"
)

func TestTypeConstantSize(t *testing.T) {
	src := `package foo
	import "git.marketally.com/tutus-one/tutus-chain/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 (
			"git.marketally.com/tutus-one/tutus-chain/pkg/interop"
			"git.marketally.com/tutus-one/tutus-chain/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 (
			"git.marketally.com/tutus-one/tutus-chain/pkg/interop"
			"git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 := tutustest.NewExecutor(t, bc, acc, acc)
	src := `package foo
		import (
			"git.marketally.com/tutus-one/tutus-chain/pkg/interop"
			"git.marketally.com/tutus-one/tutus-chain/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 := tutustest.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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 := tutustest.NewExecutor(t, bc, acc, acc)
	src := `package foo
		import (
			"git.marketally.com/tutus-one/tutus-chain/pkg/interop/native/ledger"
			"git.marketally.com/tutus-one/tutus-chain/pkg/interop/runtime"
		)
		func Main() []ledger.TransactionSigner {
			return runtime.CurrentSigners()
		}`
	ctr := tutustest.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 := tutustest.NewExecutor(t, bc, acc, acc)
	src := `package foo
		import (
			"git.marketally.com/tutus-one/tutus-chain/pkg/interop/native/std"
		)
		func Main(s string) int {
			return std.StrLen(s)
		}`
	ctr := tutustest.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 "git.marketally.com/tutus-one/tutus-chain/pkg/interop/contract"
	import "git.marketally.com/tutus-one/tutus-chain/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*vm.ExecFeeFactorMultiplier, native.DefaultStoragePrice*vm.ExecFeeFactorMultiplier, 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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/pkg/interop/contract"
	func Main() int {
		result := contract.Call(` + h + `, "callInner", ` + flags + `)
		return result.(int)
	}`
}

func TestBuiltinDoesNotCompile(t *testing.T) {
	src := `package foo
	import "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/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 "git.marketally.com/tutus-one/tutus-chain/pkg/interop/tutusinternal"
		func Main() int {
			var hash string
			return tutusinternal.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 "git.marketally.com/tutus-one/tutus-chain/pkg/interop/tutusinternal"
		func Main() int {
			return tutusinternal.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 "git.marketally.com/tutus-one/tutus-chain/pkg/interop/tutusinternal"
		func Main() int {
			var method string
			return tutusinternal.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 "git.marketally.com/tutus-one/tutus-chain/pkg/interop/tutusinternal"
		func Main() {
			var flags int
			tutusinternal.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 := tutustest.NewExecutor(t, bc, acc, acc)
	src := `package foo
		import (
			"git.marketally.com/tutus-one/tutus-chain/pkg/interop"
			"git.marketally.com/tutus-one/tutus-chain/pkg/interop/contract"
			util "git.marketally.com/tutus-one/tutus-chain/pkg/interop/lib/contract"
		)
		func CallWithVersion(hash interop.Hash160, version int, method string) any {
			return util.CallWithVersion(hash, version, method, contract.All)
		}`
	ctr := tutustest.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, vm.PicoGasToDatoshi(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 := tutustest.NewExecutor(t, bc, acc, acc)
		src := `package foo
		import "git.marketally.com/tutus-one/tutus-chain/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 := tutustest.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)
	})
}

// TestStorageIterator_Value checks that iterator.Value can be
// type-asserted to storage.KeyValue inside a contract.
func TestStorageIterator_Value(t *testing.T) {
	bc, acc := chain.NewSingle(t)
	e := tutustest.NewExecutor(t, bc, acc, acc)

	src := `package foo

import (
	"git.marketally.com/tutus-one/tutus-chain/pkg/interop/storage"
	"git.marketally.com/tutus-one/tutus-chain/pkg/interop/iterator"
)

func Main() int {
	ctx := storage.GetContext()
	storage.Put(ctx, []byte{1}, []byte{1})
	storage.Put(ctx, []byte{2}, []byte{2})

	it := storage.Find(ctx, []byte{}, storage.None)
	sum := 0
	for iterator.Next(it) {
		kv := iterator.Value(it).(storage.KeyValue)
		sum += int(kv.Value[0])
	}
	return sum
}
`
	ctr := tutustest.CompileSource(t, e.CommitteeHash, strings.NewReader(src), &compiler.Options{Name: "KVIter"})
	e.DeployContract(t, ctr, nil)
	c := e.CommitteeInvoker(ctr.Hash)

	c.Invoke(t, big.NewInt(3), "main")
}
