vm: move StackItem to a separate package

closes #912

pkg/compiler/codegen.go

@@ -12,6 +12,8 @@ import (
  "sort"
  "strings"
 
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+
  "github.com/nspcc-dev/neo-go/pkg/encoding/address"
  "github.com/nspcc-dev/neo-go/pkg/io"
  "github.com/nspcc-dev/neo-go/pkg/vm"
@@ -720,7 +722,7 @@ func (c *codegen) Visit(node ast.Node) ast.Visitor {
  // For now we will assume that there are only byte slice conversions.
  // E.g. []byte("foobar") or []byte(scriptHash).
  ast.Walk(c, n.Args[0])
- c.emitConvert(vm.BufferT)
+ c.emitConvert(stackitem.BufferT)
  return nil
  }
 
@@ -1091,12 +1093,12 @@ func (c *codegen) convertBuiltin(expr *ast.CallExpr) {
  c.prog.Err = errors.New("panic should have string or nil argument")
  }
  case "ToInteger", "ToByteArray", "ToBool":
- typ := vm.IntegerT
+ typ := stackitem.IntegerT
  switch name {
  case "ToByteArray":
- typ = vm.ByteArrayT
+ typ = stackitem.ByteArrayT
  case "ToBool":
- typ = vm.BooleanT
+ typ = stackitem.BooleanT
  }
  c.emitConvert(typ)
  case "SHA256":
@@ -1123,7 +1125,7 @@ func (c *codegen) convertBuiltin(expr *ast.CallExpr) {
  }
  bytes := uint160.BytesBE()
  emit.Bytes(c.prog.BinWriter, bytes)
- c.emitConvert(vm.BufferT)
+ c.emitConvert(stackitem.BufferT)
  }
 }
 
@@ -1150,7 +1152,7 @@ func transformArgs(fun ast.Expr, args []ast.Expr) []ast.Expr {
 }
 
 // emitConvert converts top stack item to the specified type.
-func (c *codegen) emitConvert(typ vm.StackItemType) {
+func (c *codegen) emitConvert(typ stackitem.StackItemType) {
  emit.Instruction(c.prog.BinWriter, opcode.CONVERT, []byte{byte(typ)})
 }
 
@@ -1162,7 +1164,7 @@ func (c *codegen) convertByteArray(lit *ast.CompositeLit) {
  buf[i] = byte(val)
  }
  emit.Bytes(c.prog.BinWriter, buf)
- c.emitConvert(vm.BufferT)
+ c.emitConvert(stackitem.BufferT)
 }
 
 func (c *codegen) convertMap(lit *ast.CompositeLit) {

pkg/compiler/for_test.go

@@ -5,7 +5,7 @@ import (
  "math/big"
  "testing"
 
- "github.com/nspcc-dev/neo-go/pkg/vm"
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 )
 
 func TestEntryPointWithMethod(t *testing.T) {
@@ -30,7 +30,7 @@ func TestEntryPointWithArgs(t *testing.T) {
  return 2 + args[1].(int)
  }
  `
- args := []vm.StackItem{vm.NewBigIntegerItem(big.NewInt(0)), vm.NewBigIntegerItem(big.NewInt(1))}
+ args := []stackitem.StackItem{stackitem.NewBigIntegerItem(big.NewInt(0)), stackitem.NewBigIntegerItem(big.NewInt(1))}
  evalWithArgs(t, src, nil, args, big.NewInt(3))
 }
 
@@ -45,7 +45,7 @@ func TestEntryPointWithMethodAndArgs(t *testing.T) {
  return 0
  }
  `
- args := []vm.StackItem{vm.NewBigIntegerItem(big.NewInt(0)), vm.NewBigIntegerItem(big.NewInt(1))}
+ args := []stackitem.StackItem{stackitem.NewBigIntegerItem(big.NewInt(0)), stackitem.NewBigIntegerItem(big.NewInt(1))}
  evalWithArgs(t, src, []byte("foobar"), args, big.NewInt(3))
 }
 
@@ -134,10 +134,10 @@ func TestStringArray(t *testing.T) {
  return x
  }
  `
- eval(t, src, []vm.StackItem{
- vm.NewByteArrayItem([]byte("foo")),
- vm.NewByteArrayItem([]byte("bar")),
- vm.NewByteArrayItem([]byte("foobar")),
+ eval(t, src, []stackitem.StackItem{
+ stackitem.NewByteArrayItem([]byte("foo")),
+ stackitem.NewByteArrayItem([]byte("bar")),
+ stackitem.NewByteArrayItem([]byte("foobar")),
  })
 }
 
@@ -149,10 +149,10 @@ func TestIntArray(t *testing.T) {
  return arr
  }
  `
- eval(t, src, []vm.StackItem{
- vm.NewBigIntegerItem(big.NewInt(1)),
- vm.NewBigIntegerItem(big.NewInt(2)),
- vm.NewBigIntegerItem(big.NewInt(3)),
+ eval(t, src, []stackitem.StackItem{
+ stackitem.NewBigIntegerItem(big.NewInt(1)),
+ stackitem.NewBigIntegerItem(big.NewInt(2)),
+ stackitem.NewBigIntegerItem(big.NewInt(3)),
  })
 }
 
@@ -198,7 +198,7 @@ func TestSimpleString(t *testing.T) {
  return x
  }
  `
- eval(t, src, vm.NewByteArrayItem([]byte("NEO")).Value())
+ eval(t, src, stackitem.NewByteArrayItem([]byte("NEO")).Value())
 }
 
 func TestBoolAssign(t *testing.T) {
@@ -315,7 +315,7 @@ func TestAppendString(t *testing.T) {
  return arr[3]
  }
  `
- eval(t, src, vm.NewByteArrayItem([]byte("d")).Value())
+ eval(t, src, stackitem.NewByteArrayItem([]byte("d")).Value())
 }
 
 func TestAppendInt(t *testing.T) {

pkg/compiler/slice_test.go

@@ -4,7 +4,7 @@ import (
  "math/big"
  "testing"
 
- "github.com/nspcc-dev/neo-go/pkg/vm"
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 )
 
 var sliceTestCases = []testCase{
@@ -160,9 +160,9 @@ var sliceTestCases = []testCase{
  a = append(a, "b")
  return a
  }`,
- []vm.StackItem{
- vm.NewByteArrayItem([]byte("a")),
- vm.NewByteArrayItem([]byte("b")),
+ []stackitem.StackItem{
+ stackitem.NewByteArrayItem([]byte("a")),
+ stackitem.NewByteArrayItem([]byte("b")),
  },
  },
  {
@@ -175,9 +175,9 @@ var sliceTestCases = []testCase{
  a = append(a, "b")
  return a
  }`,
- []vm.StackItem{
- vm.NewByteArrayItem([]byte("a")),
- vm.NewByteArrayItem([]byte("b")),
+ []stackitem.StackItem{
+ stackitem.NewByteArrayItem([]byte("a")),
+ stackitem.NewByteArrayItem([]byte("b")),
  },
  },
  {

pkg/compiler/struct_test.go

@@ -4,7 +4,7 @@ import (
  "math/big"
  "testing"
 
- "github.com/nspcc-dev/neo-go/pkg/vm"
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 )
 
 var structTestCases = []testCase{
@@ -281,11 +281,11 @@ var structTestCases = []testCase{
  return newToken()
  }
  `,
- []vm.StackItem{
- vm.NewBigIntegerItem(big.NewInt(1)),
- vm.NewBigIntegerItem(big.NewInt(2)),
- vm.NewByteArrayItem([]byte("hello")),
- vm.NewBoolItem(false),
+ []stackitem.StackItem{
+ stackitem.NewBigIntegerItem(big.NewInt(1)),
+ stackitem.NewBigIntegerItem(big.NewInt(2)),
+ stackitem.NewByteArrayItem([]byte("hello")),
+ stackitem.NewBoolItem(false),
  },
  },
  {

pkg/compiler/syscall_test.go

@@ -4,7 +4,8 @@ import (
  "math/big"
  "testing"
 
- "github.com/nspcc-dev/neo-go/pkg/vm"
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+
  "github.com/stretchr/testify/assert"
  "github.com/stretchr/testify/require"
 )
@@ -41,8 +42,8 @@ func TestNotify(t *testing.T) {
  require.NoError(t, v.Run())
  require.Equal(t, 3, len(s.events))
 
- exp0 := []vm.StackItem{vm.NewBigIntegerItem(big.NewInt(11)), vm.NewByteArrayItem([]byte("sum")), vm.NewBigIntegerItem(big.NewInt(12))}
+ exp0 := []stackitem.StackItem{stackitem.NewBigIntegerItem(big.NewInt(11)), stackitem.NewByteArrayItem([]byte("sum")), stackitem.NewBigIntegerItem(big.NewInt(12))}
  assert.Equal(t, exp0, s.events[0].Value())
- assert.Equal(t, []vm.StackItem{}, s.events[1].Value())
- assert.Equal(t, []vm.StackItem{vm.NewByteArrayItem([]byte("single"))}, s.events[2].Value())
+ assert.Equal(t, []stackitem.StackItem{}, s.events[1].Value())
+ assert.Equal(t, []stackitem.StackItem{stackitem.NewByteArrayItem([]byte("single"))}, s.events[2].Value())
 }

pkg/compiler/vm_test.go

@@ -5,6 +5,8 @@ import (
  "strings"
  "testing"
 
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+
  "github.com/nspcc-dev/neo-go/pkg/compiler"
  "github.com/nspcc-dev/neo-go/pkg/vm"
  "github.com/nspcc-dev/neo-go/pkg/vm/emit"
@@ -38,7 +40,7 @@ func eval(t *testing.T, src string, result interface{}) {
  assertResult(t, vm, result)
 }
 
-func evalWithArgs(t *testing.T, src string, op []byte, args []vm.StackItem, result interface{}) {
+func evalWithArgs(t *testing.T, src string, op []byte, args []stackitem.StackItem, result interface{}) {
  vm := vmAndCompile(t, src)
  vm.LoadArgs(op, args)
  err := vm.Run()
@@ -73,7 +75,7 @@ func vmAndCompileInterop(t *testing.T, src string) (*vm.VM, *storagePlugin) {
 type storagePlugin struct {
  mem map[string][]byte
  interops map[uint32]vm.InteropFunc
- events []vm.StackItem
+ events []stackitem.StackItem
 }
 
 func newStoragePlugin() *storagePlugin {

pkg/core/blockchain.go

@@ -9,6 +9,10 @@ import (
  "sync/atomic"
  "time"
 
+ "github.com/nspcc-dev/neo-go/pkg/vm/bigint"
+
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+
  "github.com/nspcc-dev/neo-go/pkg/config"
  "github.com/nspcc-dev/neo-go/pkg/core/block"
  "github.com/nspcc-dev/neo-go/pkg/core/dao"
@@ -745,7 +749,7 @@ func (bc *Blockchain) storeBlock(block *block.Block) error {
  return errors.Wrap(err, "failed to persist invocation results")
  }
  for _, note := range systemInterop.Notifications {
- arr, ok := note.Item.Value().([]vm.StackItem)
+ arr, ok := note.Item.Value().([]stackitem.StackItem)
  if !ok || len(arr) != 4 {
  continue
  }
@@ -777,7 +781,7 @@ func (bc *Blockchain) storeBlock(block *block.Block) error {
  if !ok {
  continue
  }
- amount = emit.BytesToInt(bs)
+ amount = bigint.BytesToInt(bs)
  }
  bc.processNEP5Transfer(cache, tx, block, note.ScriptHash, from, to, amount.Int64())
  }

pkg/core/interop/context.go

@@ -15,6 +15,7 @@ import (
  "github.com/nspcc-dev/neo-go/pkg/util"
  "github.com/nspcc-dev/neo-go/pkg/vm"
  "github.com/nspcc-dev/neo-go/pkg/vm/emit"
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
  "go.uber.org/zap"
 )
 
@@ -60,7 +61,7 @@ type Function struct {
 }
 
 // Method is a signature for a native method.
-type Method = func(ic *Context, args []vm.StackItem) vm.StackItem
+type Method = func(ic *Context, args []stackitem.StackItem) stackitem.StackItem
 
 // MethodAndPrice is a native-contract method descriptor.
 type MethodAndPrice struct {

pkg/core/interop/crypto/ecdsa.go

@@ -4,6 +4,8 @@ import (
  "errors"
  "fmt"
 
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+
  "github.com/nspcc-dev/neo-go/pkg/core/interop"
  "github.com/nspcc-dev/neo-go/pkg/crypto"
  "github.com/nspcc-dev/neo-go/pkg/crypto/hash"
@@ -48,12 +50,12 @@ func ECDSACheckMultisig(ic *interop.Context, v *vm.VM) error {
  return nil
 }
 
-func getMessage(ic *interop.Context, item vm.StackItem) []byte {
+func getMessage(ic *interop.Context, item stackitem.StackItem) []byte {
  var msg []byte
  switch val := item.(type) {
- case *vm.InteropItem:
+ case *stackitem.InteropItem:
  msg = val.Value().(crypto.Verifiable).GetSignedPart()
- case vm.NullItem:
+ case stackitem.NullItem:
  msg = ic.Container.GetSignedPart()
  default:
  var err error

pkg/core/interop/crypto/ecdsa_test.go

@@ -4,6 +4,8 @@ import (
  "encoding/binary"
  "testing"
 
+ "github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+
  "github.com/nspcc-dev/neo-go/pkg/core/interop"
  "github.com/nspcc-dev/neo-go/pkg/crypto/keys"
  "github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger"
@@ -13,12 +15,12 @@ import (
  "github.com/stretchr/testify/require"
 )
 
-func initCHECKMULTISIG(msg []byte, n int) ([]vm.StackItem, []vm.StackItem, map[string]*keys.PublicKey, error) {
+func initCHECKMULTISIG(msg []byte, n int) ([]stackitem.StackItem, []stackitem.StackItem, map[string]*keys.PublicKey, error) {
  var err error
 
  keyMap := make(map[string]*keys.PublicKey)
  pkeys := make([]*keys.PrivateKey, n)
- pubs := make([]vm.StackItem, n)
+ pubs := make([]stackitem.StackItem, n)
  for i := range pubs {
  pkeys[i], err = keys.NewPrivateKey()
  if err != nil {
@@ -27,25 +29,25 @@ func initCHECKMULTISIG(msg []byte, n int) ([]vm.StackItem, []vm.StackItem, map[s
 
  pk := pkeys[i].PublicKey()
  data := pk.Bytes()
- pubs[i] = vm.NewByteArrayItem(data)
+ pubs[i] = stackitem.NewByteArrayItem(data)
  keyMap[string(data)] = pk
  }
 
- sigs := make([]vm.StackItem, n)
+ sigs := make([]stackitem.StackItem, n)
  for i := range sigs {
  sig := pkeys[i].Sign(msg)
- sigs[i] = vm.NewByteArrayItem(sig)
+ sigs[i] = stackitem.NewByteArrayItem(sig)
  }
 
  return pubs, sigs, keyMap, nil
 }
 
-func subSlice(arr []vm.StackItem, indices []int) []vm.StackItem {
+func subSlice(arr []stackitem.StackItem, indices []int) []stackitem.StackItem {
  if indices == nil {
  return arr
  }
 
- result := make([]vm.StackItem, len(indices))
+ result := make([]stackitem.StackItem, len(indices))
  for i, j := range indices {
  result[i] = arr[j]
  }