vm: use uint256.Int (fixes nspcc-dev#1581)

ZhangTao1596 · Mar 3, 2023 · 45fecd3 · 45fecd3
1 parent 9f9c6f5
commit 45fecd3
Show file tree

Hide file tree

Showing 73 changed files with 882 additions and 486 deletions.
diff --git a/cli/nep_test/nep11_test.go b/cli/nep_test/nep11_test.go
@@ -7,12 +7,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"math/big"
 	"os"
 	"path/filepath"
 	"strconv"
 	"testing"
 
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/internal/testcli"
 	"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
 	"github.com/nspcc-dev/neo-go/pkg/core/state"
@@ -351,7 +351,7 @@ func TestNEP11_ND_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 		Name:       "OnNEP11Payment",
 		Item: stackitem.NewArray([]stackitem.Item{
 			stackitem.NewByteArray(nftOwnerHash.BytesBE()),
-			stackitem.NewBigInteger(big.NewInt(1)),
+			stackitem.NewBigInteger(uint256.NewInt(1)),
 			stackitem.NewByteArray(tokenID1),
 			stackitem.NewByteArray([]byte("some_data")),
 		}),
@@ -636,7 +636,7 @@ func TestNEP11_D_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 		Name:       "OnNEP11Payment",
 		Item: stackitem.NewArray([]stackitem.Item{
 			stackitem.NewByteArray(validatorHash.BytesBE()),
-			stackitem.NewBigInteger(big.NewInt(25)),
+			stackitem.NewBigInteger(uint256.NewInt(25)),
 			stackitem.NewByteArray(token2ID),
 			stackitem.NewByteArray([]byte("some_data")),
 		}),

diff --git a/cli/vm/cli_test.go b/cli/vm/cli_test.go
@@ -8,7 +8,6 @@ import (
 	"errors"
 	"fmt"
 	gio "io"
-	"math/big"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -18,6 +17,7 @@ import (
 	"time"
 
 	"github.com/chzyer/readline"
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/cli/paramcontext"
 	"github.com/nspcc-dev/neo-go/internal/basicchain"
 	"github.com/nspcc-dev/neo-go/internal/random"
@@ -590,9 +590,9 @@ func TestRunWithDifferentArguments(t *testing.T) {
 
 	e.checkNextLine(t, "READY: loaded \\d.* instructions")
 	e.checkStack(t, []stackitem.Item{
-		stackitem.NewBigInteger(big.NewInt(1)),
-		stackitem.NewBigInteger(big.NewInt(2)),
-		stackitem.NewBigInteger(big.NewInt(3)),
+		stackitem.NewBigInteger(uint256.NewInt(1)),
+		stackitem.NewBigInteger(uint256.NewInt(2)),
+		stackitem.NewBigInteger(uint256.NewInt(3)),
 	})
 }
 

diff --git a/go.work b/go.work
@@ -0,0 +1,6 @@
+go 1.20
+
+use (
+	.
+	./pkg/interop
+)
diff --git a/pkg/compiler/for_test.go b/pkg/compiler/for_test.go
@@ -7,6 +7,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/pkg/compiler"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger"
 	"github.com/nspcc-dev/neo-go/pkg/vm"
@@ -36,7 +37,7 @@ func TestEntryPointWithArgs(t *testing.T) {
 			return 2 + args[1].(int)
 		}
 	`
-	args := []stackitem.Item{stackitem.NewBigInteger(big.NewInt(0)), stackitem.NewBigInteger(big.NewInt(1))}
+	args := []stackitem.Item{stackitem.NewBigInteger(uint256.NewInt(0)), stackitem.NewBigInteger(uint256.NewInt(1))}
 	evalWithArgs(t, src, nil, args, big.NewInt(3))
 }
 
@@ -51,7 +52,7 @@ func TestEntryPointWithMethodAndArgs(t *testing.T) {
 			return 0
 		}
 	`
-	args := []stackitem.Item{stackitem.NewBigInteger(big.NewInt(0)), stackitem.NewBigInteger(big.NewInt(1))}
+	args := []stackitem.Item{stackitem.NewBigInteger(uint256.NewInt(0)), stackitem.NewBigInteger(uint256.NewInt(1))}
 	evalWithArgs(t, src, []byte("foobar"), args, big.NewInt(3))
 }
 
@@ -156,9 +157,9 @@ func TestIntArray(t *testing.T) {
 		}
 	`
 	eval(t, src, []stackitem.Item{
-		stackitem.NewBigInteger(big.NewInt(1)),
-		stackitem.NewBigInteger(big.NewInt(2)),
-		stackitem.NewBigInteger(big.NewInt(3)),
+		stackitem.NewBigInteger(uint256.NewInt(1)),
+		stackitem.NewBigInteger(uint256.NewInt(2)),
+		stackitem.NewBigInteger(uint256.NewInt(3)),
 	})
 }
 

diff --git a/pkg/compiler/interop_test.go b/pkg/compiler/interop_test.go
@@ -586,7 +586,7 @@ func TestForcedNotifyArgumentsConversion(t *testing.T) {
 				Name: strconv.Itoa(i),
 				Type: targetSCParamTypes[i],
 			}
-			defaultValue := stackitem.NewBigInteger(big.NewInt(int64(i)))
+			defaultValue := stackitem.NewBigIntegerFromInt64(int64(i))
 			var (
 				val stackitem.Item
 				err error

diff --git a/pkg/compiler/native_test.go b/pkg/compiler/native_test.go
@@ -4,11 +4,11 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-	"math/big"
 	"strconv"
 	"strings"
 	"testing"
 
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/pkg/compiler"
 	"github.com/nspcc-dev/neo-go/pkg/config"
 	"github.com/nspcc-dev/neo-go/pkg/core/interop"
@@ -362,7 +362,7 @@ func getTestStackItem(typ smartcontract.ParamType) stackitem.Item {
 	case smartcontract.BoolType:
 		return stackitem.NewBool(true)
 	case smartcontract.IntegerType:
-		return stackitem.NewBigInteger(big.NewInt(42))
+		return stackitem.NewBigInteger(uint256.NewInt(42))
 	case smartcontract.ByteArrayType, smartcontract.StringType, smartcontract.Hash160Type,
 		smartcontract.Hash256Type, smartcontract.PublicKeyType, smartcontract.SignatureType:
 		return stackitem.NewByteArray([]byte("result"))

diff --git a/pkg/compiler/slice_test.go b/pkg/compiler/slice_test.go
@@ -7,6 +7,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/pkg/compiler"
 	"github.com/nspcc-dev/neo-go/pkg/vm"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
@@ -162,11 +163,11 @@ var sliceTestCases = []testCase{
 		}
 		`,
 		[]stackitem.Item{
-			stackitem.NewBigInteger(big.NewInt(1)),
-			stackitem.NewBigInteger(big.NewInt(2)),
-			stackitem.NewBigInteger(big.NewInt(3)),
-			stackitem.NewBigInteger(big.NewInt(4)),
-			stackitem.NewBigInteger(big.NewInt(5)),
+			stackitem.NewBigInteger(uint256.NewInt(1)),
+			stackitem.NewBigInteger(uint256.NewInt(2)),
+			stackitem.NewBigInteger(uint256.NewInt(3)),
+			stackitem.NewBigInteger(uint256.NewInt(4)),
+			stackitem.NewBigInteger(uint256.NewInt(5)),
 		},
 	},
 	{

diff --git a/pkg/compiler/struct_test.go b/pkg/compiler/struct_test.go
@@ -7,6 +7,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/pkg/compiler"
 	"github.com/nspcc-dev/neo-go/pkg/vm"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
@@ -278,8 +279,8 @@ var structTestCases = []testCase{
 		}
 		`,
 		[]stackitem.Item{
-			stackitem.NewBigInteger(big.NewInt(1)),
-			stackitem.NewBigInteger(big.NewInt(2)),
+			stackitem.NewBigInteger(uint256.NewInt(1)),
+			stackitem.NewBigInteger(uint256.NewInt(2)),
 			stackitem.NewByteArray([]byte("hello")),
 			stackitem.NewBool(false),
 		},

diff --git a/pkg/compiler/syscall_test.go b/pkg/compiler/syscall_test.go
@@ -8,6 +8,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/pkg/compiler"
 	"github.com/nspcc-dev/neo-go/pkg/core"
 	"github.com/nspcc-dev/neo-go/pkg/core/interop"
@@ -201,7 +202,7 @@ func TestNotify(t *testing.T) {
 	require.NoError(t, v.Run())
 	require.Equal(t, 2, len(s.events))
 
-	exp0 := []stackitem.Item{stackitem.NewBigInteger(big.NewInt(11)), stackitem.NewByteArray([]byte("sum")), stackitem.NewBigInteger(big.NewInt(12))}
+	exp0 := []stackitem.Item{stackitem.NewBigInteger(uint256.NewInt(11)), stackitem.NewByteArray([]byte("sum")), stackitem.NewBigInteger(uint256.NewInt(12))}
 	assert.Equal(t, "Event1", s.events[0].Name)
 	assert.Equal(t, exp0, s.events[0].Item.Value())
 	assert.Equal(t, "single", s.events[1].Name)

diff --git a/pkg/core/block/block.go b/pkg/core/block/block.go
@@ -4,8 +4,8 @@ import (
 	"encoding/json"
 	"errors"
 	"math"
-	"math/big"
 
+	"github.com/holiman/uint256"
 	"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/io"
@@ -223,14 +223,14 @@ func (b *Block) GetExpectedBlockSizeWithoutTransactions(txCount int) int {
 func (b *Block) ToStackItem() stackitem.Item {
 	items := []stackitem.Item{
 		stackitem.NewByteArray(b.Hash().BytesBE()),
-		stackitem.NewBigInteger(big.NewInt(int64(b.Version))),
+		stackitem.NewBigInteger(uint256.NewInt(uint64(b.Version))),
 		stackitem.NewByteArray(b.PrevHash.BytesBE()),
 		stackitem.NewByteArray(b.MerkleRoot.BytesBE()),
-		stackitem.NewBigInteger(big.NewInt(int64(b.Timestamp))),
-		stackitem.NewBigInteger(new(big.Int).SetUint64(b.Nonce)),
-		stackitem.NewBigInteger(big.NewInt(int64(b.Index))),
+		stackitem.NewBigInteger(uint256.NewInt(uint64(b.Timestamp))),
+		stackitem.NewBigInteger(uint256.NewInt(b.Nonce)),
+		stackitem.NewBigInteger(uint256.NewInt(uint64(b.Index))),
 		stackitem.NewByteArray(b.NextConsensus.BytesBE()),
-		stackitem.NewBigInteger(big.NewInt(int64(len(b.Transactions)))),
+		stackitem.NewBigInteger(uint256.NewInt(uint64(len(b.Transactions)))),
 	}
 	if b.StateRootEnabled {
 		items = append(items, stackitem.NewByteArray(b.PrevStateRoot.BytesBE()))

diff --git a/pkg/core/blockchain.go b/pkg/core/blockchain.go
@@ -1736,7 +1736,7 @@ func (bc *Blockchain) handleNotification(note *state.NotificationEvent, d *dao.S
 			return
 		}
 	}
-	bc.processTokenTransfer(d, transCache, h, b, note.ScriptHash, from, to, amount, id)
+	bc.processTokenTransfer(d, transCache, h, b, note.ScriptHash, from, to, util.ToBig(amount), id)
 }
 
 func parseUint160(itm stackitem.Item) (util.Uint160, error) {

diff --git a/pkg/core/interop/contract/call.go b/pkg/core/interop/contract/call.go
@@ -3,9 +3,9 @@ package contract
 import (
 	"errors"
 	"fmt"
-	"math/big"
 	"strings"
 
+	"github.com/holiman/uint256"
 	"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/nativenames"
@@ -47,7 +47,7 @@ func LoadToken(ic *interop.Context, id int32) error {
 func Call(ic *interop.Context) error {
 	h := ic.VM.Estack().Pop().Bytes()
 	method := ic.VM.Estack().Pop().String()
-	fs := callflag.CallFlag(int32(ic.VM.Estack().Pop().BigInt().Int64()))
+	fs := callflag.CallFlag(int32(ic.VM.Estack().Pop().BigInt().Uint64()))
 	if fs&^callflag.All != 0 {
 		return errors.New("call flags out of range")
 	}
@@ -176,6 +176,6 @@ func CallFromNative(ic *interop.Context, caller util.Uint160, cs *state.Contract
 
 // GetCallFlags returns current context calling flags.
 func GetCallFlags(ic *interop.Context) error {
-	ic.VM.Estack().PushItem(stackitem.NewBigInteger(big.NewInt(int64(ic.VM.Context().GetCallFlags()))))
+	ic.VM.Estack().PushItem(stackitem.NewBigInteger(uint256.NewInt(uint64(ic.VM.Context().GetCallFlags()))))
 	return nil
 }
diff --git a/pkg/core/interop/contract/call_test.go b/pkg/core/interop/contract/call_test.go
@@ -8,6 +8,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/internal/contracts"
 	"github.com/nspcc-dev/neo-go/internal/random"
 	"github.com/nspcc-dev/neo-go/pkg/compiler"
@@ -189,7 +190,7 @@ func TestLoadToken(t *testing.T) {
 
 	t.Run("good", func(t *testing.T) {
 		realBalance, _ := bc.GetGoverningTokenBalance(acc.ScriptHash())
-		cInvoker.Invoke(t, stackitem.NewBigInteger(big.NewInt(realBalance.Int64()+1)), "callT0", acc.ScriptHash())
+		cInvoker.Invoke(t, stackitem.NewBigInteger(uint256.NewInt(uint64(realBalance.Int64()+1))), "callT0", acc.ScriptHash())
 	})
 	t.Run("invalid param count", func(t *testing.T) {
 		cInvoker.InvokeFail(t, "method not found: callT2/1", "callT2", acc.ScriptHash())

diff --git a/pkg/core/interop/iterator/interop_test.go b/pkg/core/interop/iterator/interop_test.go
@@ -23,7 +23,7 @@ func (t *testIter) Next() bool {
 }
 
 func (t testIter) Value() stackitem.Item {
-	return stackitem.NewBigInteger(big.NewInt(int64(t.arr[t.index])))
+	return stackitem.NewBigIntegerFromInt64(int64(t.arr[t.index]))
 }
 
 // Iterator is thoroughly tested in VM package, these are smoke tests.

diff --git a/pkg/core/interop/runtime/engine.go b/pkg/core/interop/runtime/engine.go
@@ -3,8 +3,8 @@ package runtime
 import (
 	"errors"
 	"fmt"
-	"math/big"
 
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/pkg/core/interop"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
 	"github.com/nspcc-dev/neo-go/pkg/vm"
@@ -65,7 +65,7 @@ func Platform(ic *interop.Context) error {
 
 // GetTrigger returns the script trigger.
 func GetTrigger(ic *interop.Context) error {
-	ic.VM.Estack().PushItem(stackitem.NewBigInteger(big.NewInt(int64(ic.Trigger))))
+	ic.VM.Estack().PushItem(stackitem.NewBigInteger(uint256.NewInt(uint64(ic.Trigger))))
 	return nil
 }
 
@@ -110,7 +110,7 @@ func Notify(ic *interop.Context) error {
 // LoadScript takes a script and arguments from the stack and loads it into the VM.
 func LoadScript(ic *interop.Context) error {
 	script := ic.VM.Estack().Pop().Bytes()
-	fs := callflag.CallFlag(int32(ic.VM.Estack().Pop().BigInt().Int64()))
+	fs := callflag.CallFlag(int32(ic.VM.Estack().Pop().BigInt().Uint64()))
 	if fs&^callflag.All != 0 {
 		return errors.New("call flags out of range")
 	}
@@ -148,23 +148,20 @@ func Log(ic *interop.Context) error {
 // GetTime returns timestamp of the block being verified, or the latest
 // one in the blockchain if no block is given to Context.
 func GetTime(ic *interop.Context) error {
-	ic.VM.Estack().PushItem(stackitem.NewBigInteger(new(big.Int).SetUint64(ic.Block.Timestamp)))
+	ic.VM.Estack().PushItem(stackitem.NewBigInteger(uint256.NewInt((ic.Block.Timestamp))))
 	return nil
 }
 
 // BurnGas burns GAS to benefit Neo ecosystem.
 func BurnGas(ic *interop.Context) error {
 	gas := ic.VM.Estack().Pop().BigInt()
-	if !gas.IsInt64() {
+	if !gas.IsUint64() {
 		return errors.New("invalid GAS value")
 	}
 
-	g := gas.Int64()
-	if g <= 0 {
-		return errors.New("GAS must be positive")
-	}
+	g := gas.Uint64()
 
-	if !ic.VM.AddGas(g) {
+	if !ic.VM.AddGas(int64(g)) {
 		return errors.New("GAS limit exceeded")
 	}
 	return nil

diff --git a/pkg/core/interop/runtime/ext_test.go b/pkg/core/interop/runtime/ext_test.go
@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/holiman/uint256"
 	"github.com/nspcc-dev/neo-go/internal/contracts"
 	"github.com/nspcc-dev/neo-go/internal/random"
 	"github.com/nspcc-dev/neo-go/pkg/config"
@@ -491,7 +492,7 @@ func TestGetAddressVersion(t *testing.T) {
 
 	emit.Syscall(w.BinWriter, interopnames.SystemRuntimeGetAddressVersion)
 	require.NoError(t, w.Err)
-	e.InvokeScriptCheckHALT(t, w.Bytes(), []neotest.Signer{acc}, stackitem.NewBigInteger(big.NewInt(int64(address.NEO3Prefix))))
+	e.InvokeScriptCheckHALT(t, w.Bytes(), []neotest.Signer{acc}, stackitem.NewBigInteger(uint256.NewInt(uint64(address.NEO3Prefix))))
 }
 
 func TestGetInvocationCounter(t *testing.T) {
@@ -506,19 +507,19 @@ func TestGetInvocationCounter(t *testing.T) {
 		v.Load([]byte{1})
 		// do not return an error in this case.
 		require.NoError(t, runtime.GetInvocationCounter(ic))
-		require.EqualValues(t, 1, v.Estack().Pop().BigInt().Int64())
+		require.EqualValues(t, 1, v.Estack().Pop().BigInt().Uint64())
 	})
 	t.Run("NonZero", func(t *testing.T) {
 		v.Load([]byte{2})
 		require.NoError(t, runtime.GetInvocationCounter(ic))
-		require.EqualValues(t, 42, v.Estack().Pop().BigInt().Int64())
+		require.EqualValues(t, 42, v.Estack().Pop().BigInt().Uint64())
 	})
 	t.Run("Contract", func(t *testing.T) {
 		script, err := smartcontract.CreateCallScript(cs.Hash, "invocCounter")
 		require.NoError(t, err)
 		v.LoadWithFlags(script, callflag.All)
 		require.NoError(t, v.Run())
-		require.EqualValues(t, 1, v.Estack().Pop().BigInt().Int64())
+		require.EqualValues(t, 1, v.Estack().Pop().BigInt().Uint64())
 	})
 }
 
@@ -529,7 +530,7 @@ func TestGetNetwork(t *testing.T) {
 
 	emit.Syscall(w.BinWriter, interopnames.SystemRuntimeGetNetwork)
 	require.NoError(t, w.Err)
-	e.InvokeScriptCheckHALT(t, w.Bytes(), []neotest.Signer{acc}, stackitem.NewBigInteger(big.NewInt(int64(bc.GetConfig().Magic))))
+	e.InvokeScriptCheckHALT(t, w.Bytes(), []neotest.Signer{acc}, stackitem.NewBigInteger(uint256.NewInt(uint64(bc.GetConfig().Magic))))
 }
 
 func TestGetNotifications(t *testing.T) {