vm

Documentation

Index

• Constants
• Variables
• type ArgumentsParser
• type BaseOperationCost
• type BlockchainHook
• type BuiltInCost
• type ContextHandler
• type EconomicsHandler
• type EpochNotifier
• type GasCost
• type MessageSignVerifier
• type MetaChainSystemSCsCost
• type NodesConfigProvider
• type SystemEI
• type SystemSCContainer
• type SystemSCContainerFactory
• type SystemSmartContract

Constants

const (
	// InsufficientGasLimit defined constant for return message
	InsufficientGasLimit = "insufficient gas limit"
	// StakeNotEnabled defined constant for return message
	StakeNotEnabled = "stake is not enabled"
	// UnBondNotEnabled defined constant for return message
	UnBondNotEnabled = "unBond is not enabled"
	// UnStakeNotEnabled defined constant for return message
	UnStakeNotEnabled = "unStake is not enabled"
	// TransactionValueMustBeZero defined constant for return message
	TransactionValueMustBeZero = "transaction value must be zero"
	// CannotGetOrCreateRegistrationData defined constant for return message
	CannotGetOrCreateRegistrationData = "cannot get or create registration data: error - "
	// CannotGetAllBlsKeysFromRegistrationData defined constant for return message
	CannotGetAllBlsKeysFromRegistrationData = "could not get all blsKeys from registration data: error - "
)

Variables

var DelegationManagerSCAddress = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 255, 255}

DelegationManagerSCAddress is the hard-coded address for the delegation manager smart contract

var ESDTSCAddress = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 255, 255}

ESDTSCAddress is the hard-coded address for esdt issuing smart contract

var EndOfEpochAddress = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}

EndOfEpochAddress is the hard-coded address which can call system smart contract functions at end of epoch

var ErrBLSPublicKeyAlreadyJailed = errors.New("bls public key already jailed")

ErrBLSPublicKeyAlreadyJailed signals that bls public key was already jailed

var ErrBLSPublicKeyMismatch = errors.New("public key mismatch")

ErrBLSPublicKeyMismatch signals that public keys do not match

var ErrBLSPublicKeyMissmatch = errors.New("public key missmatch")

ErrBLSPublicKeyMissmatch signals that public keys do not match

var ErrCallValueMustBeZero = errors.New("call value must be zero")

ErrCallValueMustBeZero signals that call value must be zero

var ErrCouldNotCreateNewTokenIdentifier = errors.New("token identifier could not be created")

ErrCouldNotCreateNewTokenIdentifier signals that token identifier could not be created

var ErrDataNotFoundUnderKey = errors.New("data was not found under requested key")

ErrDataNotFoundUnderKey signals that data was not found under requested key

var ErrDuplicatesFoundInArguments = errors.New("duplicates found in arguments")

ErrDuplicatesFoundInArguments signals that duplicates were found in arguments

var ErrElementNotFound = errors.New("element was not found")

ErrElementNotFound signals that element was not found

var ErrEmptyStorage = errors.New("storage is nil for given key")

ErrEmptyStorage signals that the storage is empty for given key

var ErrIncorrectConfig = errors.New("config incorrect")

ErrIncorrectConfig signals that the config is incorrect

var ErrInputArgsIsNil = errors.New("input system smart contract arguments are nil")

ErrInputArgsIsNil signals that input arguments are nil for system smart contract

var ErrInputCallValueIsNil = errors.New("input value for system smart contract is nil")

ErrInputCallValueIsNil signals that input call value is nil for system smart contract

var ErrInputCallerAddrIsNil = errors.New("input called address for system smart contract is nil")

ErrInputCallerAddrIsNil signals that input caller address is nil for system smart contract

var ErrInputFunctionIsNil = errors.New("input function for system smart contract is nil")

ErrInputFunctionIsNil signals that input function is nil for system smart contract

var ErrInputRecipientAddrIsNil = errors.New("input recipient address for system smart contract is nil")

ErrInputRecipientAddrIsNil signals that input recipient address for system smart contract is nil

var ErrInvalidAddress = errors.New("invalid address")

ErrInvalidAddress signals that invalid address has been provided

var ErrInvalidArgument = errors.New("invalid argument")

ErrInvalidArgument signals that invalid argument has been provided

var ErrInvalidBLSKeys = errors.New("invalid bls keys")

ErrInvalidBLSKeys signals that invalid bls keys has been provided

var ErrInvalidBaseIssuingCost = errors.New("invalid base issuing cost")

ErrInvalidBaseIssuingCost signals that invalid base issuing cost has been provided

var ErrInvalidCaller = errors.New("the function was called by a not authorized user")

ErrInvalidCaller signals that the functions was called by a not authorized user

var ErrInvalidDelegationSCConfig = errors.New("invalid delegation sc config")

ErrInvalidDelegationSCConfig signals that invalid delegation sc config has been provided

var ErrInvalidEndOfEpochAccessAddress = errors.New("invalid end of epoch access address")

ErrInvalidEndOfEpochAccessAddress signals that end of epoch access address is invalid

var ErrInvalidGenesisTotalSupply = errors.New("invalid genesis total supply cost")

ErrInvalidGenesisTotalSupply signals that provided genesis total supply is invalid

var ErrInvalidJailAccessAddress = errors.New("invalid jailing access address")

ErrInvalidJailAccessAddress signals that invalid jailing access address was provided

var ErrInvalidMaxNumberOfNodes = errors.New("invalid number of max number of nodes")

ErrInvalidMaxNumberOfNodes signals that invalid number of max number of nodes has been provided

var ErrInvalidMinCreationDeposit = errors.New("invalid min creation deposit")

ErrInvalidMinCreationDeposit signals that invalid min creation deposit has been provided

var ErrInvalidMinStakeValue = errors.New("invalid min stake value")

ErrInvalidMinStakeValue signals that an invalid min stake value was provided

var ErrInvalidMinStepValue = errors.New("invalid min step value")

ErrInvalidMinStepValue signals that an invalid min step value was provided

var ErrInvalidMinUnstakeTokensValue = errors.New("invalid min unstake tokens value")

ErrInvalidMinUnstakeTokensValue signals that an invalid min unstake tokens value was provided

var ErrInvalidNodePrice = errors.New("invalid node price")

ErrInvalidNodePrice signals that an invalid node price was provided

var ErrInvalidNumOfArguments = errors.New("invalid number of arguments")

ErrInvalidNumOfArguments signals that invalid number of arguments has been provided

var ErrInvalidNumberOfDecimals = errors.New("invalid number of decimals")

ErrInvalidNumberOfDecimals signals that an invalid number of decimals has been provided

var ErrInvalidStakingAccessAddress = errors.New("invalid staking access address")

ErrInvalidStakingAccessAddress signals that invalid staking access address was provided

var ErrInvalidStartEndVoteNonce = errors.New("invalid start/end vote nonce")

ErrInvalidStartEndVoteNonce signals that invalid arguments where passed for start or end vote nonce

var ErrInvalidUnJailCost = errors.New("invalid unjail cost")

ErrInvalidUnJailCost signals that provided unjail cost is invalid

var ErrInvalidWaitingList = errors.New("invalid waiting list")

ErrInvalidWaitingList signals that waiting list is invalid

var ErrKeyAlreadyRegistered = errors.New("bls key already registered")

ErrKeyAlreadyRegistered signals that bls key is already registered

var ErrNegativeBleedPercentagePerRound = errors.New("negative bleed percentage per round")

ErrNegativeBleedPercentagePerRound signals that negative bleed percentage per round has been provided

var ErrNegativeInitialStakeValue = errors.New("initial stake value is negative")

ErrNegativeInitialStakeValue signals that a negative initial stake value was provided

var ErrNegativeMaximumPercentageToBleed = errors.New("negative maximum percentage to bleed")

ErrNegativeMaximumPercentageToBleed signals that negative maximum percentage to bleed has been provided

var ErrNegativeOrZeroInitialSupply = errors.New("negative initial supply was provided")

ErrNegativeOrZeroInitialSupply signals that negative initial supply has been provided

var ErrNegativeWaitingNodesPercentage = errors.New("negative waiting nodes percentage")

ErrNegativeWaitingNodesPercentage signals that negative waiting nodes percentage was provided

var ErrNilAddressPubKeyConverter = errors.New("nil address public key converter")

ErrNilAddressPubKeyConverter signals that the provided public key converter is nil

var ErrNilArgumentsParser = errors.New("nil arguments parser")

ErrNilArgumentsParser signals that arguments parses is nil

var ErrNilBlockchainHook = errors.New("blockchain hook is nil")

ErrNilBlockchainHook signals that blockchain hook is nil

var ErrNilChanceComputer = errors.New("nil chance computer")

ErrNilChanceComputer signals that nil chance computer has been provided

var ErrNilCryptoHook = errors.New("crypto hook is nil")

ErrNilCryptoHook signals that crypto hook is nil

var ErrNilEconomicsData = errors.New("nil economics data")

ErrNilEconomicsData signals that nil economics data has been provided

var ErrNilEpochNotifier = errors.New("nil EpochNotifier")

ErrNilEpochNotifier signals that the provided EpochNotifier is nil

var ErrNilGasSchedule = errors.New("nil gas schedule")

ErrNilGasSchedule signals that nil gas schedule has been provided

var ErrNilHasher = errors.New("nil Hasher")

ErrNilHasher signals that an operation has been attempted to or with a nil hasher implementation

var ErrNilKeyGenerator = errors.New("nil key generator")

ErrNilKeyGenerator signals that key generator is nil

var ErrNilMarshalizer = errors.New("nil Marshalizer")

ErrNilMarshalizer signals that an operation has been attempted to or with a nil Marshalizer implementation

var ErrNilMessageSignVerifier = errors.New("nil message sign verifier")

ErrNilMessageSignVerifier signals that message sign verifier is nil

var ErrNilNodesConfigProvider = errors.New("nil nodes config provider")

ErrNilNodesConfigProvider signals that an operation has been attempted to or with a nil nodes config provider

var ErrNilOrEmptyKey = errors.New("nil or empty key")

ErrNilOrEmptyKey signals that key is nil or empty

var ErrNilPublicKey = errors.New("nil public key")

ErrNilPublicKey signals that nil public key has been provided

var ErrNilSingleSigner = errors.New("nil single signer")

ErrNilSingleSigner signals that the single signer is nil

var ErrNilStakingSmartContractAddress = errors.New("nil staking smart contract address")

ErrNilStakingSmartContractAddress signals that staking smart contract address is nil

var ErrNilSystemContractsContainer = errors.New("system contract container is nil")

ErrNilSystemContractsContainer signals that the provided system contract container is nil

var ErrNilSystemEnvironmentInterface = errors.New("system environment interface is nil")

ErrNilSystemEnvironmentInterface signals that a nil system environment interface was provided

var ErrNilSystemSCConfig = errors.New("nil system sc config")

ErrNilSystemSCConfig signals that nil system sc config was provided

var ErrNilVMType = errors.New("vm type is nil")

ErrNilVMType signals that the provided vm type is nil

var ErrNilValidatorAccountsDB = errors.New("nil validator accounts DB")

ErrNilValidatorAccountsDB signals that nil validator accounts DB was provided

var ErrNilValidatorSmartContractAddress = errors.New("nil validator smart contract address")

ErrNilValidatorSmartContractAddress signals that validator smart contract address is nil

var ErrNoTickerWithGivenName = errors.New("no ticker with given name")

ErrNoTickerWithGivenName signals that ticker does not exists with given name

var ErrNotEnoughArgumentsToStake = errors.New("not enough arguments to stake")

ErrNotEnoughArgumentsToStake signals that the arguments provided are not enough

var ErrNotEnoughGas = errors.New("not enough gas")

ErrNotEnoughGas signals that there is not enough gas for execution

var ErrNotEnoughInitialOwnerFunds = errors.New("not enough initial owner funds")

ErrNotEnoughInitialOwnerFunds signals that not enough initial owner funds has been provided

var ErrOnExecutionAtStakingSC = errors.New("execution error at staking sc")

ErrOnExecutionAtStakingSC signals that there was an error at staking sc call

var ErrOwnerCannotUnDelegate = errors.New("owner cannot undelegate, contract still active")

ErrOwnerCannotUnDelegate signals that owner cannot undelegate as contract is still active

var ErrTickerNameNotValid = errors.New("ticker name is not valid")

ErrTickerNameNotValid signals that ticker name is not valid

var ErrTokenNameNotHumanReadable = errors.New("token name is not human readable")

ErrTokenNameNotHumanReadable signals that token name is not human readable

var ErrUnknownSystemSmartContract = errors.New("missing system smart contract on selected address")

ErrUnknownSystemSmartContract signals that there is no system smart contract on the provided address

var ErrVotedForAProposalThatNotBeginsYet = errors.New("voted for a proposal that not begins yet")

ErrVotedForAProposalThatNotBeginsYet signals that voting was done for a proposal that not begins yet

var ErrVotedForAnExpiredProposal = errors.New("voted for an expired proposal")

ErrVotedForAnExpiredProposal signals that voting was done for an expired proposal

var FirstDelegationSCAddress = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 255, 255, 255}

FirstDelegationSCAddress is the hard-coded address for the first delegation contract, the other will follow

var GovernanceSCAddress = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 255, 255}

GovernanceSCAddress is the hard-coded address for governance smart contract

var JailingAddress = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}

JailingAddress is the hard-coded address which can call jail function

var StakingSCAddress = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255}

StakingSCAddress is the hard-coded address for smart contracts

var ValidatorSCAddress = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 255, 255}

ValidatorSCAddress is the hard-coded address for validator smart contract

Types

type ArgumentsParser

type ArgumentsParser interface {
	ParseData(data string) (string, [][]byte, error)
	IsInterfaceNil() bool
}

ArgumentsParser defines the functionality to parse transaction data into arguments and code for smart contracts

type BaseOperationCost

type BaseOperationCost struct {
	StorePerByte      uint64
	ReleasePerByte    uint64
	DataCopyPerByte   uint64
	PersistPerByte    uint64
	CompilePerByte    uint64
	AoTPreparePerByte uint64
	GetCode           uint64
}

BaseOperationCost defines cost for base operation cost

type BlockchainHook

type BlockchainHook interface {
	GetStorageData(accountAddress []byte, index []byte) ([]byte, error)
	CurrentNonce() uint64
	CurrentRound() uint64
	CurrentEpoch() uint32
	GetUserAccount(address []byte) (vmcommon.UserAccountHandler, error)
	GetCode(account vmcommon.UserAccountHandler) []byte
	GetShardOfAddress(address []byte) uint32
	IsSmartContract(address []byte) bool
	IsPayable(address []byte) (bool, error)
	NumberOfShards() uint32
	CurrentRandomSeed() []byte
}

BlockchainHook is the interface for VM blockchain callbacks

type BuiltInCost

type BuiltInCost struct {
	ChangeOwnerAddress    uint64
	ClaimDeveloperRewards uint64
	SaveUserName          uint64
	SaveKeyValue          uint64
	ESDTTransfer          uint64
	ESDTBurn              uint64
}

BuiltInCost defines cost for built-in methods

type ContextHandler

type ContextHandler interface {
	SystemEI

	GetContract(address []byte) (SystemSmartContract, error)
	SetSystemSCContainer(scContainer SystemSCContainer) error
	CreateVMOutput() *vmcommon.VMOutput
	CleanCache()
	SetSCAddress(addr []byte)
	AddCode(addr []byte, code []byte)
	AddTxValueToSmartContract(value *big.Int, scAddress []byte)
	SetGasProvided(gasProvided uint64)
}

ContextHandler defines the methods needed to execute system smart contracts

type EconomicsHandler

type EconomicsHandler interface {
	GenesisTotalSupply() *big.Int
	IsInterfaceNil() bool
}

EconomicsHandler defines the methods to get data from the economics component

type EpochNotifier

type EpochNotifier interface {
	RegisterNotifyHandler(handler core.EpochSubscriberHandler)
	CurrentEpoch() uint32
	CheckEpoch(epoch uint32)
	IsInterfaceNil() bool
}

EpochNotifier can notify upon an epoch change and provide the current epoch

type GasCost

type GasCost struct {
	BaseOperationCost      BaseOperationCost
	MetaChainSystemSCsCost MetaChainSystemSCsCost
	BuiltInCost            BuiltInCost
}

GasCost holds all the needed gas costs for system smart contracts

type MessageSignVerifier

type MessageSignVerifier interface {
	Verify(message []byte, signedMessage []byte, pubKey []byte) error
	IsInterfaceNil() bool
}

MessageSignVerifier is used to verify if message was signed with given public key

type MetaChainSystemSCsCost

type MetaChainSystemSCsCost struct {
	Stake               uint64
	UnStake             uint64
	UnBond              uint64
	Claim               uint64
	Get                 uint64
	ChangeRewardAddress uint64
	ChangeValidatorKeys uint64
	UnJail              uint64
	ESDTIssue           uint64
	ESDTOperations      uint64
	Proposal            uint64
	Vote                uint64
	DelegateVote        uint64
	RevokeVote          uint64
	CloseProposal       uint64
	DelegationOps       uint64
	UnStakeTokens       uint64
	UnBondTokens        uint64
	DelegationMgrOps    uint64
	GetAllNodeStates    uint64
}

MetaChainSystemSCsCost defines the cost of system staking SCs methods

type NodesConfigProvider

type NodesConfigProvider interface {
	MinNumberOfNodes() uint32
	MinNumberOfNodesWithHysteresis() uint32
	IsInterfaceNil() bool
}

NodesConfigProvider defines the functionality which is needed for nodes config in system smart contracts

type SystemEI

type SystemEI interface {
	ExecuteOnDestContext(destination []byte, sender []byte, value *big.Int, input []byte) (*vmcommon.VMOutput, error)
	DeploySystemSC(baseContract []byte, newAddress []byte, ownerAddress []byte, value *big.Int, input [][]byte) (vmcommon.ReturnCode, error)
	Transfer(destination []byte, sender []byte, value *big.Int, input []byte, gasLimit uint64) error
	SendGlobalSettingToAll(sender []byte, input []byte)
	GetBalance(addr []byte) *big.Int
	SetStorage(key []byte, value []byte)
	SetStorageForAddress(address []byte, key []byte, value []byte)
	AddReturnMessage(msg string)
	GetStorage(key []byte) []byte
	GetStorageFromAddress(address []byte, key []byte) []byte
	Finish(value []byte)
	UseGas(gasToConsume uint64) error
	GasLeft() uint64
	BlockChainHook() BlockchainHook
	CryptoHook() vmcommon.CryptoHook
	IsValidator(blsKey []byte) bool
	StatusFromValidatorStatistics(blsKey []byte) string
	CanUnJail(blsKey []byte) bool
	IsBadRating(blsKey []byte) bool

	IsInterfaceNil() bool
}

SystemEI defines the environment interface system smart contract can use

type SystemSCContainer

type SystemSCContainer interface {
	Get(key []byte) (SystemSmartContract, error)
	Add(key []byte, val SystemSmartContract) error
	Replace(key []byte, val SystemSmartContract) error
	Remove(key []byte)
	Len() int
	Keys() [][]byte
	IsInterfaceNil() bool
}

SystemSCContainer defines a system smart contract holder data type with basic functionality

type SystemSCContainerFactory

type SystemSCContainerFactory interface {
	CreateForGenesis() (SystemSCContainer, error)
	Create() (SystemSCContainer, error)
	IsInterfaceNil() bool
}

SystemSCContainerFactory defines the functionality to create a system smart contract container

type SystemSmartContract

type SystemSmartContract interface {
	Execute(args *vmcommon.ContractCallInput) vmcommon.ReturnCode
	CanUseContract() bool
	SetNewGasCost(gasCost GasCost)
	IsInterfaceNil() bool
}

SystemSmartContract interface defines the function a system smart contract should have