protocol/vm: remove the dependency on protocol/bc

core/generator/generator_test.go

@@ -83,7 +83,7 @@ func TestGetAndAddBlockSignatures(t *testing.T) {
 		testutil.FatalErr(t, err)
 	}
 
-	err = vm.VerifyBlockHeader(&tip.BlockHeader, block)
+	err = vm.Verify(bc.NewBlockVMContext(block, tip.ConsensusProgram, block.Witness))
 	if err != nil {
 		testutil.FatalErr(t, err)
 	}

protocol/bc/tx_test.go

@@ -22,8 +22,8 @@ func TestTxHashes(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		if len(hashes.VMContexts) != len(c.txdata.Inputs) {
-			t.Errorf("case %d: len(hashes.VMContexts) = %d, want %d", i, len(hashes.VMContexts), len(c.txdata.Inputs))
+		if len(hashes.SpentOutputIDs) != len(c.txdata.Inputs) {
+			t.Errorf("case %d: len(hashes.SpentOutputIDs) = %d, want %d", i, len(hashes.SpentOutputIDs), len(c.txdata.Inputs))
 		}
 		if c.hash != hashes.ID {
 			t.Errorf("case %d: got txid %x, want %x", i, hashes.ID[:], c.hash[:])

protocol/bc/txhashes.go

@@ -11,8 +11,8 @@ type (
 			ID           Hash
 			ExpirationMS uint64
 		}
-		SpentOutputIDs []Hash       // one per old-style Input. Non-spend inputs are blank hashes.
-		VMContexts     []*VMContext // one per old-style Input
+		SpentOutputIDs []Hash // one per old-style Input. Non-spend inputs are blank hashes.
+		SigHashes      []Hash // one per old-style Input.
 	}
 
 	// ResultInfo contains information about each result in a transaction header.
@@ -24,17 +24,8 @@ type (
 		SourcePos   uint64 // the position within the source entry of this output's value
 		RefDataHash Hash   // contents of the result entry's data field (which is a hash of the source refdata, when converting from old-style transactions)
 	}
-
-	VMContext struct {
-		TxRefDataHash Hash
-		RefDataHash   Hash
-		TxSigHash     Hash
-		OutputID      *Hash
-		EntryID       Hash
-		NonceID       *Hash
-	}
 )
 
 func (t TxHashes) SigHash(n uint32) Hash {
-	return t.VMContexts[n].TxSigHash
+	return t.SigHashes[n]
 }

protocol/bc/txtransaction.go

@@ -50,8 +50,8 @@ func ComputeTxHashes(oldTx *TxData) (hashes *TxHashes, err error) {
 		}
 	}
 
-	hashes.VMContexts = make([]*VMContext, len(oldTx.Inputs))
 	hashes.SpentOutputIDs = make([]Hash, len(oldTx.Inputs))
+	hashes.SigHashes = make([]Hash, len(oldTx.Inputs))
 
 	for entryID, ent := range entries {
 		switch ent := ent.(type) {
@@ -73,41 +73,22 @@ func ComputeTxHashes(oldTx *TxData) (hashes *TxHashes, err error) {
 			hashes.Issuances = append(hashes.Issuances, iss)
 
 		case *Issuance:
-			vmc := newVMContext(entryID, hashes.ID, header.body.Data, ent.body.Data)
-			vmc.NonceID = &ent.body.Anchor
-			hashes.VMContexts[ent.Ordinal()] = vmc
+			hashes.SigHashes[ent.Ordinal()] = makeSigHash(entryID, hashes.ID)
 
 		case *Spend:
-			vmc := newVMContext(entryID, hashes.ID, header.body.Data, ent.body.Data)
-			vmc.OutputID = &ent.body.SpentOutput
-			hashes.VMContexts[ent.Ordinal()] = vmc
+			hashes.SigHashes[ent.Ordinal()] = makeSigHash(entryID, hashes.ID)
 			hashes.SpentOutputIDs[ent.Ordinal()] = ent.body.SpentOutput
 		}
 	}
 
 	return hashes, nil
 }
 
-// populates the common fields of a VMContext for an Entry, regardless of whether
-// that Entry is a Spend or an Issuance
-func newVMContext(entryID, txid, txData, inpData Hash) *VMContext {
-	vmc := new(VMContext)
-
-	// TxRefDataHash
-	vmc.TxRefDataHash = txData
-
-	// RefDataHash (input-specific)
-	vmc.RefDataHash = inpData
-
-	// EntryID
-	vmc.EntryID = entryID
-
-	// TxSigHash
+func makeSigHash(entryID, txID Hash) (hash Hash) {
 	hasher := sha3pool.Get256()
 	defer sha3pool.Put256(hasher)
 	hasher.Write(entryID[:])
-	hasher.Write(txid[:])
-	hasher.Read(vmc.TxSigHash[:])
-
-	return vmc
+	hasher.Write(txID[:])
+	hasher.Read(hash[:])
+	return hash
 }

protocol/bc/vmcontext.go

@@ -0,0 +1,89 @@
+package bc
+
+import (
+	"bytes"
+
+	"chain/protocol/vm"
+)
+
+func NewBlockVMContext(block *Block, prog []byte, args [][]byte) *vm.Context {
+	blockHash := block.Hash().Bytes()
+	return &vm.Context{
+		VMVersion: 1,
+		Code:      prog,
+		Arguments: args,
+
+		BlockHash:            &blockHash,
+		BlockTimeMS:          &block.TimestampMS,
+		NextConsensusProgram: &block.ConsensusProgram,
+	}
+}
+
+func NewTxVMContext(tx *Tx, index uint32, prog Program, args [][]byte) *vm.Context {
+	var (
+		txSigHash        = tx.SigHash(index).Bytes()
+		numResults       = uint64(len(tx.Results))
+		assetID          = tx.Inputs[index].AssetID()
+		assetIDBytes     = assetID[:]
+		amount           = tx.Inputs[index].Amount()
+		inputRefDataHash = hashData(tx.Inputs[index].ReferenceData).Bytes()
+		txRefDataHash    = hashData(tx.ReferenceData).Bytes()
+	)
+
+	checkOutput := func(index uint64, refdatahash []byte, amount uint64, assetID []byte, vmVersion uint64, code []byte) (bool, error) {
+		if index >= uint64(len(tx.Outputs)) {
+			return false, vm.ErrBadValue
+		}
+		o := tx.Outputs[index]
+		if o.AssetVersion != 1 {
+			return false, nil
+		}
+		if o.Amount != uint64(amount) {
+			return false, nil
+		}
+		if o.VMVersion != uint64(vmVersion) {
+			return false, nil
+		}
+		if !bytes.Equal(o.ControlProgram, code) {
+			return false, nil
+		}
+		if !bytes.Equal(o.AssetID[:], assetID) {
+			return false, nil
+		}
+		if len(refdatahash) > 0 {
+			h := hashData(o.ReferenceData)
+			if !bytes.Equal(h[:], refdatahash) {
+				return false, nil
+			}
+		}
+		return true, nil
+	}
+
+	result := &vm.Context{
+		VMVersion: prog.VMVersion,
+		Code:      prog.Code,
+		Arguments: args,
+
+		TxVersion: &tx.Version,
+
+		TxSigHash:        &txSigHash,
+		NumResults:       &numResults,
+		AssetID:          &assetIDBytes,
+		Amount:           &amount,
+		MinTimeMS:        &tx.MinTime,
+		MaxTimeMS:        &tx.MaxTime,
+		InputRefDataHash: &inputRefDataHash,
+		TxRefDataHash:    &txRefDataHash,
+		InputIndex:       &index,
+		CheckOutput:      checkOutput,
+	}
+	switch inp := tx.Inputs[index].TypedInput.(type) {
+	case *IssuanceInput:
+		result.Nonce = &inp.Nonce
+	case *SpendInput:
+		spentOutputID := tx.TxHashes.SpentOutputIDs[index][:]
+		result.SpentOutputID = &spentOutputID
+	}
+
+	return result
+}

protocol/validation/block.go

@@ -34,7 +34,7 @@ var (
 // then calls ValidateBlock.
 func ValidateBlockForAccept(ctx context.Context, snapshot *state.Snapshot, initialBlockHash bc.Hash, prevBlock, block *bc.Block, validateTx func(*bc.Tx) error) error {
 	if prevBlock != nil {
-		err := vm.VerifyBlockHeader(&prevBlock.BlockHeader, block)
+		err := vm.Verify(bc.NewBlockVMContext(block, prevBlock.ConsensusProgram, block.Witness))
 		if err != nil {
 			pkScriptStr, _ := vm.Disassemble(prevBlock.ConsensusProgram)
 			witnessStrs := make([]string, 0, len(block.Witness))

protocol/validation/tx.go

@@ -249,8 +249,20 @@ func CheckTxWellFormed(tx *bc.Tx) error {
 		}
 	}
 
-	for i := range tx.Inputs {
-		err := vm.VerifyTxInput(tx, uint32(i))
+	for i, inp := range tx.Inputs {
+		var (
+			prog bc.Program
+			args [][]byte
+		)
+		switch inp := inp.TypedInput.(type) {
+		case *bc.IssuanceInput:
+			prog = bc.Program{VMVersion: inp.VMVersion, Code: inp.IssuanceProgram}
+			args = inp.Arguments
+		case *bc.SpendInput:
+			prog = bc.Program{VMVersion: inp.VMVersion, Code: inp.ControlProgram}
+			args = inp.Arguments
+		}
+		err := vm.Verify(bc.NewTxVMContext(tx, uint32(i), prog, args))
 		if err != nil {
 			return badTxErrf(err, "validation failed in script execution, input %d", i)
 		}

protocol/vm/assemble_test.go

@@ -72,3 +72,11 @@ func TestDisassemble(t *testing.T) {
 		}
 	}
 }
+
+func mustDecodeHex(h string) []byte {
+	bits, err := hex.DecodeString(h)
+	if err != nil {
+		panic(err)
+	}
+	return bits
+}

protocol/vm/context.go

@@ -0,0 +1,43 @@
+package vm
+
+// Context contains the execution context for the virtual machine.
+//
+// Most fields are pointers and are not required to be present in all
+// cases. A nil pointer means the value is absent in that context. If
+// an opcode executes that requires an absent field to be present, it
+// will return ErrContext.
+//
+// By convention, variables of this type have the name context, _not_
+// ctx (to avoid confusion with context.Context).
+type Context struct {
+	VMVersion uint64
+	Code      []byte
+	Arguments [][]byte
+
+	// TxVersion must be present when verifying transaction components
+	// (such as spends and issuances).
+	TxVersion *uint64
+
+	// These fields must be present when verifying block headers.
+
+	BlockHash            *[]byte
+	BlockTimeMS          *uint64
+	NextConsensusProgram *[]byte
+
+	// Fields below this point are required by particular opcodes when
+	// verifying transaction components.
+
+	TxSigHash        *[]byte
+	NumResults       *uint64
+	AssetID          *[]byte
+	Amount           *uint64
+	MinTimeMS        *uint64
+	MaxTimeMS        *uint64
+	InputRefDataHash *[]byte
+	TxRefDataHash    *[]byte
+	InputIndex       *uint32
+	Nonce            *[]byte
+	SpentOutputID    *[]byte
+
+	CheckOutput func(index uint64, data []byte, amount uint64, assetID []byte, vmVersion uint64, code []byte) (bool, error)
+}

protocol/vm/control.go

@@ -61,14 +61,11 @@ func opCheckPredicate(vm *virtualMachine) error {
 	}
 
 	childVM := virtualMachine{
-		mainprog:   vm.mainprog,
-		program:    predicate,
-		runLimit:   limit,
-		depth:      vm.depth + 1,
-		dataStack:  append([][]byte{}, vm.dataStack[l-n:]...),
-		tx:         vm.tx,
-		txContext:  vm.txContext,
-		inputIndex: vm.inputIndex,
+		context:   vm.context,
+		program:   predicate,
+		runLimit:  limit,
+		depth:     vm.depth + 1,
+		dataStack: append([][]byte{}, vm.dataStack[l-n:]...),
 	}
 	vm.dataStack = vm.dataStack[:l-n]
 

protocol/vm/crypto.go

@@ -127,25 +127,23 @@ func opCheckMultiSig(vm *virtualMachine) error {
 }
 
 func opTxSigHash(vm *virtualMachine) error {
-	if vm.tx == nil {
-		return ErrContext
-	}
 	err := vm.applyCost(256)
 	if err != nil {
 		return err
 	}
-	h := vm.txContext.TxSigHash
-	return vm.push(h[:], false)
+	if vm.context.TxSigHash == nil {
+		return ErrContext
+	}
+	return vm.push(*vm.context.TxSigHash, false)
 }
 
 func opBlockHash(vm *virtualMachine) error {
-	if vm.block == nil {
-		return ErrContext
-	}
-	h := vm.block.Hash()
-	err := vm.applyCost(4 * int64(len(h)))
+	err := vm.applyCost(1)
 	if err != nil {
 		return err
 	}
-	return vm.push(h[:], false)
+	if vm.context.BlockHash == nil {
+		return ErrContext
+	}
+	return vm.push(*vm.context.BlockHash, false)
 }