diff --git a/pkg/core/blockchain.go b/pkg/core/blockchain.go
index 068401b03..24f98ffcb 100644
--- a/pkg/core/blockchain.go
+++ b/pkg/core/blockchain.go
@@ -1,6 +1,7 @@
 package core
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"math"
@@ -12,6 +13,7 @@ import (
 	"github.com/CityOfZion/neo-go/pkg/core/transaction"
 	"github.com/CityOfZion/neo-go/pkg/io"
 	"github.com/CityOfZion/neo-go/pkg/util"
+	"github.com/CityOfZion/neo-go/pkg/vm"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 )
@@ -902,28 +904,35 @@ func (bc *Blockchain) VerifyWitnesses(t *transaction.Transaction) error {
 		verification := witnesses[i].VerificationScript
 
 		if len(verification) == 0 {
-			/*TODO: replicate following C# code:
-			using (ScriptBuilder sb = new ScriptBuilder())
-			{
-				sb.EmitAppCall(hashes[i].ToArray());
-				verification = sb.ToArray();
+			bb := new(bytes.Buffer)
+			err = vm.EmitAppCall(bb, hashes[i], false)
+			if err != nil {
+				return err
 			}
-			*/
-
+			verification = bb.Bytes()
 		} else {
 			if h := witnesses[i].ScriptHash(); hashes[i] != h {
 				return errors.Errorf("hash mismatch for script #%d", i)
 			}
 		}
 
-		/*TODO: replicate following C# code:
-		using (ApplicationEngine engine = new ApplicationEngine(TriggerType.Verification, verifiable, snapshot, Fixed8.Zero))
-		{
-			engine.LoadScript(verification);
-			engine.LoadScript(verifiable.Witnesses[i].InvocationScript);
-			if (!engine.Execute()) return false;
-			if (engine.ResultStack.Count != 1 || !engine.ResultStack.Pop().GetBoolean()) return false;
-		}*/
+		vm := vm.New(vm.ModeMute)
+		vm.SetCheckedHash(t.VerificationHash().Bytes())
+		vm.LoadScript(verification)
+		vm.LoadScript(witnesses[i].InvocationScript)
+		vm.Run()
+		if vm.HasFailed() {
+			return errors.Errorf("vm failed to execute the script")
+		}
+		res := vm.PopResult()
+		switch res.(type) {
+		case bool:
+			if !(res.(bool)) {
+				return errors.Errorf("signature check failed")
+			}
+		default:
+			return errors.Errorf("vm returned non-boolean result")
+		}
 	}
 
 	return nil
diff --git a/pkg/core/transaction/transaction.go b/pkg/core/transaction/transaction.go
index 13bdca753..1d9db3349 100644
--- a/pkg/core/transaction/transaction.go
+++ b/pkg/core/transaction/transaction.go
@@ -39,9 +39,12 @@ type Transaction struct {
 	// and invocation script.
 	Scripts []*Witness `json:"scripts"`
 
-	// hash of the transaction
+	// Hash of the transaction (double SHA256).
 	hash util.Uint256
 
+	// Hash of the transaction used to verify it (single SHA256).
+	verificationHash util.Uint256
+
 	// Trimmed indicates this is a transaction from trimmed
 	// data.
 	Trimmed bool `json:"-"`
@@ -59,11 +62,23 @@ func NewTrimmedTX(hash util.Uint256) *Transaction {
 // Hash return the hash of the transaction.
 func (t *Transaction) Hash() util.Uint256 {
 	if t.hash.Equals(util.Uint256{}) {
-		t.createHash()
+		if t.createHash() != nil {
+			panic("failed to compute hash!")
+		}
 	}
 	return t.hash
 }
 
+// VerificationHash returns the hash of the transaction used to verify it.
+func (t *Transaction) VerificationHash() util.Uint256 {
+	if t.verificationHash.Equals(util.Uint256{}) {
+		if t.createHash() != nil {
+			panic("failed to compute hash!")
+		}
+	}
+	return t.verificationHash
+}
+
 // AddOutput adds the given output to the transaction outputs.
 func (t *Transaction) AddOutput(out *Output) {
 	t.Outputs = append(t.Outputs, out)
@@ -196,7 +211,9 @@ func (t *Transaction) createHash() error {
 		return buf.Err
 	}
 
-	t.hash = hash.DoubleSha256(buf.Bytes())
+	b := buf.Bytes()
+	t.hash = hash.DoubleSha256(b)
+	t.verificationHash = hash.Sha256(b)
 
 	return nil
 }
diff --git a/pkg/vm/stack.go b/pkg/vm/stack.go
index e840bccb7..e0987637d 100644
--- a/pkg/vm/stack.go
+++ b/pkg/vm/stack.go
@@ -1,6 +1,7 @@
 package vm
 
 import (
+	"fmt"
 	"math/big"
 
 	"github.com/CityOfZion/neo-go/pkg/util"
@@ -280,3 +281,39 @@ func (s *Stack) Iter(f func(*Element)) {
 		f(e)
 	}
 }
+
+// popSigElements pops keys or signatures from the stack as needed for
+// CHECKMULTISIG.
+func (s *Stack) popSigElements() ([][]byte, error) {
+	var num int
+	var elems [][]byte
+	item := s.Pop()
+	if item == nil {
+		return nil, fmt.Errorf("nothing on the stack")
+	}
+	switch item.value.(type) {
+	case *ArrayItem:
+		num = len(item.Array())
+		if num < 1 {
+			return nil, fmt.Errorf("less than one element in the array")
+		}
+		elems = make([][]byte, num)
+		for k, v := range item.Array() {
+			b, ok := v.Value().([]byte)
+			if !ok {
+				return nil, fmt.Errorf("bad element %s", v.String())
+			}
+			elems[k] = b
+		}
+	default:
+		num = int(item.BigInt().Int64())
+		if num < 1 || num > s.Len() {
+			return nil, fmt.Errorf("wrong number of elements: %d", num)
+		}
+		elems = make([][]byte, num)
+		for i := 0; i < num; i++ {
+			elems[i] = s.Pop().Bytes()
+		}
+	}
+	return elems, nil
+}
diff --git a/pkg/vm/stack_test.go b/pkg/vm/stack_test.go
index e4e32fab4..ffc0f4c5d 100644
--- a/pkg/vm/stack_test.go
+++ b/pkg/vm/stack_test.go
@@ -217,6 +217,44 @@ func TestSwapElemValues(t *testing.T) {
 	assert.Equal(t, int64(4), s.Pop().BigInt().Int64())
 }
 
+func TestPopSigElements(t *testing.T) {
+	s := NewStack("test")
+
+	_, err := s.popSigElements()
+	assert.NotNil(t, err)
+
+	s.PushVal([]StackItem{})
+	_, err = s.popSigElements()
+	assert.NotNil(t, err)
+
+	s.PushVal([]StackItem{NewBoolItem(false)})
+	_, err = s.popSigElements()
+	assert.NotNil(t, err)
+
+	b1 := []byte("smth")
+	b2 := []byte("strange")
+	s.PushVal([]StackItem{NewByteArrayItem(b1), NewByteArrayItem(b2)})
+	z, err := s.popSigElements()
+	assert.Nil(t, err)
+	assert.Equal(t, z, [][]byte{b1, b2})
+
+	s.PushVal(2)
+	_, err = s.popSigElements()
+	assert.NotNil(t, err)
+
+	s.PushVal(b1)
+	s.PushVal(2)
+	_, err = s.popSigElements()
+	assert.NotNil(t, err)
+
+	s.PushVal(b2)
+	s.PushVal(b1)
+	s.PushVal(2)
+	z, err = s.popSigElements()
+	assert.Nil(t, err)
+	assert.Equal(t, z, [][]byte{b1, b2})
+}
+
 func makeElements(n int) []*Element {
 	elems := make([]*Element, n)
 	for i := 0; i < n; i++ {
diff --git a/pkg/vm/vm.go b/pkg/vm/vm.go
index 0108b6a4e..23760fbb9 100644
--- a/pkg/vm/vm.go
+++ b/pkg/vm/vm.go
@@ -11,6 +11,7 @@ import (
 	"text/tabwriter"
 
 	"github.com/CityOfZion/neo-go/pkg/crypto/hash"
+	"github.com/CityOfZion/neo-go/pkg/crypto/keys"
 	"github.com/CityOfZion/neo-go/pkg/util"
 )
 
@@ -43,6 +44,8 @@ type VM struct {
 
 	// Mute all output after execution.
 	mute bool
+	// Hash to verify in CHECKSIG/CHECKMULTISIG.
+	checkhash []byte
 }
 
 // New returns a new VM object ready to load .avm bytecode scripts.
@@ -233,6 +236,18 @@ func (v *VM) Step() {
 	}
 }
 
+// HasFailed returns whether VM is in the failed state now. Usually used to
+// check status after Run.
+func (v *VM) HasFailed() bool {
+	return v.state.HasFlag(faultState)
+}
+
+// SetCheckedHash sets checked hash for CHECKSIG and CHECKMULTISIG instructions.
+func (v *VM) SetCheckedHash(h []byte) {
+	v.checkhash = make([]byte, len(h))
+	copy(v.checkhash, h)
+}
+
 // execute performs an instruction cycle in the VM. Acting on the instruction (opcode).
 func (v *VM) execute(ctx *Context, op Instruction) {
 	// Instead of polluting the whole VM logic with error handling, we will recover
@@ -842,7 +857,62 @@ func (v *VM) execute(ctx *Context, op Instruction) {
 			v.state = haltState
 		}
 
-	case CHECKSIG, VERIFY, CHECKMULTISIG, NEWMAP, HASKEY, KEYS, VALUES:
+	case CHECKSIG, VERIFY:
+		var hashToCheck []byte
+
+		keyb := v.estack.Pop().Bytes()
+		signature := v.estack.Pop().Bytes()
+		if op == CHECKSIG {
+			if v.checkhash == nil {
+				panic("VM is not set up properly for signature checks")
+			}
+			hashToCheck = v.checkhash
+		} else { // VERIFY
+			msg := v.estack.Pop().Bytes()
+			hashToCheck = hash.Sha256(msg).Bytes()
+		}
+		pkey := &keys.PublicKey{}
+		err := pkey.DecodeBytes(keyb)
+		if err != nil {
+			panic(err.Error())
+		}
+		res := pkey.Verify(signature, hashToCheck)
+		v.estack.PushVal(res)
+
+	case CHECKMULTISIG:
+		pkeys, err := v.estack.popSigElements()
+		if err != nil {
+			panic(fmt.Sprintf("wrong parameters: %s", err.Error()))
+		}
+		sigs, err := v.estack.popSigElements()
+		if err != nil {
+			panic(fmt.Sprintf("wrong parameters: %s", err.Error()))
+		}
+		if len(pkeys) < len(sigs) {
+			panic("more signatures than there are keys")
+		}
+		if v.checkhash == nil {
+			panic("VM is not set up properly for signature checks")
+		}
+		sigok := true
+		j := 0
+		for i := 0; sigok && i < len(pkeys) && j < len(sigs); {
+			pkey := &keys.PublicKey{}
+			err := pkey.DecodeBytes(pkeys[j])
+			if err != nil {
+				panic(err.Error())
+			}
+			if pkey.Verify(sigs[i], v.checkhash) {
+				i++
+			}
+			j++
+			if len(pkeys)-i > len(sigs)-j {
+				sigok = false
+			}
+		}
+		v.estack.PushVal(sigok)
+
+	case NEWMAP, HASKEY, KEYS, VALUES:
 		panic("unimplemented")
 
 	// Cryptographic operations.
diff --git a/pkg/vm/vm_test.go b/pkg/vm/vm_test.go
index 80cceba9b..11562c339 100644
--- a/pkg/vm/vm_test.go
+++ b/pkg/vm/vm_test.go
@@ -7,6 +7,8 @@ import (
 	"math/rand"
 	"testing"
 
+	"github.com/CityOfZion/neo-go/pkg/crypto/hash"
+	"github.com/CityOfZion/neo-go/pkg/crypto/keys"
 	"github.com/CityOfZion/neo-go/pkg/util"
 	"github.com/stretchr/testify/assert"
 )
@@ -23,7 +25,7 @@ func TestInteropHook(t *testing.T) {
 	EmitOpcode(buf, RET)
 	v.Load(buf.Bytes())
 	v.Run()
-	assert.Equal(t, false, v.state.HasFlag(faultState))
+	assert.Equal(t, false, v.HasFailed())
 	assert.Equal(t, 1, v.estack.Len())
 	assert.Equal(t, big.NewInt(1), v.estack.Pop().value.Value())
 }
@@ -65,7 +67,7 @@ func TestPushBytesNoParam(t *testing.T) {
 	prog[0] = byte(PUSHBYTES1)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushBytesShort(t *testing.T) {
@@ -73,7 +75,7 @@ func TestPushBytesShort(t *testing.T) {
 	prog[0] = byte(PUSHBYTES10) // but only 9 left in the `prog`
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushm1to16(t *testing.T) {
@@ -103,21 +105,21 @@ func TestPushData1BadNoN(t *testing.T) {
 	prog := []byte{byte(PUSHDATA1)}
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushData1BadN(t *testing.T) {
 	prog := []byte{byte(PUSHDATA1), 1}
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushData1Good(t *testing.T) {
 	prog := makeProgram(PUSHDATA1, 3, 1, 2, 3)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte{1, 2, 3}, vm.estack.Pop().Bytes())
 }
@@ -126,28 +128,28 @@ func TestPushData2BadNoN(t *testing.T) {
 	prog := []byte{byte(PUSHDATA2)}
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushData2ShortN(t *testing.T) {
 	prog := []byte{byte(PUSHDATA2), 0}
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushData2BadN(t *testing.T) {
 	prog := []byte{byte(PUSHDATA2), 1, 0}
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushData2Good(t *testing.T) {
 	prog := makeProgram(PUSHDATA2, 3, 0, 1, 2, 3)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte{1, 2, 3}, vm.estack.Pop().Bytes())
 }
@@ -156,28 +158,28 @@ func TestPushData4BadNoN(t *testing.T) {
 	prog := []byte{byte(PUSHDATA4)}
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushData4BadN(t *testing.T) {
 	prog := []byte{byte(PUSHDATA4), 1, 0, 0, 0}
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushData4ShortN(t *testing.T) {
 	prog := []byte{byte(PUSHDATA4), 0, 0, 0}
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPushData4Good(t *testing.T) {
 	prog := makeProgram(PUSHDATA4, 3, 0, 0, 0, 1, 2, 3)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte{1, 2, 3}, vm.estack.Pop().Bytes())
 }
@@ -186,7 +188,7 @@ func TestNOTNoArgument(t *testing.T) {
 	prog := makeProgram(NOT)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestNOTBool(t *testing.T) {
@@ -194,7 +196,7 @@ func TestNOTBool(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(false)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, &BoolItem{true}, vm.estack.Pop().value)
 }
 
@@ -203,7 +205,7 @@ func TestNOTNonZeroInt(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(3)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, &BoolItem{false}, vm.estack.Pop().value)
 }
 
@@ -212,7 +214,7 @@ func TestNOTArray(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]StackItem{})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, &BoolItem{false}, vm.estack.Pop().value)
 }
 
@@ -221,7 +223,7 @@ func TestNOTStruct(t *testing.T) {
 	vm := load(prog)
 	vm.estack.Push(NewElement(&StructItem{[]StackItem{}}))
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, &BoolItem{false}, vm.estack.Pop().value)
 }
 
@@ -230,7 +232,7 @@ func TestNOTByteArray0(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]byte{0, 0})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, &BoolItem{true}, vm.estack.Pop().value)
 }
 
@@ -239,7 +241,7 @@ func TestNOTByteArray1(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]byte{0, 1})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, &BoolItem{false}, vm.estack.Pop().value)
 }
 
@@ -249,7 +251,7 @@ func TestAdd(t *testing.T) {
 	vm.estack.PushVal(4)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(6), vm.estack.Pop().BigInt().Int64())
 }
 
@@ -259,7 +261,7 @@ func TestMul(t *testing.T) {
 	vm.estack.PushVal(4)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(8), vm.estack.Pop().BigInt().Int64())
 }
 
@@ -269,7 +271,7 @@ func TestDiv(t *testing.T) {
 	vm.estack.PushVal(4)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(2), vm.estack.Pop().BigInt().Int64())
 }
 
@@ -279,7 +281,7 @@ func TestSub(t *testing.T) {
 	vm.estack.PushVal(4)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(2), vm.estack.Pop().BigInt().Int64())
 }
 
@@ -289,7 +291,7 @@ func TestSHRGood(t *testing.T) {
 	vm.estack.PushVal(4)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem(1), vm.estack.Pop().value)
 }
@@ -300,7 +302,7 @@ func TestSHRZero(t *testing.T) {
 	vm.estack.PushVal([]byte{0, 1})
 	vm.estack.PushVal(0)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem([]byte{0, 1}), vm.estack.Pop().value)
 }
@@ -311,7 +313,7 @@ func TestSHRSmallValue(t *testing.T) {
 	vm.estack.PushVal(5)
 	vm.estack.PushVal(-257)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestSHLGood(t *testing.T) {
@@ -320,7 +322,7 @@ func TestSHLGood(t *testing.T) {
 	vm.estack.PushVal(4)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem(16), vm.estack.Pop().value)
 }
@@ -331,7 +333,7 @@ func TestSHLZero(t *testing.T) {
 	vm.estack.PushVal([]byte{0, 1})
 	vm.estack.PushVal(0)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem([]byte{0, 1}), vm.estack.Pop().value)
 }
@@ -342,7 +344,7 @@ func TestSHLBigValue(t *testing.T) {
 	vm.estack.PushVal(5)
 	vm.estack.PushVal(257)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestLT(t *testing.T) {
@@ -351,7 +353,7 @@ func TestLT(t *testing.T) {
 	vm.estack.PushVal(4)
 	vm.estack.PushVal(3)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, false, vm.estack.Pop().Bool())
 }
 
@@ -361,7 +363,7 @@ func TestLTE(t *testing.T) {
 	vm.estack.PushVal(2)
 	vm.estack.PushVal(3)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, true, vm.estack.Pop().Bool())
 }
 
@@ -371,7 +373,7 @@ func TestGT(t *testing.T) {
 	vm.estack.PushVal(9)
 	vm.estack.PushVal(3)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, true, vm.estack.Pop().Bool())
 
 }
@@ -382,7 +384,7 @@ func TestGTE(t *testing.T) {
 	vm.estack.PushVal(3)
 	vm.estack.PushVal(3)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, true, vm.estack.Pop().Bool())
 }
 
@@ -393,7 +395,7 @@ func TestDepth(t *testing.T) {
 	vm.estack.PushVal(2)
 	vm.estack.PushVal(3)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(3), vm.estack.Pop().BigInt().Int64())
 }
 
@@ -401,7 +403,7 @@ func TestEQUALNoArguments(t *testing.T) {
 	prog := makeProgram(EQUAL)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestEQUALBad1Argument(t *testing.T) {
@@ -409,7 +411,7 @@ func TestEQUALBad1Argument(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestEQUALGoodInteger(t *testing.T) {
@@ -418,7 +420,7 @@ func TestEQUALGoodInteger(t *testing.T) {
 	vm.estack.PushVal(5)
 	vm.estack.PushVal(5)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &BoolItem{true}, vm.estack.Pop().value)
 }
@@ -428,7 +430,7 @@ func TestEQUALArrayTrue(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]StackItem{})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &BoolItem{true}, vm.estack.Pop().value)
 }
@@ -439,7 +441,7 @@ func TestEQUALArrayFalse(t *testing.T) {
 	vm.estack.PushVal([]StackItem{})
 	vm.estack.PushVal([]StackItem{})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &BoolItem{false}, vm.estack.Pop().value)
 }
@@ -450,7 +452,7 @@ func TestNumEqual(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, false, vm.estack.Pop().Bool())
 }
 
@@ -460,7 +462,7 @@ func TestNumNotEqual(t *testing.T) {
 	vm.estack.PushVal(2)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, false, vm.estack.Pop().Bool())
 }
 
@@ -469,7 +471,7 @@ func TestINC(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, big.NewInt(2), vm.estack.Pop().BigInt())
 }
 
@@ -478,7 +480,7 @@ func TestNEWARRAYInteger(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &ArrayItem{[]StackItem{makeStackItem(false)}}, vm.estack.Pop().value)
 }
@@ -489,7 +491,7 @@ func TestNEWARRAYStruct(t *testing.T) {
 	arr := []StackItem{makeStackItem(42)}
 	vm.estack.Push(&Element{value: &StructItem{arr}})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &ArrayItem{arr}, vm.estack.Pop().value)
 }
@@ -500,7 +502,7 @@ func TestNEWARRAYArray(t *testing.T) {
 	arr := []StackItem{makeStackItem(42)}
 	vm.estack.Push(&Element{value: &ArrayItem{arr}})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &ArrayItem{arr}, vm.estack.Pop().value)
 }
@@ -510,7 +512,7 @@ func TestNEWARRAYByteArray(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]byte{})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &ArrayItem{[]StackItem{}}, vm.estack.Pop().value)
 }
@@ -520,7 +522,7 @@ func TestNEWSTRUCTInteger(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &StructItem{[]StackItem{makeStackItem(false)}}, vm.estack.Pop().value)
 }
@@ -531,7 +533,7 @@ func TestNEWSTRUCTArray(t *testing.T) {
 	arr := []StackItem{makeStackItem(42)}
 	vm.estack.Push(&Element{value: &ArrayItem{arr}})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &StructItem{arr}, vm.estack.Pop().value)
 }
@@ -542,7 +544,7 @@ func TestNEWSTRUCTStruct(t *testing.T) {
 	arr := []StackItem{makeStackItem(42)}
 	vm.estack.Push(&Element{value: &StructItem{arr}})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &StructItem{arr}, vm.estack.Pop().value)
 }
@@ -552,7 +554,7 @@ func TestNEWSTRUCTByteArray(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]byte{})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &StructItem{[]StackItem{}}, vm.estack.Pop().value)
 }
@@ -562,7 +564,7 @@ func TestAPPENDArray(t *testing.T) {
 	vm := load(prog)
 	vm.estack.Push(&Element{value: &ArrayItem{}})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &ArrayItem{[]StackItem{makeStackItem(5)}}, vm.estack.Pop().value)
 }
@@ -572,7 +574,7 @@ func TestAPPENDStruct(t *testing.T) {
 	vm := load(prog)
 	vm.estack.Push(&Element{value: &StructItem{}})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &StructItem{[]StackItem{makeStackItem(5)}}, vm.estack.Pop().value)
 }
@@ -582,7 +584,7 @@ func TestAPPENDCloneStruct(t *testing.T) {
 	vm := load(prog)
 	vm.estack.Push(&Element{value: &ArrayItem{}})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &ArrayItem{[]StackItem{
 		&StructItem{[]StackItem{}},
@@ -593,7 +595,7 @@ func TestAPPENDBadNoArguments(t *testing.T) {
 	prog := makeProgram(APPEND)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestAPPENDBad1Argument(t *testing.T) {
@@ -601,7 +603,7 @@ func TestAPPENDBad1Argument(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestAPPENDWrongType(t *testing.T) {
@@ -610,7 +612,7 @@ func TestAPPENDWrongType(t *testing.T) {
 	vm.estack.PushVal([]byte{})
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPICKITEMBadIndex(t *testing.T) {
@@ -619,7 +621,7 @@ func TestPICKITEMBadIndex(t *testing.T) {
 	vm.estack.PushVal([]StackItem{})
 	vm.estack.PushVal(0)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPICKITEMArray(t *testing.T) {
@@ -628,7 +630,7 @@ func TestPICKITEMArray(t *testing.T) {
 	vm.estack.PushVal([]StackItem{makeStackItem(1), makeStackItem(2)})
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem(2), vm.estack.Pop().value)
 }
@@ -639,7 +641,7 @@ func TestPICKITEMByteArray(t *testing.T) {
 	vm.estack.PushVal([]byte{1, 2})
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem(2), vm.estack.Pop().value)
 }
@@ -648,7 +650,7 @@ func TestSIZENoArgument(t *testing.T) {
 	prog := makeProgram(SIZE)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestSIZEByteArray(t *testing.T) {
@@ -656,7 +658,7 @@ func TestSIZEByteArray(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]byte{0, 1})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem(2), vm.estack.Pop().value)
 }
@@ -666,7 +668,7 @@ func TestSIZEBool(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(false)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem(1), vm.estack.Pop().value)
 }
@@ -675,7 +677,7 @@ func TestSIGNNoArgument(t *testing.T) {
 	prog := makeProgram(SIGN)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestSIGNWrongType(t *testing.T) {
@@ -683,7 +685,7 @@ func TestSIGNWrongType(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]StackItem{})
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestSIGNBool(t *testing.T) {
@@ -691,7 +693,7 @@ func TestSIGNBool(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(false)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &BigIntegerItem{big.NewInt(0)}, vm.estack.Pop().value)
 }
@@ -701,7 +703,7 @@ func TestSIGNPositiveInt(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &BigIntegerItem{big.NewInt(1)}, vm.estack.Pop().value)
 }
@@ -711,7 +713,7 @@ func TestSIGNNegativeInt(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(-1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &BigIntegerItem{big.NewInt(-1)}, vm.estack.Pop().value)
 }
@@ -721,7 +723,7 @@ func TestSIGNZero(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(0)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &BigIntegerItem{big.NewInt(0)}, vm.estack.Pop().value)
 }
@@ -731,7 +733,7 @@ func TestSIGNByteArray(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]byte{0, 1})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &BigIntegerItem{big.NewInt(1)}, vm.estack.Pop().value)
 }
@@ -747,7 +749,7 @@ func TestAppCall(t *testing.T) {
 	vm.estack.PushVal(2)
 
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	elem := vm.estack.Pop() // depth should be 1
 	assert.Equal(t, int64(1), elem.BigInt().Int64())
 }
@@ -762,7 +764,7 @@ func TestSimpleCall(t *testing.T) {
 	}
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, result, int(vm.estack.Pop().BigInt().Int64()))
 }
 
@@ -771,7 +773,7 @@ func TestNZtrue(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, true, vm.estack.Pop().Bool())
 }
 
@@ -780,7 +782,7 @@ func TestNZfalse(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(0)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, false, vm.estack.Pop().Bool())
 }
 
@@ -789,7 +791,7 @@ func TestPICKbadNoitem(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPICKbadNegative(t *testing.T) {
@@ -797,7 +799,7 @@ func TestPICKbadNegative(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(-1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPICKgood(t *testing.T) {
@@ -812,7 +814,7 @@ func TestPICKgood(t *testing.T) {
 	vm.estack.PushVal(5)
 	vm.estack.PushVal(3)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(result), vm.estack.Pop().BigInt().Int64())
 }
 
@@ -822,7 +824,7 @@ func TestROTBad(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestROTGood(t *testing.T) {
@@ -832,7 +834,7 @@ func TestROTGood(t *testing.T) {
 	vm.estack.PushVal(2)
 	vm.estack.PushVal(3)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 3, vm.estack.Len())
 	assert.Equal(t, makeStackItem(1), vm.estack.Pop().value)
 	assert.Equal(t, makeStackItem(3), vm.estack.Pop().value)
@@ -844,7 +846,7 @@ func TestXTUCKbadNoitem(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestXTUCKbadNoN(t *testing.T) {
@@ -853,7 +855,7 @@ func TestXTUCKbadNoN(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestXTUCKbadNegative(t *testing.T) {
@@ -861,7 +863,7 @@ func TestXTUCKbadNegative(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(-1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestXTUCKbadZero(t *testing.T) {
@@ -870,7 +872,7 @@ func TestXTUCKbadZero(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(0)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestXTUCKgood(t *testing.T) {
@@ -886,7 +888,7 @@ func TestXTUCKgood(t *testing.T) {
 	vm.estack.PushVal(topelement)
 	vm.estack.PushVal(xtuckdepth)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(topelement), vm.estack.Peek(0).BigInt().Int64())
 	assert.Equal(t, int64(topelement), vm.estack.Peek(xtuckdepth).BigInt().Int64())
 }
@@ -895,7 +897,7 @@ func TestTUCKbadNoitems(t *testing.T) {
 	prog := makeProgram(TUCK)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestTUCKbadNoitem(t *testing.T) {
@@ -903,7 +905,7 @@ func TestTUCKbadNoitem(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestTUCKgood(t *testing.T) {
@@ -912,7 +914,7 @@ func TestTUCKgood(t *testing.T) {
 	vm.estack.PushVal(42)
 	vm.estack.PushVal(34)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(34), vm.estack.Peek(0).BigInt().Int64())
 	assert.Equal(t, int64(42), vm.estack.Peek(1).BigInt().Int64())
 	assert.Equal(t, int64(34), vm.estack.Peek(2).BigInt().Int64())
@@ -925,7 +927,7 @@ func TestTUCKgood2(t *testing.T) {
 	vm.estack.PushVal(42)
 	vm.estack.PushVal(34)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(34), vm.estack.Peek(0).BigInt().Int64())
 	assert.Equal(t, int64(42), vm.estack.Peek(1).BigInt().Int64())
 	assert.Equal(t, int64(34), vm.estack.Peek(2).BigInt().Int64())
@@ -937,7 +939,7 @@ func TestOVERbadNoitem(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem(1), vm.estack.Pop().value)
 }
@@ -946,7 +948,7 @@ func TestOVERbadNoitems(t *testing.T) {
 	prog := makeProgram(OVER)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestOVERgood(t *testing.T) {
@@ -955,7 +957,7 @@ func TestOVERgood(t *testing.T) {
 	vm.estack.PushVal(42)
 	vm.estack.PushVal(34)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(42), vm.estack.Peek(0).BigInt().Int64())
 	assert.Equal(t, int64(34), vm.estack.Peek(1).BigInt().Int64())
 	assert.Equal(t, int64(42), vm.estack.Peek(2).BigInt().Int64())
@@ -967,7 +969,7 @@ func TestNIPBadNoItem(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestNIPGood(t *testing.T) {
@@ -976,7 +978,7 @@ func TestNIPGood(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, makeStackItem(2), vm.estack.Pop().value)
 }
@@ -985,7 +987,7 @@ func TestDROPBadNoItem(t *testing.T) {
 	prog := makeProgram(DROP)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestDROPGood(t *testing.T) {
@@ -993,7 +995,7 @@ func TestDROPGood(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 0, vm.estack.Len())
 }
 
@@ -1001,7 +1003,7 @@ func TestXDROPbadNoitem(t *testing.T) {
 	prog := makeProgram(XDROP)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestXDROPbadNoN(t *testing.T) {
@@ -1010,7 +1012,7 @@ func TestXDROPbadNoN(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestXDROPbadNegative(t *testing.T) {
@@ -1019,7 +1021,7 @@ func TestXDROPbadNegative(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(-1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestXDROPgood(t *testing.T) {
@@ -1030,7 +1032,7 @@ func TestXDROPgood(t *testing.T) {
 	vm.estack.PushVal(2)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 2, vm.estack.Len())
 	assert.Equal(t, int64(2), vm.estack.Peek(0).BigInt().Int64())
 	assert.Equal(t, int64(1), vm.estack.Peek(1).BigInt().Int64())
@@ -1040,7 +1042,7 @@ func TestINVERTbadNoitem(t *testing.T) {
 	prog := makeProgram(INVERT)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestINVERTgood1(t *testing.T) {
@@ -1048,7 +1050,7 @@ func TestINVERTgood1(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(0)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(-1), vm.estack.Peek(0).BigInt().Int64())
 }
 
@@ -1057,7 +1059,7 @@ func TestINVERTgood2(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(-1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(0), vm.estack.Peek(0).BigInt().Int64())
 }
 
@@ -1066,7 +1068,7 @@ func TestINVERTgood3(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(0x69)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, int64(-0x6A), vm.estack.Peek(0).BigInt().Int64())
 }
 
@@ -1074,7 +1076,7 @@ func TestCATBadNoArgs(t *testing.T) {
 	prog := makeProgram(CAT)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestCATBadOneArg(t *testing.T) {
@@ -1082,7 +1084,7 @@ func TestCATBadOneArg(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal([]byte("abc"))
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestCATGood(t *testing.T) {
@@ -1091,7 +1093,7 @@ func TestCATGood(t *testing.T) {
 	vm.estack.PushVal([]byte("abc"))
 	vm.estack.PushVal([]byte("def"))
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte("abcdef"), vm.estack.Peek(0).Bytes())
 }
@@ -1102,7 +1104,7 @@ func TestCATInt0ByteArray(t *testing.T) {
 	vm.estack.PushVal(0)
 	vm.estack.PushVal([]byte{})
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &ByteArrayItem{[]byte{}}, vm.estack.Pop().value)
 }
@@ -1113,7 +1115,7 @@ func TestCATByteArrayInt1(t *testing.T) {
 	vm.estack.PushVal([]byte{})
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, &ByteArrayItem{[]byte{1}}, vm.estack.Pop().value)
 }
@@ -1122,7 +1124,7 @@ func TestSUBSTRBadNoArgs(t *testing.T) {
 	prog := makeProgram(SUBSTR)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestSUBSTRBadOneArg(t *testing.T) {
@@ -1130,7 +1132,7 @@ func TestSUBSTRBadOneArg(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestSUBSTRBadTwoArgs(t *testing.T) {
@@ -1139,7 +1141,7 @@ func TestSUBSTRBadTwoArgs(t *testing.T) {
 	vm.estack.PushVal(0)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestSUBSTRGood(t *testing.T) {
@@ -1149,7 +1151,7 @@ func TestSUBSTRGood(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte("bc"), vm.estack.Peek(0).Bytes())
 }
@@ -1161,7 +1163,7 @@ func TestSUBSTRBadOffset(t *testing.T) {
 	vm.estack.PushVal(7)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestSUBSTRBigLen(t *testing.T) {
@@ -1171,7 +1173,7 @@ func TestSUBSTRBigLen(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(6)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte("bcdef"), vm.estack.Pop().Bytes())
 }
@@ -1185,7 +1187,7 @@ func TestSUBSTRBad387(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(6)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte("bcdef"), vm.estack.Pop().Bytes())
 }
@@ -1197,7 +1199,7 @@ func TestSUBSTRBadNegativeOffset(t *testing.T) {
 	vm.estack.PushVal(-1)
 	vm.estack.PushVal(3)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestSUBSTRBadNegativeLen(t *testing.T) {
@@ -1207,14 +1209,14 @@ func TestSUBSTRBadNegativeLen(t *testing.T) {
 	vm.estack.PushVal(3)
 	vm.estack.PushVal(-1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestLEFTBadNoArgs(t *testing.T) {
 	prog := makeProgram(LEFT)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestLEFTBadNoString(t *testing.T) {
@@ -1222,7 +1224,7 @@ func TestLEFTBadNoString(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestLEFTBadNegativeLen(t *testing.T) {
@@ -1231,7 +1233,7 @@ func TestLEFTBadNegativeLen(t *testing.T) {
 	vm.estack.PushVal([]byte("abcdef"))
 	vm.estack.PushVal(-1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestLEFTGood(t *testing.T) {
@@ -1240,7 +1242,7 @@ func TestLEFTGood(t *testing.T) {
 	vm.estack.PushVal([]byte("abcdef"))
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte("ab"), vm.estack.Peek(0).Bytes())
 }
@@ -1251,7 +1253,7 @@ func TestLEFTGoodLen(t *testing.T) {
 	vm.estack.PushVal([]byte("abcdef"))
 	vm.estack.PushVal(8)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte("abcdef"), vm.estack.Peek(0).Bytes())
 }
@@ -1260,7 +1262,7 @@ func TestRIGHTBadNoArgs(t *testing.T) {
 	prog := makeProgram(RIGHT)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestRIGHTBadNoString(t *testing.T) {
@@ -1268,7 +1270,7 @@ func TestRIGHTBadNoString(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestRIGHTBadNegativeLen(t *testing.T) {
@@ -1277,7 +1279,7 @@ func TestRIGHTBadNegativeLen(t *testing.T) {
 	vm.estack.PushVal([]byte("abcdef"))
 	vm.estack.PushVal(-1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestRIGHTGood(t *testing.T) {
@@ -1286,7 +1288,7 @@ func TestRIGHTGood(t *testing.T) {
 	vm.estack.PushVal([]byte("abcdef"))
 	vm.estack.PushVal(2)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []byte("ef"), vm.estack.Peek(0).Bytes())
 }
@@ -1297,7 +1299,7 @@ func TestRIGHTBadLen(t *testing.T) {
 	vm.estack.PushVal([]byte("abcdef"))
 	vm.estack.PushVal(8)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPACKBadLen(t *testing.T) {
@@ -1305,7 +1307,7 @@ func TestPACKBadLen(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestPACKGoodZeroLen(t *testing.T) {
@@ -1313,7 +1315,7 @@ func TestPACKGoodZeroLen(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(0)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 1, vm.estack.Len())
 	assert.Equal(t, []StackItem{}, vm.estack.Peek(0).Array())
 }
@@ -1329,7 +1331,7 @@ func TestPACKGood(t *testing.T) {
 	}
 	vm.estack.PushVal(len(elements))
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 2, vm.estack.Len())
 	a := vm.estack.Peek(0).Array()
 	assert.Equal(t, len(elements), len(a))
@@ -1345,7 +1347,7 @@ func TestUNPACKBadNotArray(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestUNPACKGood(t *testing.T) {
@@ -1356,7 +1358,7 @@ func TestUNPACKGood(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(elements)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 5, vm.estack.Len())
 	assert.Equal(t, int64(len(elements)), vm.estack.Peek(0).BigInt().Int64())
 	for k, v := range elements {
@@ -1370,7 +1372,7 @@ func TestREVERSEBadNotArray(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestREVERSEGoodOneElem(t *testing.T) {
@@ -1380,7 +1382,7 @@ func TestREVERSEGoodOneElem(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(elements)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 2, vm.estack.Len())
 	a := vm.estack.Peek(0).Array()
 	assert.Equal(t, len(elements), len(a))
@@ -1405,7 +1407,7 @@ func TestREVERSEGoodStruct(t *testing.T) {
 		vm.estack.Push(&Element{value: &StructItem{arr}})
 
 		vm.Run()
-		assert.Equal(t, false, vm.state.HasFlag(faultState))
+		assert.Equal(t, false, vm.HasFailed())
 		assert.Equal(t, 2, vm.estack.Len())
 		a := vm.estack.Peek(0).Array()
 		assert.Equal(t, len(elements), len(a))
@@ -1428,7 +1430,7 @@ func TestREVERSEGood(t *testing.T) {
 		vm.estack.PushVal(1)
 		vm.estack.PushVal(elements)
 		vm.Run()
-		assert.Equal(t, false, vm.state.HasFlag(faultState))
+		assert.Equal(t, false, vm.HasFailed())
 		assert.Equal(t, 2, vm.estack.Len())
 		a := vm.estack.Peek(0).Array()
 		assert.Equal(t, len(elements), len(a))
@@ -1444,7 +1446,7 @@ func TestREMOVEBadNoArgs(t *testing.T) {
 	prog := makeProgram(REMOVE)
 	vm := load(prog)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestREMOVEBadOneArg(t *testing.T) {
@@ -1452,7 +1454,7 @@ func TestREMOVEBadOneArg(t *testing.T) {
 	vm := load(prog)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestREMOVEBadNotArray(t *testing.T) {
@@ -1461,7 +1463,7 @@ func TestREMOVEBadNotArray(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(1)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestREMOVEBadIndex(t *testing.T) {
@@ -1471,7 +1473,7 @@ func TestREMOVEBadIndex(t *testing.T) {
 	vm.estack.PushVal(elements)
 	vm.estack.PushVal(10)
 	vm.Run()
-	assert.Equal(t, true, vm.state.HasFlag(faultState))
+	assert.Equal(t, true, vm.HasFailed())
 }
 
 func TestREMOVEGood(t *testing.T) {
@@ -1482,12 +1484,258 @@ func TestREMOVEGood(t *testing.T) {
 	vm.estack.PushVal(1)
 	vm.estack.PushVal(elements)
 	vm.Run()
-	assert.Equal(t, false, vm.state.HasFlag(faultState))
+	assert.Equal(t, false, vm.HasFailed())
 	assert.Equal(t, 2, vm.estack.Len())
 	assert.Equal(t, makeStackItem(reselements), vm.estack.Pop().value)
 	assert.Equal(t, makeStackItem(1), vm.estack.Pop().value)
 }
 
+func TestCHECKSIGNoArgs(t *testing.T) {
+	prog := makeProgram(CHECKSIG)
+	vm := load(prog)
+	vm.Run()
+	assert.Equal(t, true, vm.HasFailed())
+}
+
+func TestCHECKSIGOneArg(t *testing.T) {
+	prog := makeProgram(CHECKSIG)
+	pk, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	pbytes := pk.PublicKey().Bytes()
+	vm := load(prog)
+	vm.estack.PushVal(pbytes)
+	vm.Run()
+	assert.Equal(t, true, vm.HasFailed())
+}
+
+func TestCHECKSIGNoSigLoaded(t *testing.T) {
+	prog := makeProgram(CHECKSIG)
+	pk, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := "NEO - An Open Network For Smart Economy"
+	sig, err := pk.Sign([]byte(msg))
+	assert.Nil(t, err)
+	pbytes := pk.PublicKey().Bytes()
+	vm := load(prog)
+	vm.estack.PushVal(sig)
+	vm.estack.PushVal(pbytes)
+	vm.Run()
+	assert.Equal(t, true, vm.HasFailed())
+}
+
+func TestCHECKSIGBadKey(t *testing.T) {
+	prog := makeProgram(CHECKSIG)
+	pk, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig, err := pk.Sign(msg)
+	assert.Nil(t, err)
+	pbytes := pk.PublicKey().Bytes()[:4]
+	vm := load(prog)
+	vm.SetCheckedHash(hash.Sha256(msg).Bytes())
+	vm.estack.PushVal(sig)
+	vm.estack.PushVal(pbytes)
+	vm.Run()
+	assert.Equal(t, true, vm.HasFailed())
+}
+
+func TestCHECKSIGWrongSig(t *testing.T) {
+	prog := makeProgram(CHECKSIG)
+	pk, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig, err := pk.Sign(msg)
+	assert.Nil(t, err)
+	pbytes := pk.PublicKey().Bytes()
+	vm := load(prog)
+	vm.SetCheckedHash(hash.Sha256(msg).Bytes())
+	vm.estack.PushVal(util.ArrayReverse(sig))
+	vm.estack.PushVal(pbytes)
+	vm.Run()
+	assert.Equal(t, false, vm.HasFailed())
+	assert.Equal(t, 1, vm.estack.Len())
+	assert.Equal(t, false, vm.estack.Pop().Bool())
+}
+
+func TestCHECKSIGGood(t *testing.T) {
+	prog := makeProgram(CHECKSIG)
+	pk, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig, err := pk.Sign(msg)
+	assert.Nil(t, err)
+	pbytes := pk.PublicKey().Bytes()
+	vm := load(prog)
+	vm.SetCheckedHash(hash.Sha256(msg).Bytes())
+	vm.estack.PushVal(sig)
+	vm.estack.PushVal(pbytes)
+	vm.Run()
+	assert.Equal(t, false, vm.HasFailed())
+	assert.Equal(t, 1, vm.estack.Len())
+	assert.Equal(t, true, vm.estack.Pop().Bool())
+}
+
+func TestVERIFYGood(t *testing.T) {
+	prog := makeProgram(VERIFY)
+	pk, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig, err := pk.Sign(msg)
+	assert.Nil(t, err)
+	pbytes := pk.PublicKey().Bytes()
+	vm := load(prog)
+	vm.estack.PushVal(msg)
+	vm.estack.PushVal(sig)
+	vm.estack.PushVal(pbytes)
+	vm.Run()
+	assert.Equal(t, false, vm.HasFailed())
+	assert.Equal(t, 1, vm.estack.Len())
+	assert.Equal(t, true, vm.estack.Pop().Bool())
+}
+
+func TestVERIFYBad(t *testing.T) {
+	prog := makeProgram(VERIFY)
+	pk, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig, err := pk.Sign(msg)
+	assert.Nil(t, err)
+	pbytes := pk.PublicKey().Bytes()
+	vm := load(prog)
+	vm.estack.PushVal(util.ArrayReverse(msg))
+	vm.estack.PushVal(sig)
+	vm.estack.PushVal(pbytes)
+	vm.Run()
+	assert.Equal(t, false, vm.HasFailed())
+	assert.Equal(t, 1, vm.estack.Len())
+	assert.Equal(t, false, vm.estack.Pop().Bool())
+}
+
+func TestCHECKMULTISIGNoArgs(t *testing.T) {
+	prog := makeProgram(CHECKMULTISIG)
+	vm := load(prog)
+	vm.Run()
+	assert.Equal(t, true, vm.HasFailed())
+}
+
+func TestCHECKMULTISIGOneArg(t *testing.T) {
+	prog := makeProgram(CHECKMULTISIG)
+	pk, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	vm := load(prog)
+	pbytes := pk.PublicKey().Bytes()
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(pbytes)})
+	vm.Run()
+	assert.Equal(t, true, vm.HasFailed())
+}
+
+func TestCHECKMULTISIGNotEnoughKeys(t *testing.T) {
+	prog := makeProgram(CHECKMULTISIG)
+	pk1, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	pk2, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig1, err := pk1.Sign(msg)
+	assert.Nil(t, err)
+	sig2, err := pk2.Sign(msg)
+	assert.Nil(t, err)
+	pbytes1 := pk1.PublicKey().Bytes()
+	vm := load(prog)
+	vm.SetCheckedHash(hash.Sha256(msg).Bytes())
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(sig1), NewByteArrayItem(sig2)})
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(pbytes1)})
+	vm.Run()
+	assert.Equal(t, true, vm.HasFailed())
+}
+
+func TestCHECKMULTISIGNoHash(t *testing.T) {
+	prog := makeProgram(CHECKMULTISIG)
+	pk1, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	pk2, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig1, err := pk1.Sign(msg)
+	assert.Nil(t, err)
+	sig2, err := pk2.Sign(msg)
+	assert.Nil(t, err)
+	pbytes1 := pk1.PublicKey().Bytes()
+	pbytes2 := pk2.PublicKey().Bytes()
+	vm := load(prog)
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(sig1), NewByteArrayItem(sig2)})
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(pbytes1), NewByteArrayItem(pbytes2)})
+	vm.Run()
+	assert.Equal(t, true, vm.HasFailed())
+}
+
+func TestCHECKMULTISIGBadKey(t *testing.T) {
+	prog := makeProgram(CHECKMULTISIG)
+	pk1, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	pk2, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig1, err := pk1.Sign(msg)
+	assert.Nil(t, err)
+	sig2, err := pk2.Sign(msg)
+	assert.Nil(t, err)
+	pbytes1 := pk1.PublicKey().Bytes()
+	pbytes2 := pk2.PublicKey().Bytes()[:4]
+	vm := load(prog)
+	vm.SetCheckedHash(hash.Sha256(msg).Bytes())
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(sig1), NewByteArrayItem(sig2)})
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(pbytes1), NewByteArrayItem(pbytes2)})
+	vm.Run()
+	assert.Equal(t, true, vm.HasFailed())
+}
+
+func TestCHECKMULTISIGBadSig(t *testing.T) {
+	prog := makeProgram(CHECKMULTISIG)
+	pk1, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	pk2, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig1, err := pk1.Sign(msg)
+	assert.Nil(t, err)
+	sig2, err := pk2.Sign(msg)
+	assert.Nil(t, err)
+	pbytes1 := pk1.PublicKey().Bytes()
+	pbytes2 := pk2.PublicKey().Bytes()
+	vm := load(prog)
+	vm.SetCheckedHash(hash.Sha256(msg).Bytes())
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(util.ArrayReverse(sig1)), NewByteArrayItem(sig2)})
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(pbytes1), NewByteArrayItem(pbytes2)})
+	vm.Run()
+	assert.Equal(t, false, vm.HasFailed())
+	assert.Equal(t, 1, vm.estack.Len())
+	assert.Equal(t, false, vm.estack.Pop().Bool())
+}
+
+func TestCHECKMULTISIGGood(t *testing.T) {
+	prog := makeProgram(CHECKMULTISIG)
+	pk1, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	pk2, err := keys.NewPrivateKey()
+	assert.Nil(t, err)
+	msg := []byte("NEO - An Open Network For Smart Economy")
+	sig1, err := pk1.Sign(msg)
+	assert.Nil(t, err)
+	sig2, err := pk2.Sign(msg)
+	assert.Nil(t, err)
+	pbytes1 := pk1.PublicKey().Bytes()
+	pbytes2 := pk2.PublicKey().Bytes()
+	vm := load(prog)
+	vm.SetCheckedHash(hash.Sha256(msg).Bytes())
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(sig1), NewByteArrayItem(sig2)})
+	vm.estack.PushVal([]StackItem{NewByteArrayItem(pbytes1), NewByteArrayItem(pbytes2)})
+	vm.Run()
+	assert.Equal(t, false, vm.HasFailed())
+	assert.Equal(t, 1, vm.estack.Len())
+	assert.Equal(t, true, vm.estack.Pop().Bool())
+}
+
 func makeProgram(opcodes ...Instruction) []byte {
 	prog := make([]byte, len(opcodes)+1) // RET
 	for i := 0; i < len(opcodes); i++ {