forked from TrueCloudLab/neoneo-go
c80ee952a1
add processing of validators while block persist; add validator structure with decoding/encoding; add validator get from store; add EnrollmentTX and StateTX processing; add pubkey decode bytes, unique and contains functions;
758 lines
21 KiB
Go
758 lines
21 KiB
Go
package core
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
|
|
"github.com/CityOfZion/neo-go/pkg/core/transaction"
|
|
"github.com/CityOfZion/neo-go/pkg/crypto/keys"
|
|
"github.com/CityOfZion/neo-go/pkg/smartcontract"
|
|
"github.com/CityOfZion/neo-go/pkg/util"
|
|
"github.com/CityOfZion/neo-go/pkg/vm"
|
|
gherr "github.com/pkg/errors"
|
|
)
|
|
|
|
const (
|
|
// MaxContractScriptSize is the maximum script size for a contract.
|
|
MaxContractScriptSize = 1024 * 1024
|
|
// MaxContractParametersNum is the maximum number of parameters for a contract.
|
|
MaxContractParametersNum = 252
|
|
// MaxContractStringLen is the maximum length for contract metadata strings.
|
|
MaxContractStringLen = 252
|
|
// MaxAssetNameLen is the maximum length of asset name.
|
|
MaxAssetNameLen = 1024
|
|
// MaxAssetPrecision is the maximum precision of asset.
|
|
MaxAssetPrecision = 8
|
|
// BlocksPerYear is a multiplier for asset renewal.
|
|
BlocksPerYear = 2000000
|
|
// DefaultAssetLifetime is the default lifetime of an asset (which differs
|
|
// from assets created by register tx).
|
|
DefaultAssetLifetime = 1 + BlocksPerYear
|
|
)
|
|
|
|
// txInOut is used to pushed one key-value pair from References() onto the stack.
|
|
type txInOut struct {
|
|
in transaction.Input
|
|
out transaction.Output
|
|
}
|
|
|
|
// headerGetVersion returns version from the header.
|
|
func (ic *interopContext) headerGetVersion(v *vm.VM) error {
|
|
header, err := popHeaderFromVM(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(header.Version)
|
|
return nil
|
|
}
|
|
|
|
// headerGetConsensusData returns consensus data from the header.
|
|
func (ic *interopContext) headerGetConsensusData(v *vm.VM) error {
|
|
header, err := popHeaderFromVM(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(header.ConsensusData)
|
|
return nil
|
|
}
|
|
|
|
// headerGetMerkleRoot returns version from the header.
|
|
func (ic *interopContext) headerGetMerkleRoot(v *vm.VM) error {
|
|
header, err := popHeaderFromVM(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(header.MerkleRoot.BytesReverse())
|
|
return nil
|
|
}
|
|
|
|
// headerGetNextConsensus returns version from the header.
|
|
func (ic *interopContext) headerGetNextConsensus(v *vm.VM) error {
|
|
header, err := popHeaderFromVM(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(header.NextConsensus.BytesReverse())
|
|
return nil
|
|
}
|
|
|
|
// txGetAttributes returns current transaction attributes.
|
|
func (ic *interopContext) txGetAttributes(v *vm.VM) error {
|
|
txInterface := v.Estack().Pop().Value()
|
|
tx, ok := txInterface.(*transaction.Transaction)
|
|
if !ok {
|
|
return errors.New("value is not a transaction")
|
|
}
|
|
if len(tx.Attributes) > vm.MaxArraySize {
|
|
return errors.New("too many attributes")
|
|
}
|
|
attrs := make([]vm.StackItem, 0, len(tx.Attributes))
|
|
for _, attr := range tx.Attributes {
|
|
attrs = append(attrs, vm.NewInteropItem(attr))
|
|
}
|
|
v.Estack().PushVal(attrs)
|
|
return nil
|
|
}
|
|
|
|
// txGetInputs returns current transaction inputs.
|
|
func (ic *interopContext) txGetInputs(v *vm.VM) error {
|
|
txInterface := v.Estack().Pop().Value()
|
|
tx, ok := txInterface.(*transaction.Transaction)
|
|
if !ok {
|
|
return errors.New("value is not a transaction")
|
|
}
|
|
if len(tx.Inputs) > vm.MaxArraySize {
|
|
return errors.New("too many inputs")
|
|
}
|
|
inputs := make([]vm.StackItem, 0, len(tx.Inputs))
|
|
for _, input := range tx.Inputs {
|
|
inputs = append(inputs, vm.NewInteropItem(input))
|
|
}
|
|
v.Estack().PushVal(inputs)
|
|
return nil
|
|
}
|
|
|
|
// txGetOutputs returns current transaction outputs.
|
|
func (ic *interopContext) txGetOutputs(v *vm.VM) error {
|
|
txInterface := v.Estack().Pop().Value()
|
|
tx, ok := txInterface.(*transaction.Transaction)
|
|
if !ok {
|
|
return errors.New("value is not a transaction")
|
|
}
|
|
if len(tx.Outputs) > vm.MaxArraySize {
|
|
return errors.New("too many outputs")
|
|
}
|
|
outputs := make([]vm.StackItem, 0, len(tx.Outputs))
|
|
for _, output := range tx.Outputs {
|
|
outputs = append(outputs, vm.NewInteropItem(output))
|
|
}
|
|
v.Estack().PushVal(outputs)
|
|
return nil
|
|
}
|
|
|
|
// txGetReferences returns current transaction references.
|
|
func (ic *interopContext) txGetReferences(v *vm.VM) error {
|
|
txInterface := v.Estack().Pop().Value()
|
|
tx, ok := txInterface.(*transaction.Transaction)
|
|
if !ok {
|
|
return fmt.Errorf("type mismatch: %T is not a Transaction", txInterface)
|
|
}
|
|
refs := ic.bc.References(tx)
|
|
if len(refs) > vm.MaxArraySize {
|
|
return errors.New("too many references")
|
|
}
|
|
|
|
stackrefs := make([]vm.StackItem, 0, len(refs))
|
|
for _, k := range tx.Inputs {
|
|
tio := txInOut{*k, *refs[*k]}
|
|
stackrefs = append(stackrefs, vm.NewInteropItem(tio))
|
|
}
|
|
v.Estack().PushVal(stackrefs)
|
|
return nil
|
|
}
|
|
|
|
// txGetType returns current transaction type.
|
|
func (ic *interopContext) txGetType(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(int(tx.Type))
|
|
return nil
|
|
}
|
|
|
|
// txGetUnspentCoins returns current transaction unspent coins.
|
|
func (ic *interopContext) txGetUnspentCoins(v *vm.VM) error {
|
|
txInterface := v.Estack().Pop().Value()
|
|
tx, ok := txInterface.(*transaction.Transaction)
|
|
if !ok {
|
|
return errors.New("value is not a transaction")
|
|
}
|
|
ucs := ic.bc.GetUnspentCoinState(tx.Hash())
|
|
if ucs == nil {
|
|
return errors.New("no unspent coin state found")
|
|
}
|
|
v.Estack().PushVal(vm.NewInteropItem(ucs))
|
|
return nil
|
|
}
|
|
|
|
// txGetWitnesses returns current transaction witnesses.
|
|
func (ic *interopContext) txGetWitnesses(v *vm.VM) error {
|
|
txInterface := v.Estack().Pop().Value()
|
|
tx, ok := txInterface.(*transaction.Transaction)
|
|
if !ok {
|
|
return errors.New("value is not a transaction")
|
|
}
|
|
if len(tx.Scripts) > vm.MaxArraySize {
|
|
return errors.New("too many outputs")
|
|
}
|
|
scripts := make([]vm.StackItem, 0, len(tx.Scripts))
|
|
for _, script := range tx.Scripts {
|
|
scripts = append(scripts, vm.NewInteropItem(script))
|
|
}
|
|
v.Estack().PushVal(scripts)
|
|
return nil
|
|
}
|
|
|
|
// bcGetValidators returns validators.
|
|
func (ic *interopContext) bcGetValidators(v *vm.VM) error {
|
|
validators, err := ic.bc.GetValidators()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(validators)
|
|
return nil
|
|
}
|
|
|
|
// popInputFromVM returns transaction.Input from the first estack element.
|
|
func popInputFromVM(v *vm.VM) (*transaction.Input, error) {
|
|
inInterface := v.Estack().Pop().Value()
|
|
input, ok := inInterface.(*transaction.Input)
|
|
if !ok {
|
|
txio, ok := inInterface.(txInOut)
|
|
if !ok {
|
|
return nil, fmt.Errorf("type mismatch: %T is not an Input or txInOut", inInterface)
|
|
}
|
|
input = &txio.in
|
|
}
|
|
return input, nil
|
|
}
|
|
|
|
// inputGetHash returns hash from the given input.
|
|
func (ic *interopContext) inputGetHash(v *vm.VM) error {
|
|
input, err := popInputFromVM(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(input.PrevHash.Bytes())
|
|
return nil
|
|
}
|
|
|
|
// inputGetIndex returns index from the given input.
|
|
func (ic *interopContext) inputGetIndex(v *vm.VM) error {
|
|
input, err := popInputFromVM(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(input.PrevIndex)
|
|
return nil
|
|
}
|
|
|
|
// popOutputFromVM returns transaction.Input from the first estack element.
|
|
func popOutputFromVM(v *vm.VM) (*transaction.Output, error) {
|
|
outInterface := v.Estack().Pop().Value()
|
|
output, ok := outInterface.(*transaction.Output)
|
|
if !ok {
|
|
txio, ok := outInterface.(txInOut)
|
|
if !ok {
|
|
return nil, fmt.Errorf("type mismatch: %T is not an Output or txInOut", outInterface)
|
|
}
|
|
output = &txio.out
|
|
}
|
|
return output, nil
|
|
}
|
|
|
|
// outputGetAssetId returns asset ID from the given output.
|
|
func (ic *interopContext) outputGetAssetID(v *vm.VM) error {
|
|
output, err := popOutputFromVM(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(output.AssetID.Bytes())
|
|
return nil
|
|
}
|
|
|
|
// outputGetScriptHash returns scripthash from the given output.
|
|
func (ic *interopContext) outputGetScriptHash(v *vm.VM) error {
|
|
output, err := popOutputFromVM(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(output.ScriptHash.Bytes())
|
|
return nil
|
|
}
|
|
|
|
// outputGetValue returns value (amount) from the given output.
|
|
func (ic *interopContext) outputGetValue(v *vm.VM) error {
|
|
output, err := popOutputFromVM(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.Estack().PushVal(int64(output.Amount))
|
|
return nil
|
|
}
|
|
|
|
// attrGetData returns tx attribute data.
|
|
func (ic *interopContext) attrGetData(v *vm.VM) error {
|
|
attrInterface := v.Estack().Pop().Value()
|
|
attr, ok := attrInterface.(*transaction.Attribute)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an attribute", attr)
|
|
}
|
|
v.Estack().PushVal(attr.Data)
|
|
return nil
|
|
}
|
|
|
|
// attrGetData returns tx attribute usage field.
|
|
func (ic *interopContext) attrGetUsage(v *vm.VM) error {
|
|
attrInterface := v.Estack().Pop().Value()
|
|
attr, ok := attrInterface.(*transaction.Attribute)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an attribute", attr)
|
|
}
|
|
v.Estack().PushVal(int(attr.Usage))
|
|
return nil
|
|
}
|
|
|
|
// bcGetAccount returns or creates an account.
|
|
func (ic *interopContext) bcGetAccount(v *vm.VM) error {
|
|
accbytes := v.Estack().Pop().Bytes()
|
|
acchash, err := util.Uint160DecodeBytes(accbytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
acc := ic.bc.GetAccountState(acchash)
|
|
if acc == nil {
|
|
acc = NewAccountState(acchash)
|
|
}
|
|
v.Estack().PushVal(vm.NewInteropItem(acc))
|
|
return nil
|
|
}
|
|
|
|
// bcGetAsset returns an asset.
|
|
func (ic *interopContext) bcGetAsset(v *vm.VM) error {
|
|
asbytes := v.Estack().Pop().Bytes()
|
|
ashash, err := util.Uint256DecodeBytes(asbytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
as := ic.bc.GetAssetState(ashash)
|
|
if as == nil {
|
|
return errors.New("asset not found")
|
|
}
|
|
v.Estack().PushVal(vm.NewInteropItem(as))
|
|
return nil
|
|
}
|
|
|
|
// accountGetBalance returns balance for a given account.
|
|
func (ic *interopContext) accountGetBalance(v *vm.VM) error {
|
|
accInterface := v.Estack().Pop().Value()
|
|
acc, ok := accInterface.(*AccountState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an account state", acc)
|
|
}
|
|
asbytes := v.Estack().Pop().Bytes()
|
|
ashash, err := util.Uint256DecodeBytes(asbytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
balance, ok := acc.GetBalanceValues()[ashash]
|
|
if !ok {
|
|
balance = util.Fixed8(0)
|
|
}
|
|
v.Estack().PushVal(int64(balance))
|
|
return nil
|
|
}
|
|
|
|
// accountGetScriptHash returns script hash of a given account.
|
|
func (ic *interopContext) accountGetScriptHash(v *vm.VM) error {
|
|
accInterface := v.Estack().Pop().Value()
|
|
acc, ok := accInterface.(*AccountState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an account state", acc)
|
|
}
|
|
v.Estack().PushVal(acc.ScriptHash.Bytes())
|
|
return nil
|
|
}
|
|
|
|
// accountGetVotes returns votes of a given account.
|
|
func (ic *interopContext) accountGetVotes(v *vm.VM) error {
|
|
accInterface := v.Estack().Pop().Value()
|
|
acc, ok := accInterface.(*AccountState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an account state", acc)
|
|
}
|
|
if len(acc.Votes) > vm.MaxArraySize {
|
|
return errors.New("too many votes")
|
|
}
|
|
votes := make([]vm.StackItem, 0, len(acc.Votes))
|
|
for _, key := range acc.Votes {
|
|
votes = append(votes, vm.NewByteArrayItem(key.Bytes()))
|
|
}
|
|
v.Estack().PushVal(votes)
|
|
return nil
|
|
}
|
|
|
|
// accountIsStandard checks whether given account is standard.
|
|
func (ic *interopContext) accountIsStandard(v *vm.VM) error {
|
|
accbytes := v.Estack().Pop().Bytes()
|
|
acchash, err := util.Uint160DecodeBytes(accbytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
contract := ic.bc.GetContractState(acchash)
|
|
res := contract == nil || vm.IsStandardContract(contract.Script)
|
|
v.Estack().PushVal(res)
|
|
return nil
|
|
}
|
|
|
|
/*
|
|
// storageFind finds stored key-value pair.
|
|
func (ic *interopContext) storageFind(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
|
|
}
|
|
prefix := string(v.Estack().Pop().Bytes())
|
|
siMap, err := ic.bc.GetStorageItems(stc.ScriptHash)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for k, v := range siMap {
|
|
if strings.HasPrefix(k, prefix) {
|
|
_ = v
|
|
panic("TODO")
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
*/
|
|
// createContractStateFromVM pops all contract state elements from the VM
|
|
// evaluation stack, does a lot of checks and returns ContractState if it
|
|
// succeeds.
|
|
func (ic *interopContext) createContractStateFromVM(v *vm.VM) (*ContractState, error) {
|
|
if ic.trigger != 0x10 {
|
|
return nil, errors.New("can't create contract when not triggered by an application")
|
|
}
|
|
script := v.Estack().Pop().Bytes()
|
|
if len(script) > MaxContractScriptSize {
|
|
return nil, errors.New("the script is too big")
|
|
}
|
|
paramBytes := v.Estack().Pop().Bytes()
|
|
if len(paramBytes) > MaxContractParametersNum {
|
|
return nil, errors.New("too many parameters for a script")
|
|
}
|
|
paramList := make([]smartcontract.ParamType, len(paramBytes))
|
|
for k, v := range paramBytes {
|
|
paramList[k] = smartcontract.ParamType(v)
|
|
}
|
|
retType := smartcontract.ParamType(v.Estack().Pop().BigInt().Int64())
|
|
properties := smartcontract.PropertyState(v.Estack().Pop().BigInt().Int64())
|
|
name := v.Estack().Pop().Bytes()
|
|
if len(name) > MaxContractStringLen {
|
|
return nil, errors.New("too big name")
|
|
}
|
|
version := v.Estack().Pop().Bytes()
|
|
if len(version) > MaxContractStringLen {
|
|
return nil, errors.New("too big version")
|
|
}
|
|
author := v.Estack().Pop().Bytes()
|
|
if len(author) > MaxContractStringLen {
|
|
return nil, errors.New("too big author")
|
|
}
|
|
email := v.Estack().Pop().Bytes()
|
|
if len(email) > MaxContractStringLen {
|
|
return nil, errors.New("too big email")
|
|
}
|
|
desc := v.Estack().Pop().Bytes()
|
|
if len(desc) > MaxContractStringLen {
|
|
return nil, errors.New("too big description")
|
|
}
|
|
contract := &ContractState{
|
|
Script: script,
|
|
ParamList: paramList,
|
|
ReturnType: retType,
|
|
Properties: properties,
|
|
Name: string(name),
|
|
CodeVersion: string(version),
|
|
Author: string(author),
|
|
Email: string(email),
|
|
Description: string(desc),
|
|
}
|
|
return contract, nil
|
|
}
|
|
|
|
// contractCreate creates a contract.
|
|
func (ic *interopContext) contractCreate(v *vm.VM) error {
|
|
newcontract, err := ic.createContractStateFromVM(v)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
contract := ic.bc.GetContractState(newcontract.ScriptHash())
|
|
if contract == nil {
|
|
contract = newcontract
|
|
err := putContractStateIntoStore(ic.mem, contract)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
v.Estack().PushVal(vm.NewInteropItem(contract))
|
|
return nil
|
|
}
|
|
|
|
// contractGetScript returns a script associated with a contract.
|
|
func (ic *interopContext) contractGetScript(v *vm.VM) error {
|
|
csInterface := v.Estack().Pop().Value()
|
|
cs, ok := csInterface.(*ContractState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not a contract state", cs)
|
|
}
|
|
v.Estack().PushVal(cs.Script)
|
|
return nil
|
|
}
|
|
|
|
// contractIsPayable returns whether contract is payable.
|
|
func (ic *interopContext) contractIsPayable(v *vm.VM) error {
|
|
csInterface := v.Estack().Pop().Value()
|
|
cs, ok := csInterface.(*ContractState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not a contract state", cs)
|
|
}
|
|
v.Estack().PushVal(cs.IsPayable())
|
|
return nil
|
|
}
|
|
|
|
// contractMigrate migrates a contract.
|
|
func (ic *interopContext) contractMigrate(v *vm.VM) error {
|
|
newcontract, err := ic.createContractStateFromVM(v)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
contract := ic.bc.GetContractState(newcontract.ScriptHash())
|
|
if contract == nil {
|
|
contract = newcontract
|
|
err := putContractStateIntoStore(ic.mem, contract)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if contract.HasStorage() {
|
|
hash := getContextScriptHash(v, 0)
|
|
siMap, err := ic.bc.GetStorageItems(hash)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for k, v := range siMap {
|
|
v.IsConst = false
|
|
_ = putStorageItemIntoStore(ic.mem, hash, []byte(k), v)
|
|
}
|
|
}
|
|
}
|
|
v.Estack().PushVal(vm.NewInteropItem(contract))
|
|
return ic.contractDestroy(v)
|
|
}
|
|
|
|
// assetCreate creates an asset.
|
|
func (ic *interopContext) assetCreate(v *vm.VM) error {
|
|
if ic.trigger != 0x10 {
|
|
return errors.New("can't create asset when not triggered by an application")
|
|
}
|
|
atype := transaction.AssetType(v.Estack().Pop().BigInt().Int64())
|
|
switch atype {
|
|
case transaction.Currency, transaction.Share, transaction.Invoice, transaction.Token:
|
|
// ok
|
|
default:
|
|
return fmt.Errorf("wrong asset type: %x", atype)
|
|
}
|
|
name := string(v.Estack().Pop().Bytes())
|
|
if len(name) > MaxAssetNameLen {
|
|
return errors.New("too big name")
|
|
}
|
|
amount := util.Fixed8(v.Estack().Pop().BigInt().Int64())
|
|
if amount == util.Fixed8(0) {
|
|
return errors.New("asset amount can't be zero")
|
|
}
|
|
if amount < -util.Satoshi() {
|
|
return errors.New("asset amount can't be negative (except special -Satoshi value")
|
|
}
|
|
if atype == transaction.Invoice && amount != -util.Satoshi() {
|
|
return errors.New("invoice assets can only have -Satoshi amount")
|
|
}
|
|
precision := byte(v.Estack().Pop().BigInt().Int64())
|
|
if precision > MaxAssetPrecision {
|
|
return fmt.Errorf("can't have asset precision of more than %d", MaxAssetPrecision)
|
|
}
|
|
if atype == transaction.Share && precision != 0 {
|
|
return errors.New("share assets can only have zero precision")
|
|
}
|
|
if amount != -util.Satoshi() && (int64(amount)%int64(math.Pow10(int(MaxAssetPrecision-precision))) != 0) {
|
|
return errors.New("given asset amount has fractional component")
|
|
}
|
|
owner := &keys.PublicKey{}
|
|
err := owner.DecodeBytes(v.Estack().Pop().Bytes())
|
|
if err != nil {
|
|
return gherr.Wrap(err, "failed to get owner key")
|
|
}
|
|
if owner.IsInfinity() {
|
|
return errors.New("can't have infinity as an owner key")
|
|
}
|
|
witnessOk, err := ic.checkKeyedWitness(owner)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !witnessOk {
|
|
return errors.New("witness check didn't succeed")
|
|
}
|
|
admin, err := util.Uint160DecodeBytes(v.Estack().Pop().Bytes())
|
|
if err != nil {
|
|
return gherr.Wrap(err, "failed to get admin")
|
|
}
|
|
issuer, err := util.Uint160DecodeBytes(v.Estack().Pop().Bytes())
|
|
if err != nil {
|
|
return gherr.Wrap(err, "failed to get issuer")
|
|
}
|
|
asset := &AssetState{
|
|
ID: ic.tx.Hash(),
|
|
AssetType: atype,
|
|
Name: name,
|
|
Amount: amount,
|
|
Precision: precision,
|
|
Owner: owner,
|
|
Admin: admin,
|
|
Issuer: issuer,
|
|
Expiration: ic.bc.BlockHeight() + DefaultAssetLifetime,
|
|
}
|
|
err = putAssetStateIntoStore(ic.mem, asset)
|
|
if err != nil {
|
|
return gherr.Wrap(err, "failed to store asset")
|
|
}
|
|
v.Estack().PushVal(vm.NewInteropItem(asset))
|
|
return nil
|
|
}
|
|
|
|
// assetGetAdmin returns asset admin.
|
|
func (ic *interopContext) assetGetAdmin(v *vm.VM) error {
|
|
asInterface := v.Estack().Pop().Value()
|
|
as, ok := asInterface.(*AssetState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an asset state", as)
|
|
}
|
|
v.Estack().PushVal(as.Admin.Bytes())
|
|
return nil
|
|
}
|
|
|
|
// assetGetAmount returns the overall amount of asset available.
|
|
func (ic *interopContext) assetGetAmount(v *vm.VM) error {
|
|
asInterface := v.Estack().Pop().Value()
|
|
as, ok := asInterface.(*AssetState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an asset state", as)
|
|
}
|
|
v.Estack().PushVal(int64(as.Amount))
|
|
return nil
|
|
}
|
|
|
|
// assetGetAssetId returns the id of an asset.
|
|
func (ic *interopContext) assetGetAssetID(v *vm.VM) error {
|
|
asInterface := v.Estack().Pop().Value()
|
|
as, ok := asInterface.(*AssetState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an asset state", as)
|
|
}
|
|
v.Estack().PushVal(as.ID.Bytes())
|
|
return nil
|
|
}
|
|
|
|
// assetGetAssetType returns type of an asset.
|
|
func (ic *interopContext) assetGetAssetType(v *vm.VM) error {
|
|
asInterface := v.Estack().Pop().Value()
|
|
as, ok := asInterface.(*AssetState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an asset state", as)
|
|
}
|
|
v.Estack().PushVal(int(as.AssetType))
|
|
return nil
|
|
}
|
|
|
|
// assetGetAvailable returns available (not yet issued) amount of asset.
|
|
func (ic *interopContext) assetGetAvailable(v *vm.VM) error {
|
|
asInterface := v.Estack().Pop().Value()
|
|
as, ok := asInterface.(*AssetState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an asset state", as)
|
|
}
|
|
v.Estack().PushVal(int(as.Available))
|
|
return nil
|
|
}
|
|
|
|
// assetGetIssuer returns issuer of an asset.
|
|
func (ic *interopContext) assetGetIssuer(v *vm.VM) error {
|
|
asInterface := v.Estack().Pop().Value()
|
|
as, ok := asInterface.(*AssetState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an asset state", as)
|
|
}
|
|
v.Estack().PushVal(as.Issuer.Bytes())
|
|
return nil
|
|
}
|
|
|
|
// assetGetOwner returns owner of an asset.
|
|
func (ic *interopContext) assetGetOwner(v *vm.VM) error {
|
|
asInterface := v.Estack().Pop().Value()
|
|
as, ok := asInterface.(*AssetState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an asset state", as)
|
|
}
|
|
v.Estack().PushVal(as.Owner.Bytes())
|
|
return nil
|
|
}
|
|
|
|
// assetGetPrecision returns precision used to measure this asset.
|
|
func (ic *interopContext) assetGetPrecision(v *vm.VM) error {
|
|
asInterface := v.Estack().Pop().Value()
|
|
as, ok := asInterface.(*AssetState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an asset state", as)
|
|
}
|
|
v.Estack().PushVal(int(as.Precision))
|
|
return nil
|
|
}
|
|
|
|
// assetRenew updates asset expiration date.
|
|
func (ic *interopContext) assetRenew(v *vm.VM) error {
|
|
if ic.trigger != 0x10 {
|
|
return errors.New("can't create asset when not triggered by an application")
|
|
}
|
|
asInterface := v.Estack().Pop().Value()
|
|
as, ok := asInterface.(*AssetState)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not an asset state", as)
|
|
}
|
|
years := byte(v.Estack().Pop().BigInt().Int64())
|
|
// Not sure why C# code regets an asset from the Store, but we also do it.
|
|
asset := ic.bc.GetAssetState(as.ID)
|
|
if asset == nil {
|
|
return errors.New("can't renew non-existent asset")
|
|
}
|
|
if asset.Expiration < ic.bc.BlockHeight()+1 {
|
|
asset.Expiration = ic.bc.BlockHeight() + 1
|
|
}
|
|
expiration := uint64(asset.Expiration) + uint64(years)*BlocksPerYear
|
|
if expiration > math.MaxUint32 {
|
|
expiration = math.MaxUint32
|
|
}
|
|
asset.Expiration = uint32(expiration)
|
|
err := putAssetStateIntoStore(ic.mem, asset)
|
|
if err != nil {
|
|
return gherr.Wrap(err, "failed to store asset")
|
|
}
|
|
v.Estack().PushVal(expiration)
|
|
return nil
|
|
}
|
|
|
|
// runtimeSerialize serializes top stack item into a ByteArray.
|
|
func (ic *interopContext) runtimeSerialize(v *vm.VM) error {
|
|
return vm.RuntimeSerialize(v)
|
|
}
|
|
|
|
// runtimeDeserialize deserializes ByteArray from a stack into an item.
|
|
func (ic *interopContext) runtimeDeserialize(v *vm.VM) error {
|
|
return vm.RuntimeDeserialize(v)
|
|
}
|