neo-go/pkg/core/interop_system.go

package core

import (
	"errors"
	"fmt"
	"math"

	"github.com/CityOfZion/neo-go/pkg/core/block"
	"github.com/CityOfZion/neo-go/pkg/core/state"
	"github.com/CityOfZion/neo-go/pkg/core/transaction"
	"github.com/CityOfZion/neo-go/pkg/crypto/keys"
	"github.com/CityOfZion/neo-go/pkg/smartcontract/trigger"
	"github.com/CityOfZion/neo-go/pkg/util"
	"github.com/CityOfZion/neo-go/pkg/vm"
	gherr "github.com/pkg/errors"
	"go.uber.org/zap"
)

const (
	// MaxStorageKeyLen is the maximum length of a key for storage items.
	MaxStorageKeyLen = 1024
)

// StorageContext contains storing script hash and read/write flag, it's used as
// a context for storage manipulation functions.
type StorageContext struct {
	ScriptHash util.Uint160
	ReadOnly   bool
}

// getBlockHashFromElement converts given vm.Element to block hash using given
// Blockchainer if needed. Interop functions accept both block numbers and
// block hashes as parameters, thus this function is needed.
func getBlockHashFromElement(bc Blockchainer, element *vm.Element) (util.Uint256, error) {
	var hash util.Uint256
	hashbytes := element.Bytes()
	if len(hashbytes) <= 5 {
		hashint := element.BigInt().Int64()
		if hashint < 0 || hashint > math.MaxUint32 {
			return hash, errors.New("bad block index")
		}
		hash = bc.GetHeaderHash(int(hashint))
	} else {
		return util.Uint256DecodeBytesLE(hashbytes)
	}
	return hash, nil
}

// bcGetBlock returns current block.
func (ic *interopContext) bcGetBlock(v *vm.VM) error {
	hash, err := getBlockHashFromElement(ic.bc, v.Estack().Pop())
	if err != nil {
		return err
	}
	block, err := ic.bc.GetBlock(hash)
	if err != nil {
		v.Estack().PushVal([]byte{})
	} else {
		v.Estack().PushVal(vm.NewInteropItem(block))
	}
	return nil
}

// bcGetContract returns contract.
func (ic *interopContext) bcGetContract(v *vm.VM) error {
	hashbytes := v.Estack().Pop().Bytes()
	hash, err := util.Uint160DecodeBytesBE(hashbytes)
	if err != nil {
		return err
	}
	cs, err := ic.dao.GetContractState(hash)
	if err != nil {
		v.Estack().PushVal([]byte{})
	} else {
		v.Estack().PushVal(vm.NewInteropItem(cs))
	}
	return nil
}

// bcGetHeader returns block header.
func (ic *interopContext) bcGetHeader(v *vm.VM) error {
	hash, err := getBlockHashFromElement(ic.bc, v.Estack().Pop())
	if err != nil {
		return err
	}
	header, err := ic.bc.GetHeader(hash)
	if err != nil {
		v.Estack().PushVal([]byte{})
	} else {
		v.Estack().PushVal(vm.NewInteropItem(header))
	}
	return nil
}

// bcGetHeight returns blockchain height.
func (ic *interopContext) bcGetHeight(v *vm.VM) error {
	v.Estack().PushVal(ic.bc.BlockHeight())
	return nil
}

// getTransactionAndHeight gets parameter from the vm evaluation stack and
// returns transaction and its height if it's present in the blockchain.
func getTransactionAndHeight(cd *cachedDao, v *vm.VM) (*transaction.Transaction, uint32, error) {
	hashbytes := v.Estack().Pop().Bytes()
	hash, err := util.Uint256DecodeBytesLE(hashbytes)
	if err != nil {
		return nil, 0, err
	}
	return cd.GetTransaction(hash)
}

// bcGetTransaction returns transaction.
func (ic *interopContext) bcGetTransaction(v *vm.VM) error {
	tx, _, err := getTransactionAndHeight(ic.dao, v)
	if err != nil {
		return err
	}
	v.Estack().PushVal(vm.NewInteropItem(tx))
	return nil
}

// bcGetTransactionHeight returns transaction height.
func (ic *interopContext) bcGetTransactionHeight(v *vm.VM) error {
	_, h, err := getTransactionAndHeight(ic.dao, v)
	if err != nil {
		return err
	}
	v.Estack().PushVal(h)
	return nil
}

// popHeaderFromVM returns pointer to Header or error. It's main feature is
// proper treatment of Block structure, because C# code implicitly assumes
// that header APIs can also operate on blocks.
func popHeaderFromVM(v *vm.VM) (*block.Header, error) {
	iface := v.Estack().Pop().Value()
	header, ok := iface.(*block.Header)
	if !ok {
		block, ok := iface.(*block.Block)
		if !ok {
			return nil, errors.New("value is not a header or block")
		}
		return block.Header(), nil
	}
	return header, nil
}

// headerGetIndex returns block index from the header.
func (ic *interopContext) headerGetIndex(v *vm.VM) error {
	header, err := popHeaderFromVM(v)
	if err != nil {
		return err
	}
	v.Estack().PushVal(header.Index)
	return nil
}

// headerGetHash returns header hash of the passed header.
func (ic *interopContext) headerGetHash(v *vm.VM) error {
	header, err := popHeaderFromVM(v)
	if err != nil {
		return err
	}
	v.Estack().PushVal(header.Hash().BytesLE())
	return nil
}

// headerGetPrevHash returns previous header hash of the passed header.
func (ic *interopContext) headerGetPrevHash(v *vm.VM) error {
	header, err := popHeaderFromVM(v)
	if err != nil {
		return err
	}
	v.Estack().PushVal(header.PrevHash.BytesLE())
	return nil
}

// headerGetTimestamp returns timestamp of the passed header.
func (ic *interopContext) headerGetTimestamp(v *vm.VM) error {
	header, err := popHeaderFromVM(v)
	if err != nil {
		return err
	}
	v.Estack().PushVal(header.Timestamp)
	return nil
}

// blockGetTransactionCount returns transactions count in the given block.
func (ic *interopContext) blockGetTransactionCount(v *vm.VM) error {
	blockInterface := v.Estack().Pop().Value()
	block, ok := blockInterface.(*block.Block)
	if !ok {
		return errors.New("value is not a block")
	}
	v.Estack().PushVal(len(block.Transactions))
	return nil
}

// blockGetTransactions returns transactions from the given block.
func (ic *interopContext) blockGetTransactions(v *vm.VM) error {
	blockInterface := v.Estack().Pop().Value()
	block, ok := blockInterface.(*block.Block)
	if !ok {
		return errors.New("value is not a block")
	}
	if len(block.Transactions) > vm.MaxArraySize {
		return errors.New("too many transactions")
	}
	txes := make([]vm.StackItem, 0, len(block.Transactions))
	for _, tx := range block.Transactions {
		txes = append(txes, vm.NewInteropItem(tx))
	}
	v.Estack().PushVal(txes)
	return nil
}

// blockGetTransaction returns transaction with the given number from the given
// block.
func (ic *interopContext) blockGetTransaction(v *vm.VM) error {
	blockInterface := v.Estack().Pop().Value()
	block, ok := blockInterface.(*block.Block)
	if !ok {
		return errors.New("value is not a block")
	}
	index := v.Estack().Pop().BigInt().Int64()
	if index < 0 || index >= int64(len(block.Transactions)) {
		return errors.New("wrong transaction index")
	}
	tx := block.Transactions[index]
	v.Estack().PushVal(vm.NewInteropItem(tx))
	return nil
}

// txGetHash returns transaction's hash.
func (ic *interopContext) txGetHash(v *vm.VM) error {
	txInterface := v.Estack().Pop().Value()
	tx, ok := txInterface.(*transaction.Transaction)
	if !ok {
		return errors.New("value is not a transaction")
	}
	v.Estack().PushVal(tx.Hash().BytesLE())
	return nil
}

// engineGetScriptContainer returns transaction that contains the script being
// run.
func (ic *interopContext) engineGetScriptContainer(v *vm.VM) error {
	v.Estack().PushVal(vm.NewInteropItem(ic.tx))
	return nil
}

// pushContextScriptHash returns script hash of the invocation stack element
// number n.
func getContextScriptHash(v *vm.VM, n int) util.Uint160 {
	ctxIface := v.Istack().Peek(n).Value()
	ctx := ctxIface.(*vm.Context)
	return ctx.ScriptHash()
}

// pushContextScriptHash pushes to evaluation stack the script hash of the
// invocation stack element number n.
func pushContextScriptHash(v *vm.VM, n int) error {
	h := getContextScriptHash(v, n)
	v.Estack().PushVal(h.BytesBE())
	return nil
}

// engineGetExecutingScriptHash returns executing script hash.
func (ic *interopContext) engineGetExecutingScriptHash(v *vm.VM) error {
	return pushContextScriptHash(v, 0)
}

// engineGetCallingScriptHash returns calling script hash.
func (ic *interopContext) engineGetCallingScriptHash(v *vm.VM) error {
	return pushContextScriptHash(v, 1)
}

// engineGetEntryScriptHash returns entry script hash.
func (ic *interopContext) engineGetEntryScriptHash(v *vm.VM) error {
	return pushContextScriptHash(v, v.Istack().Len()-1)
}

// runtimePlatform returns the name of the platform.
func (ic *interopContext) runtimePlatform(v *vm.VM) error {
	v.Estack().PushVal([]byte("NEO"))
	return nil
}

// runtimeGetTrigger returns the script trigger.
func (ic *interopContext) runtimeGetTrigger(v *vm.VM) error {
	v.Estack().PushVal(ic.trigger)
	return nil
}

// checkHashedWitness checks given hash against current list of script hashes
// for verifying in the interop context.
func (ic *interopContext) checkHashedWitness(hash util.Uint160) (bool, error) {
	hashes, err := ic.bc.GetScriptHashesForVerifying(ic.tx)
	if err != nil {
		return false, gherr.Wrap(err, "failed to get script hashes")
	}
	for _, v := range hashes {
		if hash.Equals(v) {
			return true, nil
		}
	}
	return false, nil
}

// checkKeyedWitness checks hash of signature check contract with a given public
// key against current list of script hashes for verifying in the interop context.
func (ic *interopContext) checkKeyedWitness(key *keys.PublicKey) (bool, error) {
	return ic.checkHashedWitness(key.GetScriptHash())
}

// runtimeCheckWitness checks witnesses.
func (ic *interopContext) runtimeCheckWitness(v *vm.VM) error {
	var res bool
	var err error

	hashOrKey := v.Estack().Pop().Bytes()
	hash, err := util.Uint160DecodeBytesBE(hashOrKey)
	if err != nil {
		key := &keys.PublicKey{}
		err = key.DecodeBytes(hashOrKey)
		if err != nil {
			return errors.New("parameter given is neither a key nor a hash")
		}
		res, err = ic.checkKeyedWitness(key)
	} else {
		res, err = ic.checkHashedWitness(hash)
	}
	if err != nil {
		return gherr.Wrap(err, "failed to check")
	}
	v.Estack().PushVal(res)
	return nil
}

// runtimeNotify should pass stack item to the notify plugin to handle it, but
// in neo-go the only meaningful thing to do here is to log.
func (ic *interopContext) runtimeNotify(v *vm.VM) error {
	// It can be just about anything.
	e := v.Estack().Pop()
	item := e.Item()
	// But it has to be serializable, otherwise we either have some broken
	// (recursive) structure inside or an interop item that can't be used
	// outside of the interop subsystem anyway. I'd probably fail transactions
	// that emit such broken notifications, but that might break compatibility
	// with testnet/mainnet, so we're replacing these with error messages.
	_, err := vm.SerializeItem(item)
	if err != nil {
		item = vm.NewByteArrayItem([]byte(fmt.Sprintf("bad notification: %v", err)))
	}
	ne := state.NotificationEvent{ScriptHash: getContextScriptHash(v, 0), Item: item}
	ic.notifications = append(ic.notifications, ne)
	return nil
}

// runtimeLog logs the message passed.
func (ic *interopContext) runtimeLog(v *vm.VM) error {
	msg := fmt.Sprintf("%q", v.Estack().Pop().Bytes())
	ic.log.Info("runtime log",
		zap.Stringer("script", getContextScriptHash(v, 0)),
		zap.String("logs", msg))
	return nil
}

// runtimeGetTime returns timestamp of the block being verified, or the latest
// one in the blockchain if no block is given to interopContext.
func (ic *interopContext) runtimeGetTime(v *vm.VM) error {
	var header *block.Header
	if ic.block == nil {
		var err error
		header, err = ic.bc.GetHeader(ic.bc.CurrentBlockHash())
		if err != nil {
			return err
		}
	} else {
		header = ic.block.Header()
	}
	v.Estack().PushVal(header.Timestamp)
	return nil
}

/*
// runtimeSerialize serializes given stack item.
func (ic *interopContext) runtimeSerialize(v *vm.VM) error {
	panic("TODO")
}

// runtimeDeserialize deserializes given stack item.
func (ic *interopContext) runtimeDeserialize(v *vm.VM) error {
	panic("TODO")
}
*/
func (ic *interopContext) checkStorageContext(stc *StorageContext) error {
	contract, err := ic.dao.GetContractState(stc.ScriptHash)
	if err != nil {
		return errors.New("no contract found")
	}
	if !contract.HasStorage() {
		return fmt.Errorf("contract %s can't use storage", stc.ScriptHash)
	}
	return nil
}

// storageDelete deletes stored key-value pair.
func (ic *interopContext) storageDelete(v *vm.VM) error {
	if ic.trigger != trigger.Application && ic.trigger != trigger.ApplicationR {
		return errors.New("can't delete when the trigger is not application")
	}
	stcInterface := v.Estack().Pop().Value()
	stc, ok := stcInterface.(*StorageContext)
	if !ok {
		return fmt.Errorf("%T is not a StorageContext", stcInterface)
	}
	if stc.ReadOnly {
		return errors.New("StorageContext is read only")
	}
	err := ic.checkStorageContext(stc)
	if err != nil {
		return err
	}
	key := v.Estack().Pop().Bytes()
	si := ic.dao.GetStorageItem(stc.ScriptHash, key)
	if si != nil && si.IsConst {
		return errors.New("storage item is constant")
	}
	return ic.dao.DeleteStorageItem(stc.ScriptHash, key)
}

// storageGet returns stored key-value pair.
func (ic *interopContext) storageGet(v *vm.VM) error {
	stcInterface := v.Estack().Pop().Value()
	stc, ok := stcInterface.(*StorageContext)
	if !ok {
		return fmt.Errorf("%T is not a StorageContext", stcInterface)
	}
	err := ic.checkStorageContext(stc)
	if err != nil {
		return err
	}
	key := v.Estack().Pop().Bytes()
	si := ic.dao.GetStorageItem(stc.ScriptHash, key)
	if si != nil && si.Value != nil {
		v.Estack().PushVal(si.Value)
	} else {
		v.Estack().PushVal([]byte{})
	}
	return nil
}

// storageGetContext returns storage context (scripthash).
func (ic *interopContext) storageGetContext(v *vm.VM) error {
	sc := &StorageContext{
		ScriptHash: getContextScriptHash(v, 0),
		ReadOnly:   false,
	}
	v.Estack().PushVal(vm.NewInteropItem(sc))
	return nil
}

// storageGetReadOnlyContext returns read-only context (scripthash).
func (ic *interopContext) storageGetReadOnlyContext(v *vm.VM) error {
	sc := &StorageContext{
		ScriptHash: getContextScriptHash(v, 0),
		ReadOnly:   true,
	}
	v.Estack().PushVal(vm.NewInteropItem(sc))
	return nil
}

func (ic *interopContext) putWithContextAndFlags(stc *StorageContext, key []byte, value []byte, isConst bool) error {
	if ic.trigger != trigger.Application && ic.trigger != trigger.ApplicationR {
		return errors.New("can't delete when the trigger is not application")
	}
	if len(key) > MaxStorageKeyLen {
		return errors.New("key is too big")
	}
	if stc.ReadOnly {
		return errors.New("StorageContext is read only")
	}
	err := ic.checkStorageContext(stc)
	if err != nil {
		return err
	}
	si := ic.dao.GetStorageItem(stc.ScriptHash, key)
	if si == nil {
		si = &state.StorageItem{}
	}
	if si.IsConst {
		return errors.New("storage item exists and is read-only")
	}
	si.Value = value
	si.IsConst = isConst
	return ic.dao.PutStorageItem(stc.ScriptHash, key, si)
}

// storagePutInternal is a unified implementation of storagePut and storagePutEx.
func (ic *interopContext) storagePutInternal(v *vm.VM, getFlag bool) error {
	stcInterface := v.Estack().Pop().Value()
	stc, ok := stcInterface.(*StorageContext)
	if !ok {
		return fmt.Errorf("%T is not a StorageContext", stcInterface)
	}
	key := v.Estack().Pop().Bytes()
	value := v.Estack().Pop().Bytes()
	var flag int
	if getFlag {
		flag = int(v.Estack().Pop().BigInt().Int64())
	}
	return ic.putWithContextAndFlags(stc, key, value, flag == 1)
}

// storagePut puts key-value pair into the storage.
func (ic *interopContext) storagePut(v *vm.VM) error {
	return ic.storagePutInternal(v, false)
}

// storagePutEx puts key-value pair with given flags into the storage.
func (ic *interopContext) storagePutEx(v *vm.VM) error {
	return ic.storagePutInternal(v, true)
}

// storageContextAsReadOnly sets given context to read-only mode.
func (ic *interopContext) storageContextAsReadOnly(v *vm.VM) error {
	stcInterface := v.Estack().Pop().Value()
	stc, ok := stcInterface.(*StorageContext)
	if !ok {
		return fmt.Errorf("%T is not a StorageContext", stcInterface)
	}
	if !stc.ReadOnly {
		stx := &StorageContext{
			ScriptHash: stc.ScriptHash,
			ReadOnly:   true,
		}
		stc = stx
	}
	v.Estack().PushVal(vm.NewInteropItem(stc))
	return nil
}

// contractDestroy destroys a contract.
func (ic *interopContext) contractDestroy(v *vm.VM) error {
	if ic.trigger != trigger.Application {
		return errors.New("can't destroy contract when not triggered by application")
	}
	hash := getContextScriptHash(v, 0)
	cs, err := ic.dao.GetContractState(hash)
	if err != nil {
		return nil
	}
	err = ic.dao.DeleteContractState(hash)
	if err != nil {
		return err
	}
	if cs.HasStorage() {
		siMap, err := ic.dao.GetStorageItems(hash)
		if err != nil {
			return err
		}
		for k := range siMap {
			_ = ic.dao.DeleteStorageItem(hash, []byte(k))
		}
	}
	return nil
}

// contractGetStorageContext retrieves StorageContext of a contract.
func (ic *interopContext) contractGetStorageContext(v *vm.VM) error {
	csInterface := v.Estack().Pop().Value()
	cs, ok := csInterface.(*state.Contract)
	if !ok {
		return fmt.Errorf("%T is not a contract state", cs)
	}
	contractState, err := ic.dao.GetContractState(cs.ScriptHash())
	if contractState == nil || err != nil {
		return fmt.Errorf("contract was not created in this transaction")
	}
	stc := &StorageContext{
		ScriptHash: cs.ScriptHash(),
	}
	v.Estack().PushVal(vm.NewInteropItem(stc))
	return nil
}