process

package
v1.0.50 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 4, 2019 License: GPL-3.0 Imports: 25 Imported by: 0

Documentation

Index

Constants

View Source
const MaxHeaderRequestsAllowed = 10

MaxHeaderRequestsAllowed defines the maximum number of missing cross-shard headers (gaps) which could be requested in one round, when node processes a received block

View Source
const MaxHeadersToRequestInAdvance = 10

MaxHeadersToRequestInAdvance defines the maximum number of headers which will be requested in advance, if they are missing

View Source
const MaxItemsInBlock = 15000

MaxItemsInBlock defines the maximum threshold which could be set, and represents the maximum number of items (hashes of: mini blocks, txs, meta-headers, shard-headers) which could be added in one block

View Source
const MaxNoncesWithoutCrossNotarized = 100

MaxNoncesWithoutCrossNotarized defines the maximum nonces to wait for a new block to be cross notarized, before a special action to be applied

View Source
const MaxOccupancyPercentageAllowed = float64(0.9)

MaxOccupancyPercentageAllowed defines the maximum occupancy percentage allowed to be used, from the full pool capacity, for the received data which are not needed in the near future

View Source
const MaxRequestsWithTimeoutAllowed = 5

MaxRequestsWithTimeoutAllowed defines the maximum allowed number of requests with timeout, before a special action to be applied

View Source
const MaxRoundsWithoutCommittedBlock = 20

MaxRoundsWithoutCommittedBlock defines the maximum rounds to wait for a new block to be committed, before a special action to be applied

View Source
const MetaBlockFinality = 1

MetaBlockFinality defines the block finality which is used in meta-chain

View Source
const MinForkRound = uint64(0)

MinForkRound represents the minimum fork round set by a notarized header received

View Source
const MinItemsInBlock = 15000

MinItemsInBlock defines the minimum threshold which could be set, and represents the maximum number of items (hashes of: mini blocks, txs, meta-headers, shard-headers) which could be added in one block

View Source
const NonceDifferenceWhenSynced = 0

NonceDifferenceWhenSynced defines the difference between probable highest nonce seen from network and node's last committed block nonce, after which, node is considered himself not synced

View Source
const RoundModulusTrigger = 10

RoundModulusTrigger defines a round modulus on which a trigger for an action will be released

View Source
const ShardBlockFinality = 1

ShardBlockFinality defines the block finality which is used in shards (the real finality in shards is given by meta-chain)

Variables

View Source
var ErrAccountStateDirty = errors.New("accountState was dirty before starting to change")

ErrAccountStateDirty signals that the accounts were modified before starting the current modification

View Source
var ErrBlockHashDoesNotMatch = errors.New("block hash does not match")

ErrBlockHashDoesNotMatch signals that header hash does not match with the previous one

View Source
var ErrBlockProposerSignatureMissing = errors.New("block proposer signature is missing")

ErrBlockProposerSignatureMissing signals that block proposer signature is missing from the block aggregated sig

View Source
var ErrContainerKeyAlreadyExists = errors.New("provided key already exists in container")

ErrContainerKeyAlreadyExists signals that an element was already set in the container's map

View Source
var ErrCrossShardMBWithoutConfirmationFromMeta = errors.New("cross shard miniblock with destination current shard is not confirmed by metachain")

ErrCrossShardMBWithoutConfirmationFromMeta signals that miniblock was not yet notarized by metachain

View Source
var ErrEmptyFunctionName = errors.New("empty function name")

ErrEmptyFunctionName signals that an empty function name has been provided

View Source
var ErrEmptyTxDataPool = errors.New("empty transaction data pool")

ErrEmptyTxDataPool signals that a empty transaction pool has been provided

View Source
var ErrHeaderBodyMismatch = errors.New("body cannot be validated from header data")

ErrHeaderBodyMismatch signals that the header does not attest all data from the block

View Source
var ErrHeaderIsBlackListed = errors.New("header is black listed")

ErrHeaderIsBlackListed signals that the header provided is black listed

View Source
var ErrHeaderNotFinal = errors.New("header in metablock is not final")

ErrHeaderNotFinal signals that header is not final and it should be

View Source
var ErrHigherGasLimitRequiredInTx = errors.New("higher gas limit required in tx")

ErrHigherGasLimitRequiredInTx signals that a higher gas limit was required in tx

View Source
var ErrHigherNonceInTransaction = errors.New("higher nonce in transaction")

ErrHigherNonceInTransaction signals the nonce in transaction is higher than the account's nonce

View Source
var ErrInsufficientFunds = errors.New("insufficient funds")

ErrInsufficientFunds signals the funds are insufficient

View Source
var ErrInsufficientGasLimitInTx = errors.New("insufficient gas limit in tx")

ErrInsufficientGasLimitInTx signals that a lower gas limit than required was provided

View Source
var ErrInsufficientGasPriceInTx = errors.New("insufficient gas price in tx")

ErrInsufficientGasPriceInTx signals that a lower gas price than required was provided

View Source
var ErrInvalidContainerKey = errors.New("element does not exist in container")

ErrInvalidContainerKey signals that an element does not exist in the container's map

View Source
var ErrInvalidDataInput = errors.New("data input is invalid to create key, value storage output")

ErrInvalidDataInput signals that the data input is invalid for parsing

View Source
var ErrInvalidInitialNodesState = errors.New("provided initial state is invalid")

ErrInvalidInitialNodesState signals that the initial nodes state is invalid

View Source
var ErrInvalidMaxGasLimitPerBlock = errors.New("invalid max gas limit per block")

ErrInvalidMaxGasLimitPerBlock signals that an invalid max gas limit per block has been read from config file

View Source
var ErrInvalidMetaHeader = errors.New("invalid header provided, expected MetaBlock")

ErrInvalidMetaHeader signals that a wrong implementation of HeaderHandler was provided

View Source
var ErrInvalidMetaPoolHolder = errors.New("invalid meta pool holder")

ErrInvalidMetaPoolHolder signals that a required shard data information is missing

View Source
var ErrInvalidMinimumGasLimitForTx = errors.New("invalid minimum gas limit for transactions")

ErrInvalidMinimumGasLimitForTx signals that an invalid minimum gas limit for transactions has been read from config file

View Source
var ErrInvalidMinimumGasPrice = errors.New("invalid minimum gas price")

ErrInvalidMinimumGasPrice signals that an invalid gas price has been read from config file

View Source
var ErrInvalidNonceRequest = errors.New("invalid nonce request")

ErrInvalidNonceRequest signals that invalid nonce was requested

View Source
var ErrInvalidPeerAccount = errors.New("invalid peer account")

ErrInvalidPeerAccount signals that a peer account is invalid

View Source
var ErrInvalidRcvAddr = errors.New("invalid receiver address")

ErrInvalidRcvAddr signals that an operation has been attempted to or with an invalid receiver address

View Source
var ErrInvalidRewardsPercentages = errors.New("invalid rewards percentages")

ErrInvalidRewardsPercentages signals that rewards percentages are not correct

View Source
var ErrInvalidRewardsValue = errors.New("invalid rewards value")

ErrInvalidRewardsValue signals that an invalid rewards value has been read from config file

View Source
var ErrInvalidShardId = errors.New("invalid shard id")

ErrInvalidShardId signals that the shard id is invalid

View Source
var ErrInvalidSndAddr = errors.New("invalid sender address")

ErrInvalidSndAddr signals that an operation has been attempted to or with an invalid sender address

View Source
var ErrInvalidTxInPool = errors.New("invalid transaction in the transactions pool")

ErrInvalidTxInPool signals an invalid transaction in the transactions pool

View Source
var ErrInvalidUnboundPeriod = errors.New("invalid unbound period")

ErrInvalidUnboundPeriod signals that an invalid unbound period has been read from config file

View Source
var ErrLenMismatch = errors.New("lengths mismatch")

ErrLenMismatch signals that 2 or more slices have different lengths

View Source
var ErrLowerNonceInTransaction = errors.New("lower nonce in transaction")

ErrLowerNonceInTransaction signals the nonce in transaction is lower than the account's nonce

View Source
var ErrLowerRoundInBlock = errors.New("header round is lower than last committed")

ErrLowerRoundInBlock signals that a header round is too low for processing it

View Source
var ErrMarshalWithoutSuccess = errors.New("marshal without success")

ErrMarshalWithoutSuccess signals that marshal some data was not done with success

View Source
var ErrMaxGasLimitPerBlockInSelfShardIsReached = errors.New("max gas limit per block in self shard is reached")

ErrMaxGasLimitPerBlockInSelfShardIsReached signals that max gas limit per block in self shard has been reached

View Source
var ErrMaxGasLimitPerMiniBlockInReceiverShardIsReached = errors.New("max gas limit per mini block in receiver shard is reached")

ErrMaxGasLimitPerMiniBlockInReceiverShardIsReached signals that max gas limit per mini block in receiver shard has been reached

View Source
var ErrMaxGasLimitPerMiniBlockInSenderShardIsReached = errors.New("max gas limit per mini block in sender shard is reached")

ErrMaxGasLimitPerMiniBlockInSenderShardIsReached signals that max gas limit per mini block in sender shard has been reached

View Source
var ErrMiniBlockHashMismatch = errors.New("miniblocks does not match")

ErrMiniBlockHashMismatch signals that miniblock hashes does not match

View Source
var ErrMiniblockNotForCurrentShard = errors.New("miniblock is not addressed for current shard")

ErrMiniblockNotForCurrentShard signals that the current processing miniblock must not be processed on the current shard

View Source
var ErrMintAddressNotInThisShard = errors.New("mint address does not belong to current shard")

ErrMintAddressNotInThisShard signals that the mint address does not belong to current shard

View Source
var ErrMissingBody = errors.New("missing body")

ErrMissingBody signals that body of the block is missing

View Source
var ErrMissingHashForHeaderNonce = errors.New("missing hash for header nonce")

ErrMissingHashForHeaderNonce signals that hash of the block is missing

View Source
var ErrMissingHeader = errors.New("missing header")

ErrMissingHeader signals that header of the block is missing

View Source
var ErrMissingPreProcessor = errors.New("pre processor is missing")

ErrMissingPreProcessor signals that required pre processor is missing

View Source
var ErrMissingPrevShardData = errors.New("shard data is missing")

ErrMissingPrevShardData signals that a required shard data information is missing

View Source
var ErrMissingShardDataInStorage = errors.New("missing shard data in storage")

ErrMissingShardDataInStorage signals that some ShardData information is missing from storage

View Source
var ErrMissingTransaction = errors.New("missing transaction")

ErrMissingTransaction signals that one transaction is missing

View Source
var ErrNegativeValue = errors.New("negative value")

ErrNegativeValue signals that a negative value has been detected and it is not allowed

View Source
var ErrNilAccountsAdapter = errors.New("nil AccountsAdapter")

ErrNilAccountsAdapter defines the error when trying to use a nil AccountsAddapter

View Source
var ErrNilAddressContainer = errors.New("nil AddressContainer")

ErrNilAddressContainer signals that an operation has been attempted to or with a nil AddressContainer implementation

View Source
var ErrNilAddressConverter = errors.New("nil AddressConverter")

ErrNilAddressConverter signals that an operation has been attempted to or with a nil AddressConverter implementation

View Source
var ErrNilAppStatusHandler = errors.New("nil AppStatusHandler")

ErrNilAppStatusHandler defines the error for setting a nil AppStatusHandler

View Source
var ErrNilArgumentParser = errors.New("argument parser is nil")

ErrNilArgumentParser signals that the argument parser is nil

View Source
var ErrNilArguments = errors.New("smart contract arguments are nil")

ErrNilArguments signals that arguments from transactions data is nil

View Source
var ErrNilBlackListHandler = errors.New("nil black list handler")

ErrNilBlackListHandler signals that a nil black list handler was provided

View Source
var ErrNilBlockBody = errors.New("nil block body")

ErrNilBlockBody signals that an operation has been attempted to or with a nil block body

View Source
var ErrNilBlockChain = errors.New("nil block chain")

ErrNilBlockChain signals that an operation has been attempted to or with a nil blockchain

View Source
var ErrNilBlockChainHook = errors.New("nil blockchain hook")

ErrNilBlockChainHook signals that nil blockchain hook has been provided

View Source
var ErrNilBlockExecutor = errors.New("nil BlockExecutor")

ErrNilBlockExecutor signals that an operation has been attempted to or with a nil BlockExecutor implementation

View Source
var ErrNilBlockHeader = errors.New("nil block header")

ErrNilBlockHeader signals that an operation has been attempted to or with a nil block header

View Source
var ErrNilBuffer = errors.New("provided byte buffer is nil")

ErrNilBuffer signals that a provided byte buffer is nil

View Source
var ErrNilCacher = errors.New("nil cacher")

ErrNilCacher signals that a nil cache has been provided

View Source
var ErrNilCode = errors.New("smart contract code is nil")

ErrNilCode signals that code from transaction data is nil

View Source
var ErrNilContainerElement = errors.New("element cannot be nil")

ErrNilContainerElement signals when trying to add a nil element in the container

View Source
var ErrNilDataPoolHolder = errors.New("nil data pool holder")

ErrNilDataPoolHolder signals that the data pool holder is nil

View Source
var ErrNilDataToProcess = errors.New("nil data to process")

ErrNilDataToProcess signals that nil data was provided

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

ErrNilEconomicsData signals that nil economics data has been provided

View Source
var ErrNilEconomicsFeeHandler = errors.New("nil economics fee handler")

ErrNilEconomicsFeeHandler signals that fee handler is nil

View Source
var ErrNilEconomicsRewardsHandler = errors.New("nil economics rewards handler")

ErrNilEconomicsRewardsHandler signals that rewards handler is nil

View Source
var ErrNilForkDetector = errors.New("nil fork detector")

ErrNilForkDetector signals that the fork detector is nil

View Source
var ErrNilFunction = errors.New("smart contract function is nil")

ErrNilFunction signals that function from transaction data is nil

View Source
var ErrNilGasHandler = errors.New("nil gas handler")

ErrNilGasHandler signals that gas handler is nil

View Source
var ErrNilGasSchedule = errors.New("nil GasSchedule")

ErrNilGasSchedule signals that an operation has been attempted with a nil gas schedule

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

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

View Source
var ErrNilHaveTimeHandler = errors.New("nil have time handler")

ErrNilHaveTimeHandler signals that a nil have time handler func was provided

View Source
var ErrNilHdrValidator = errors.New("nil header validator")

ErrNilHdrValidator signals that a nil header validator has been provided

View Source
var ErrNilHeadersDataPool = errors.New("nil headers data pool")

ErrNilHeadersDataPool signals that a nil headers pool has been provided

View Source
var ErrNilHeadersNonceHashStorage = errors.New("nil headers nonce hash storage")

ErrNilHeadersNonceHashStorage signals that a nil header nonce hash storage has been provided

View Source
var ErrNilHeadersNoncesDataPool = errors.New("nil headers nonces cache")

ErrNilHeadersNoncesDataPool signals that a nil header - nonce cache

View Source
var ErrNilHeadersStorage = errors.New("nil headers storage")

ErrNilHeadersStorage signals that a nil header storage has been provided

View Source
var ErrNilInterceptedDataFactory = errors.New("nil intercepted data factory")

ErrNilInterceptedDataFactory signals that a nil intercepted data factory was provided

View Source
var ErrNilInterceptedDataProcessor = errors.New("nil intercepted data processor")

ErrNilInterceptedDataProcessor signals that a nil intercepted data processor was provided

View Source
var ErrNilInterceptorThrottler = errors.New("nil interceptor throttler")

ErrNilInterceptorThrottler signals that a nil interceptor throttler was provided

View Source
var ErrNilIntermediateProcessorContainer = errors.New("intermediate processor container is nil")

ErrNilIntermediateProcessorContainer signals that intermediate processors container is nil

View Source
var ErrNilIntermediateTransactionHandler = errors.New("intermediate transaction handler is nil")

ErrNilIntermediateTransactionHandler signals that nil intermediate transaction handler was provided

View Source
var ErrNilInternalTransactionProducer = errors.New("nil internal transaction producere")

ErrNilInternalTransactionProducer signals that a nil system transactions producer was provided

View Source
var ErrNilKeyGen = errors.New("nil key generator")

ErrNilKeyGen signals that an operation has been attempted to or with a nil single sign key generator

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

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

View Source
var ErrNilMediator = errors.New("nil mediator")

ErrNilMediator signals that a mediator implementation is needed, but it is nil

View Source
var ErrNilMessage = errors.New("nil message")

ErrNilMessage signals that a nil message has been received

View Source
var ErrNilMessenger = errors.New("nil Messenger")

ErrNilMessenger signals that a nil Messenger object was provided

View Source
var ErrNilMetaBlockHeader = errors.New("nil metablock header")

ErrNilMetaBlockHeader signals that an operation has been attempted to or with a nil metablock

View Source
var ErrNilMetaBlocksPool = errors.New("nil meta blocks pool")

ErrNilMetaBlocksPool signals that a nil meta blocks pool was used

View Source
var ErrNilMetaHeadersNoncesDataPool = errors.New("nil meta headers nonces cache")

ErrNilMetaHeadersNoncesDataPool signals a nil metachain header - nonce cache

View Source
var ErrNilMiniBlockPool = errors.New("nil mini block pool")

ErrNilMiniBlockPool signals that a nil mini blocks pool was used

View Source
var ErrNilMiniBlocks = errors.New("nil mini blocks")

ErrNilMiniBlocks signals that an operation has been attempted with a nil mini-block

View Source
var ErrNilMiniBlocksCompacter = errors.New("nil mini blocks compacter")

ErrNilMiniBlocksCompacter signals that a nil mini blocks compacter has been provided

View Source
var ErrNilMultiSigVerifier = errors.New("nil multi-signature verifier")

ErrNilMultiSigVerifier signals that a nil multi-signature verifier is used

View Source
var ErrNilNetworkWatcher = errors.New("nil network watcher")

ErrNilNetworkWatcher signals that a nil network watcher has been provided

View Source
var ErrNilNodesCoordinator = errors.New("nil nodes coordinator")

ErrNilNodesCoordinator signals that an operation has been attempted to or with a nil nodes coordinator

View Source
var ErrNilNodesSetup = errors.New("nil nodes setup")

ErrNilNodesSetup signals that nil nodes setup has been provided

View Source
var ErrNilPeerAccountsAdapter = errors.New("nil peer accounts database")

ErrNilPeerAccountsAdapter signals that a nil peer accounts database was provided

View Source
var ErrNilPeerChangesHandler = errors.New("nil peer changes handler")

ErrNilPeerChangesHandler signals that nil peer changes handler has been provided

View Source
var ErrNilPoolsHolder = errors.New("nil pools holder")

ErrNilPoolsHolder signals that an operation has been attempted to or with a nil pools holder object

View Source
var ErrNilPreProcessorsContainer = errors.New("preprocessors container is nil")

ErrNilPreProcessorsContainer signals that preprocessors container is nil

View Source
var ErrNilPrevRandSeed = errors.New("provided previous rand seed is nil")

ErrNilPrevRandSeed signals that a nil previous rand seed has been provided

View Source
var ErrNilPreviousBlockHash = errors.New("nil previous block header hash")

ErrNilPreviousBlockHash signals that a operation has been attempted with a nil previous block header hash

View Source
var ErrNilPubKeysBitmap = errors.New("nil public keys bitmap")

ErrNilPubKeysBitmap signals that a operation has been attempted with a nil public keys bitmap

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

ErrNilPublicKey signals that a operation has been attempted with a nil public key

View Source
var ErrNilRandSeed = errors.New("provided rand seed is nil")

ErrNilRandSeed signals that a nil rand seed has been provided

View Source
var ErrNilRcvAddr = errors.New("nil receiver address")

ErrNilRcvAddr signals that an operation has been attempted to or with a nil receiver address

View Source
var ErrNilRequestHandler = errors.New("nil request handler")

ErrNilRequestHandler signals that a nil request handler interface was provided

View Source
var ErrNilRequestHeaderHandlerByNonce = errors.New("nil request header handler by nonce")

ErrNilRequestHeaderHandlerByNonce signals that a nil header request handler by nonce func was provided

View Source
var ErrNilResolverContainer = errors.New("nil resolver container")

ErrNilResolverContainer signals that a nil resolver container was provided

View Source
var ErrNilRewardTransaction = errors.New("reward transaction is nil")

ErrNilRewardTransaction signals that the reward transaction is nil

View Source
var ErrNilRewardTxDataPool = errors.New("reward transactions pool is nil")

ErrNilRewardTxDataPool signals that the reward transactions pool is nil

View Source
var ErrNilRewardsTxProcessor = errors.New("nil rewards transaction processor")

ErrNilRewardsTxProcessor signals that the rewards transaction processor is nil

View Source
var ErrNilRootHash = errors.New("root hash is nil")

ErrNilRootHash signals that an operation has been attempted with a nil root hash

View Source
var ErrNilRounder = errors.New("nil Rounder")

ErrNilRounder signals that an operation has been attempted to or with a nil Rounder implementation

View Source
var ErrNilSCDataGetter = errors.New("nil sc data getter")

ErrNilSCDataGetter signals that a nil sc data getter has been provided

View Source
var ErrNilSCDestAccount = errors.New("nil destination SC account")

ErrNilSCDestAccount signals that destination account is nil

View Source
var ErrNilSCToProtocol = errors.New("nil sc to protocol")

ErrNilSCToProtocol signals that nil smart contract to protocol handler has been provided

View Source
var ErrNilScAddress = errors.New("nil SC address")

ErrNilScAddress signals that a nil smart contract address has been provided

View Source
var ErrNilShardBlockPool = errors.New("nil shard block pool")

ErrNilShardBlockPool signals that a nil shard blocks pool was used

View Source
var ErrNilShardCoordinator = errors.New("nil shard coordinator")

ErrNilShardCoordinator signals that an operation has been attempted to or with a nil shard coordinator

View Source
var ErrNilShardedDataCacherNotifier = errors.New("nil sharded data cacher notifier")

ErrNilShardedDataCacherNotifier signals that a nil sharded data cacher notifier has been provided

View Source
var ErrNilSignature = errors.New("nil signature")

ErrNilSignature signals that a operation has been attempted with a nil signature

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

ErrNilSingleSigner signals that a nil single signer is used

View Source
var ErrNilSmartContractProcessor = errors.New("smart contract processor is nil")

ErrNilSmartContractProcessor signals that smart contract call executor is nil

View Source
var ErrNilSmartContractResult = errors.New("smart contract result is nil")

ErrNilSmartContractResult signals that the smart contract result is nil

View Source
var ErrNilSmartContractResultProcessor = errors.New("nil smart contract result processor")

ErrNilSmartContractResultProcessor signals that smart contract result processor is nil

View Source
var ErrNilSndAddr = errors.New("nil sender address")

ErrNilSndAddr signals that an operation has been attempted to or with a nil sender address

View Source
var ErrNilSpecialAddressHandler = errors.New("nil special address handler")

ErrNilSpecialAddressHandler signals that special address handler is nil

View Source
var ErrNilStorage = errors.New("nil storage")

ErrNilStorage signals that a nil storage has been provided

View Source
var ErrNilStore = errors.New("nil data storage service")

ErrNilStore signals that the provided storage service is nil

View Source
var ErrNilTemporaryAccountsHandler = errors.New("temporary accounts handler is nil")

ErrNilTemporaryAccountsHandler signals that temporary accounts handler is nil

View Source
var ErrNilTransaction = errors.New("nil transaction")

ErrNilTransaction signals that an operation has been attempted to or with a nil transaction

View Source
var ErrNilTransactionCoordinator = errors.New("transaction coordinator is nil")

ErrNilTransactionCoordinator signals that transaction coordinator is nil

View Source
var ErrNilTransactionPool = errors.New("nil transaction pool")

ErrNilTransactionPool signals that a nil transaction pool was used

View Source
var ErrNilTxBlockBody = errors.New("nil tx block body")

ErrNilTxBlockBody signals that an operation has been attempted to or with a nil tx block body

View Source
var ErrNilTxDataPool = errors.New("nil transaction data pool")

ErrNilTxDataPool signals that a nil transaction pool has been provided

View Source
var ErrNilTxForCurrentBlockHandler = errors.New("nil tx for current block handler")

ErrNilTxForCurrentBlockHandler signals that nil tx for current block handler has been provided

View Source
var ErrNilTxHash = errors.New("nil transaction hash")

ErrNilTxHash signals that an operation has been attempted with a nil hash

View Source
var ErrNilTxHashes = errors.New("nil transaction hashes")

ErrNilTxHashes signals that an operation has been atempted with nil transaction hashes

View Source
var ErrNilTxProcessor = errors.New("nil transactions processor")

ErrNilTxProcessor signals that a nil transactions processor was used

View Source
var ErrNilTxStorage = errors.New("nil transaction storage")

ErrNilTxStorage signals that a nil transaction storage has been provided

View Source
var ErrNilTxTypeHandler = errors.New("nil tx type handler")

ErrNilTxTypeHandler signals that tx type handler is nil

View Source
var ErrNilTxValidator = errors.New("nil transaction validator")

ErrNilTxValidator signals that a nil tx validator has been provided

View Source
var ErrNilTxsPoolsCleaner = errors.New("nil transactions pools cleaner")

ErrNilTxsPoolsCleaner signals that a nil transactions pools cleaner has been provided

View Source
var ErrNilUTxDataPool = errors.New("unsigned transactions pool is nil")

ErrNilUTxDataPool signals that unsigned transaction pool is nil

View Source
var ErrNilUTxStorage = errors.New("unsigned transactions storage is nil")

ErrNilUTxStorage signals that unsigned transaction storage is nil

View Source
var ErrNilUint64Converter = errors.New("unit64converter is nil")

ErrNilUint64Converter signals that uint64converter is nil

View Source
var ErrNilUint64SyncMapCacher = errors.New("nil Uint64SyncMapCacher")

ErrNilUint64SyncMapCacher signals that a nil Uint64SyncMapCache has been provided

View Source
var ErrNilUnsignedTxHandler = errors.New("nil unsigned tx handler")

ErrNilUnsignedTxHandler signals that the unsigned tx handler is nil

View Source
var ErrNilVMOutput = errors.New("nil vm output")

ErrNilVMOutput signals that vmoutput is nil

View Source
var ErrNilValue = errors.New("nil value")

ErrNilValue signals the value is nil

View Source
var ErrNilValueFromRewardTransaction = errors.New("transferred value is nil in reward transaction")

ErrNilValueFromRewardTransaction signals that the transfered value is nil

View Source
var ErrNoDataInMessage = errors.New("no data found in received message")

ErrNoDataInMessage signals that no data was found after parsing received p2p message

View Source
var ErrNoVM = errors.New("no VM (hook not set)")

ErrNoVM signals that no SCHandler has been set

View Source
var ErrNotEnoughArgumentsToDeploy = errors.New("not enough arguments to deploy the smart contract")

ErrNotEnoughArgumentsToDeploy signals that there are not enough arguments to deploy the smart contract

View Source
var ErrNotEnoughGas = errors.New("not enough gas was sent in the transaction")

ErrNotEnoughGas signals that not enough gas has been provided

View Source
var ErrNotEnoughValidBlocksInStorage = errors.New("not enough valid blocks to start from storage")

ErrNotEnoughValidBlocksInStorage signals that bootstrap from storage failed due to not enough valid blocks stored

View Source
var ErrNotarizedHdrsSliceIsNil = errors.New("notarized shard headers slice is nil")

ErrNotarizedHdrsSliceIsNil signals that the slice holding last notarized headers is nil

View Source
var ErrOverallBalanceChangeFromSC = errors.New("SC output balance updates are wrong")

ErrOverallBalanceChangeFromSC signals that all sumed balance changes are not zero

View Source
var ErrPeerChangesHashDoesNotMatch = errors.New("peer changes hash does not match")

ErrPeerChangesHashDoesNotMatch signals that peer changes from header does not match the created ones

View Source
var ErrRandSeedDoesNotMatch = errors.New("random seed do not match")

ErrRandSeedDoesNotMatch signals that random seed does not match with the previous one

View Source
var ErrRewardTransactionNotFound = errors.New("reward transaction not found")

ErrRewardTransactionNotFound is raised when reward transaction should be present but was not found

View Source
var ErrRewardTxNotFound = errors.New("reward transaction not found")

ErrRewardTxNotFound signals that the reward transaction was not found

View Source
var ErrRewardTxsDoNotMatch = errors.New("calculated reward tx with block reward tx does not match")

ErrRewardTxsDoNotMatch signals that reward txs do not match

View Source
var ErrRewardTxsMismatchCreatedReceived = errors.New("mismatch between created and received reward transactions")

ErrRewardTxsMismatchCreatedReceived signals a mismatch between the nb of created and received reward transactions

View Source
var ErrRootStateDoesNotMatch = errors.New("root state does not match")

ErrRootStateDoesNotMatch signals that root state does not match

View Source
var ErrSCDeployFromSCRIsNotPermitted = errors.New("it is not permitted to deploy a smart contract from another smart contract cross shard")

ErrSCDeployFromSCRIsNotPermitted signals that operation is not permitted

View Source
var ErrShardIdMissmatch = errors.New("shard ID missmatch")

ErrShardIdMissmatch signals shard ID does not match expectations

View Source
var ErrStringSplitFailed = errors.New("data splitting into arguments and code/function failed")

ErrStringSplitFailed signals that data splitting into arguments and code failed

View Source
var ErrSystemBusy = errors.New("system busy")

ErrSystemBusy signals that the system is busy

View Source
var ErrTimeIsOut = errors.New("time is out")

ErrTimeIsOut signals that time is out

View Source
var ErrTxNotFound = errors.New("transaction not found")

ErrTxNotFound signals that a transaction has not found

View Source
var ErrUnknownBlockType = errors.New("block type is unknown")

ErrUnknownBlockType signals that block type is not correct

View Source
var ErrUnmarshalWithoutSuccess = errors.New("unmarshal without success")

ErrUnmarshalWithoutSuccess signals that unmarshal some data was not done with success

View Source
var ErrVMTypeLengthInvalid = errors.New("vm type length is too long")

ErrVMTypeLengthInvalid signals that vm type length is too long

View Source
var ErrValidatorStatsRootHashDoesNotMatch = errors.New("root hash for validator statistics does not match")

ErrValidatorStatsRootHashDoesNotMatch signals that the root hash for the validator statistics does not match

View Source
var ErrWrongNonceInBlock = errors.New("wrong nonce in block")

ErrWrongNonceInBlock signals the nonce in block is different than expected nonce

View Source
var ErrWrongNonceInVMOutput = errors.New("nonce invalid from SC run")

ErrWrongNonceInVMOutput signals that nonce in vm output is wrong

View Source
var ErrWrongTransaction = errors.New("invalid transaction")

ErrWrongTransaction signals that transaction is invalid

View Source
var ErrWrongTypeAssertion = errors.New("wrong type assertion")

ErrWrongTypeAssertion signals that an type assertion failed

View Source
var ErrWrongTypeInContainer = errors.New("wrong type of object inside container")

ErrWrongTypeInContainer signals that a wrong type of object was found in container

View Source
var ErrWrongTypeInMiniBlock = errors.New("type in miniblock is not correct for processing")

ErrWrongTypeInMiniBlock signals that type is not correct for processing

View Source
var ErrZeroMaxCleanTime = errors.New("cleaning time is equal or less than zero")

ErrZeroMaxCleanTime signals that cleaning time for pools is less or equal with 0

Functions

func AddHeaderToBlackList

func AddHeaderToBlackList(blackListHandler BlackListHandler, hash []byte)

AddHeaderToBlackList adds a hash to black list handler. Logs if the operation did not succeed

func ConvertProcessedMiniBlocksMapToSlice added in v1.0.41

func ConvertProcessedMiniBlocksMapToSlice(processedMiniBlocks map[string]map[string]struct{}) []bootstrapStorage.MiniBlocksInMeta

ConvertProcessedMiniBlocksMapToSlice will convert a map[string]map[string]struct{} in a slice of MiniBlocksInMeta

func ConvertSliceToProcessedMiniBlocksMap added in v1.0.41

func ConvertSliceToProcessedMiniBlocksMap(miniBlocksInMetaBlocks []bootstrapStorage.MiniBlocksInMeta) map[string]map[string]struct{}

ConvertSliceToProcessedMiniBlocksMap will convert a slice of MiniBlocksInMeta in an map[string]map[string]struct{}

func EmptyChannel

func EmptyChannel(ch chan bool) int

EmptyChannel empties the given channel

func GetHeaderFromStorageWithNonce

func GetHeaderFromStorageWithNonce(
	nonce uint64,
	shardId uint32,
	storageService dataRetriever.StorageService,
	uint64Converter typeConverters.Uint64ByteSliceConverter,
	marshalizer marshal.Marshalizer,
) (data.HeaderHandler, []byte, error)

GetHeaderFromStorageWithNonce method returns a block header from storage with a given nonce and shardId

func GetMarshalizedHeaderFromStorage

func GetMarshalizedHeaderFromStorage(
	blockUnit dataRetriever.UnitType,
	hash []byte,
	marshalizer marshal.Marshalizer,
	storageService dataRetriever.StorageService,
) ([]byte, error)

GetMarshalizedHeaderFromStorage gets the marshalized header, which is associated with the given hash, from storage

func GetMetaHeader

func GetMetaHeader(
	hash []byte,
	cacher storage.Cacher,
	marshalizer marshal.Marshalizer,
	storageService dataRetriever.StorageService,
) (*block.MetaBlock, error)

GetMetaHeader gets the header, which is associated with the given hash, from pool or storage

func GetMetaHeaderFromPool

func GetMetaHeaderFromPool(
	hash []byte,
	cacher storage.Cacher,
) (*block.MetaBlock, error)

GetMetaHeaderFromPool gets the header, which is associated with the given hash, from pool

func GetMetaHeaderFromPoolWithNonce

func GetMetaHeaderFromPoolWithNonce(
	nonce uint64,
	cacher storage.Cacher,
	uint64SyncMapCacher dataRetriever.Uint64SyncMapCacher,
) (*block.MetaBlock, []byte, error)

GetMetaHeaderFromPoolWithNonce method returns a meta block header from pool with a given nonce

func GetMetaHeaderFromStorage

func GetMetaHeaderFromStorage(
	hash []byte,
	marshalizer marshal.Marshalizer,
	storageService dataRetriever.StorageService,
) (*block.MetaBlock, error)

GetMetaHeaderFromStorage gets the header, which is associated with the given hash, from storage

func GetMetaHeaderFromStorageWithNonce

func GetMetaHeaderFromStorageWithNonce(
	nonce uint64,
	storageService dataRetriever.StorageService,
	uint64Converter typeConverters.Uint64ByteSliceConverter,
	marshalizer marshal.Marshalizer,
) (*block.MetaBlock, []byte, error)

GetMetaHeaderFromStorageWithNonce method returns a meta block header from storage with a given nonce

func GetMetaHeaderWithNonce

func GetMetaHeaderWithNonce(
	nonce uint64,
	cacher storage.Cacher,
	uint64SyncMapCacher dataRetriever.Uint64SyncMapCacher,
	marshalizer marshal.Marshalizer,
	storageService dataRetriever.StorageService,
	uint64Converter typeConverters.Uint64ByteSliceConverter,
) (*block.MetaBlock, []byte, error)

GetMetaHeaderWithNonce method returns a meta block header with a given nonce

func GetShardHeader

func GetShardHeader(
	hash []byte,
	cacher storage.Cacher,
	marshalizer marshal.Marshalizer,
	storageService dataRetriever.StorageService,
) (*block.Header, error)

GetShardHeader gets the header, which is associated with the given hash, from pool or storage

func GetShardHeaderFromPool

func GetShardHeaderFromPool(
	hash []byte,
	cacher storage.Cacher,
) (*block.Header, error)

GetShardHeaderFromPool gets the header, which is associated with the given hash, from pool

func GetShardHeaderFromPoolWithNonce

func GetShardHeaderFromPoolWithNonce(
	nonce uint64,
	shardId uint32,
	cacher storage.Cacher,
	uint64SyncMapCacher dataRetriever.Uint64SyncMapCacher,
) (*block.Header, []byte, error)

GetShardHeaderFromPoolWithNonce method returns a shard block header from pool with a given nonce and shardId

func GetShardHeaderFromStorage

func GetShardHeaderFromStorage(
	hash []byte,
	marshalizer marshal.Marshalizer,
	storageService dataRetriever.StorageService,
) (*block.Header, error)

GetShardHeaderFromStorage gets the header, which is associated with the given hash, from storage

func GetShardHeaderFromStorageWithNonce

func GetShardHeaderFromStorageWithNonce(
	nonce uint64,
	shardId uint32,
	storageService dataRetriever.StorageService,
	uint64Converter typeConverters.Uint64ByteSliceConverter,
	marshalizer marshal.Marshalizer,
) (*block.Header, []byte, error)

GetShardHeaderFromStorageWithNonce method returns a shard block header from storage with a given nonce and shardId

func GetShardHeaderWithNonce

func GetShardHeaderWithNonce(
	nonce uint64,
	shardId uint32,
	cacher storage.Cacher,
	uint64SyncMapCacher dataRetriever.Uint64SyncMapCacher,
	marshalizer marshal.Marshalizer,
	storageService dataRetriever.StorageService,
	uint64Converter typeConverters.Uint64ByteSliceConverter,
) (*block.Header, []byte, error)

GetShardHeaderWithNonce method returns a shard block header with a given nonce and shardId

func GetTransactionHandler

func GetTransactionHandler(
	senderShardID uint32,
	destShardID uint32,
	txHash []byte,
	shardedDataCacherNotifier dataRetriever.ShardedDataCacherNotifier,
	storageService dataRetriever.StorageService,
	marshalizer marshal.Marshalizer,
) (data.TransactionHandler, error)

GetTransactionHandler gets the transaction with a given sender/receiver shardId and txHash

func GetTransactionHandlerFromPool

func GetTransactionHandlerFromPool(
	senderShardID uint32,
	destShardID uint32,
	txHash []byte,
	shardedDataCacherNotifier dataRetriever.ShardedDataCacherNotifier,
) (data.TransactionHandler, error)

GetTransactionHandlerFromPool gets the transaction from pool with a given sender/receiver shardId and txHash

func GetTransactionHandlerFromStorage

func GetTransactionHandlerFromStorage(
	txHash []byte,
	storageService dataRetriever.StorageService,
	marshalizer marshal.Marshalizer,
) (data.TransactionHandler, error)

GetTransactionHandlerFromStorage gets the transaction from storage with a given sender/receiver shardId and txHash

func IsInProperRound

func IsInProperRound(index int64) bool

IsInProperRound checks if the given round index satisfies the round modulus trigger

func ShardCacherIdentifier

func ShardCacherIdentifier(senderShardId uint32, destinationShardId uint32) string

ShardCacherIdentifier generates a string identifier between 2 shards

func SortHeadersByNonce

func SortHeadersByNonce(headers []data.HeaderHandler)

SortHeadersByNonce will sort a given list of headers by nonce

Types

type ArgumentsParser

type ArgumentsParser interface {
	GetArguments() ([][]byte, error)
	GetCode() ([]byte, error)
	GetFunction() (string, error)
	ParseData(data string) error

	CreateDataFromStorageUpdate(storageUpdates []*vmcommon.StorageUpdate) string
	GetStorageUpdates(data string) ([]*vmcommon.StorageUpdate, error)
	IsInterfaceNil() bool
}

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

type BlackListHandler

type BlackListHandler interface {
	Add(key string) error
	Has(key string) bool
	Sweep()
	IsInterfaceNil() bool
}

BlackListHandler can determine if a certain key is or not blacklisted

type BlockChainHookHandler

type BlockChainHookHandler interface {
	TemporaryAccountsHandler
	SetCurrentHeader(hdr data.HeaderHandler)
}

type BlockHeaderState

type BlockHeaderState int

BlockHeaderState specifies which is the state of the block header received

const (
	// BHReceived defines ID of a received block header
	BHReceived BlockHeaderState = iota
	// BHReceivedTooLate defines ID of a late received block header
	BHReceivedTooLate
	// BHProcessed defines ID of a processed block header
	BHProcessed
	// BHProposed defines ID of a proposed block header
	BHProposed
	// BHNotarized defines ID of a notarized block header
	BHNotarized
)

type BlockProcessor

type BlockProcessor interface {
	ProcessBlock(blockChain data.ChainHandler, header data.HeaderHandler, body data.BodyHandler, haveTime func() time.Duration) error
	CommitBlock(blockChain data.ChainHandler, header data.HeaderHandler, body data.BodyHandler) error
	RevertAccountState()
	RevertStateToBlock(header data.HeaderHandler) error
	CreateNewHeader() data.HeaderHandler
	CreateBlockBody(initialHdrData data.HeaderHandler, haveTime func() bool) (data.BodyHandler, error)
	RestoreBlockIntoPools(header data.HeaderHandler, body data.BodyHandler) error
	ApplyBodyToHeader(hdr data.HeaderHandler, body data.BodyHandler) error
	ApplyProcessedMiniBlocks(processedMiniBlocks map[string]map[string]struct{})
	MarshalizedDataToBroadcast(header data.HeaderHandler, body data.BodyHandler) (map[uint32][]byte, map[string][][]byte, error)
	DecodeBlockBody(dta []byte) data.BodyHandler
	DecodeBlockHeader(dta []byte) data.HeaderHandler
	AddLastNotarizedHdr(shardId uint32, processedHdr data.HeaderHandler)
	RestoreLastNotarizedHrdsToGenesis()
	SetConsensusData(randomness []byte, round uint64, epoch uint32, shardId uint32)
	IsInterfaceNil() bool
}

BlockProcessor is the main interface for block execution engine

type BlockSizeThrottler

type BlockSizeThrottler interface {
	MaxItemsToAdd() uint32
	Add(round uint64, items uint32)
	Succeed(round uint64)
	ComputeMaxItems()
	IsInterfaceNil() bool
}

BlockSizeThrottler defines the functionality of adapting the node to the network speed/latency when it should send a block to its peers which should be received in a limited time frame

type BootStorer

type BootStorer interface {
	SaveLastRound(round int64) error
	Put(round int64, bootData bootstrapStorage.BootstrapData) error
	Get(round int64) (bootstrapStorage.BootstrapData, error)
	GetHighestRound() int64
	IsInterfaceNil() bool
}

BootStorer is the interface needed by bootstrapper to read/write data in storage

type Bootstrapper

type Bootstrapper interface {
	AddSyncStateListener(func(isSyncing bool))
	ShouldSync() bool
	StopSync()
	StartSync()
	SetStatusHandler(handler core.AppStatusHandler) error
	IsInterfaceNil() bool
}

Bootstrapper is an interface that defines the behaviour of a struct that is able to synchronize the node

type BootstrapperFromStorage

type BootstrapperFromStorage interface {
	LoadFromStorage() error
	IsInterfaceNil() bool
}

BootstrapperFromStorage is the interface needed by boot component to load data from storage

type DataPacker

type DataPacker interface {
	PackDataInChunks(data [][]byte, limit int) ([][]byte, error)
	IsInterfaceNil() bool
}

DataPacker can split a large slice of byte slices in smaller packets

type EconomicsAddressesHandler

type EconomicsAddressesHandler interface {
	CommunityAddress() string
	BurnAddress() string
	IsInterfaceNil() bool
}

EconomicsAddressesHandler will return information about economics addresses

type FeeHandler

type FeeHandler interface {
	MaxGasLimitPerBlock() uint64
	ComputeGasLimit(tx TransactionWithFeeHandler) uint64
	ComputeFee(tx TransactionWithFeeHandler) *big.Int
	CheckValidityTxValues(tx TransactionWithFeeHandler) error
	IsInterfaceNil() bool
}

FeeHandler is able to perform some economics calculation on a provided transaction

type ForkDetector

type ForkDetector interface {
	AddHeader(header data.HeaderHandler, headerHash []byte, state BlockHeaderState, finalHeaders []data.HeaderHandler, finalHeadersHashes [][]byte, isNotarizedShardStuck bool) error
	RemoveHeaders(nonce uint64, hash []byte)
	CheckFork() *ForkInfo
	GetHighestFinalBlockNonce() uint64
	ProbableHighestNonce() uint64
	ResetProbableHighestNonce()
	ResetFork()
	RestoreFinalCheckPointToGenesis()
	GetNotarizedHeaderHash(nonce uint64) []byte
	IsInterfaceNil() bool
}

ForkDetector is an interface that defines the behaviour of a struct that is able to detect forks

type ForkInfo

type ForkInfo struct {
	IsDetected bool
	Nonce      uint64
	Round      uint64
	Hash       []byte
}

ForkInfo hold the data related to a detected fork

func NewForkInfo

func NewForkInfo() *ForkInfo

NewForkInfo creates a new ForkInfo object

type GasHandler

type GasHandler interface {
	Init()
	SetGasConsumed(gasConsumed uint64, hash []byte)
	SetGasRefunded(gasRefunded uint64, hash []byte)
	GasConsumed(hash []byte) uint64
	GasRefunded(hash []byte) uint64
	TotalGasConsumed() uint64
	TotalGasRefunded() uint64
	RemoveGasConsumed(hashes [][]byte)
	RemoveGasRefunded(hashes [][]byte)
	ComputeGasConsumedByMiniBlock(*block.MiniBlock, map[string]data.TransactionHandler) (uint64, uint64, error)
	ComputeGasConsumedByTx(txSenderShardId uint32, txReceiverShardId uint32, txHandler data.TransactionHandler) (uint64, uint64, error)
	IsInterfaceNil() bool
}

GasHandler is able to perform some gas calculation

type HashAccesser

type HashAccesser interface {
	SetHash([]byte)
	Hash() []byte
}

HashAccesser interface provides functionality over hashable objects

type HdrValidatorHandler

type HdrValidatorHandler interface {
	Hash() []byte
	HeaderHandler() data.HeaderHandler
}

HdrValidatorHandler defines the functionality that is needed for a HdrValidator to validate a header

type HeaderValidator

type HeaderValidator interface {
	HeaderValidForProcessing(headerHandler HdrValidatorHandler) error
	IsInterfaceNil() bool
}

HeaderValidator can determine if a provided header handler is valid or not from the process point of view

type InterceptedData

type InterceptedData interface {
	CheckValidity() error
	IsForCurrentShard() bool
	IsInterfaceNil() bool
	Hash() []byte
}

InterceptedData represents the interceptor's view of the received data

type InterceptedDataFactory

type InterceptedDataFactory interface {
	Create(buff []byte) (InterceptedData, error)
	IsInterfaceNil() bool
}

InterceptedDataFactory can create new instances of InterceptedData

type Interceptor

type Interceptor interface {
	ProcessReceivedMessage(message p2p.MessageP2P, broadcastHandler func(buffToSend []byte)) error
	IsInterfaceNil() bool
}

Interceptor defines what a data interceptor should do It should also adhere to the p2p.MessageProcessor interface so it can wire to a p2p.Messenger

type InterceptorProcessor

type InterceptorProcessor interface {
	Validate(data InterceptedData) error
	Save(data InterceptedData) error
	IsInterfaceNil() bool
}

InterceptorProcessor further validates and saves received data

type InterceptorThrottler

type InterceptorThrottler interface {
	CanProcess() bool
	StartProcessing()
	EndProcessing()
	IsInterfaceNil() bool
}

InterceptorThrottler can

type InterceptorsContainer

type InterceptorsContainer interface {
	Get(key string) (Interceptor, error)
	Add(key string, val Interceptor) error
	AddMultiple(keys []string, interceptors []Interceptor) error
	Replace(key string, val Interceptor) error
	Remove(key string)
	Len() int
	IsInterfaceNil() bool
}

InterceptorsContainer defines an interceptors holder data type with basic functionality

type InterceptorsContainerFactory

type InterceptorsContainerFactory interface {
	Create() (InterceptorsContainer, error)
	IsInterfaceNil() bool
}

InterceptorsContainerFactory defines the functionality to create an interceptors container

type IntermediateProcessorContainer

type IntermediateProcessorContainer interface {
	Get(key block.Type) (IntermediateTransactionHandler, error)
	Add(key block.Type, val IntermediateTransactionHandler) error
	AddMultiple(keys []block.Type, preprocessors []IntermediateTransactionHandler) error
	Replace(key block.Type, val IntermediateTransactionHandler) error
	Remove(key block.Type)
	Len() int
	Keys() []block.Type
	IsInterfaceNil() bool
}

IntermediateProcessorContainer defines an IntermediateProcessor holder data type with basic functionality

type IntermediateProcessorsContainerFactory

type IntermediateProcessorsContainerFactory interface {
	Create() (IntermediateProcessorContainer, error)
	IsInterfaceNil() bool
}

IntermediateProcessorsContainerFactory defines the functionality to create an IntermediateProcessors container

type IntermediateTransactionHandler

type IntermediateTransactionHandler interface {
	AddIntermediateTransactions(txs []data.TransactionHandler) error
	CreateAllInterMiniBlocks() map[uint32]*block.MiniBlock
	VerifyInterMiniBlocks(body block.Body) error
	CreateMarshalizedData(txHashes [][]byte) ([][]byte, error)
	SaveCurrentIntermediateTxToStorage() error
	GetAllCurrentFinishedTxs() map[string]data.TransactionHandler
	CreateBlockStarted()
	IsInterfaceNil() bool
}

IntermediateTransactionHandler handles transactions which are not resolved in only one step

type InternalTransactionProducer added in v1.0.20

type InternalTransactionProducer interface {
	CreateAllInterMiniBlocks() map[uint32]*block.MiniBlock
	IsInterfaceNil() bool
}

InternalTransactionProducer creates system transactions (e.g. rewards)

type MiniBlocksCompacter added in v1.0.36

type MiniBlocksCompacter interface {
	Compact(block.MiniBlockSlice, map[string]data.TransactionHandler) block.MiniBlockSlice
	Expand(block.MiniBlockSlice, map[string]data.TransactionHandler) (block.MiniBlockSlice, error)
	IsInterfaceNil() bool
}

MiniBlocksCompacter defines the functionality that is needed for mini blocks compaction and expansion

type NetworkConnectionWatcher

type NetworkConnectionWatcher interface {
	IsConnectedToTheNetwork() bool
	IsInterfaceNil() bool
}

NetworkConnectionWatcher defines a watchdog functionality used to specify if the current node is still connected to the rest of the network

type PeerChangesHandler

type PeerChangesHandler interface {
	PeerChanges() []block.PeerData
	VerifyPeerChanges(peerChanges []block.PeerData) error
	IsInterfaceNil() bool
}

PeerChangesHandler will create the peer changes data for current block and will verify them

type PoolsCleaner

type PoolsCleaner interface {
	Clean(duration time.Duration) (bool, error)
	NumRemovedTxs() uint64
	IsInterfaceNil() bool
}

PoolsCleaner define the functionality that is needed for a pools cleaner

type PreProcessor

type PreProcessor interface {
	CreateBlockStarted()
	IsDataPrepared(requestedTxs int, haveTime func() time.Duration) error

	RemoveTxBlockFromPools(body block.Body, miniBlockPool storage.Cacher) error
	RestoreTxBlockIntoPools(body block.Body, miniBlockPool storage.Cacher) (int, error)
	SaveTxBlockToStorage(body block.Body) error

	ProcessBlockTransactions(body block.Body, round uint64, haveTime func() bool) error
	RequestBlockTransactions(body block.Body) int

	CreateMarshalizedData(txHashes [][]byte) ([][]byte, error)

	RequestTransactionsForMiniBlock(miniBlock *block.MiniBlock) int
	ProcessMiniBlock(miniBlock *block.MiniBlock, haveTime func() bool, round uint64) error
	CreateAndProcessMiniBlock(sndShardId, dstShardId uint32, spaceRemained int, haveTime func() bool, round uint64) (*block.MiniBlock, error)
	CreateAndProcessMiniBlocks(maxTxSpaceRemained uint32, maxMbSpaceRemained uint32, round uint64, haveTime func() bool) (block.MiniBlockSlice, error)

	GetAllCurrentUsedTxs() map[string]data.TransactionHandler
	IsInterfaceNil() bool
}

PreProcessor is an interface used to prepare and process transaction data

type PreProcessorsContainer

type PreProcessorsContainer interface {
	Get(key block.Type) (PreProcessor, error)
	Add(key block.Type, val PreProcessor) error
	AddMultiple(keys []block.Type, preprocessors []PreProcessor) error
	Replace(key block.Type, val PreProcessor) error
	Remove(key block.Type)
	Len() int
	Keys() []block.Type
	IsInterfaceNil() bool
}

PreProcessorsContainer defines an PreProcessors holder data type with basic functionality

type PreProcessorsContainerFactory

type PreProcessorsContainerFactory interface {
	Create() (PreProcessorsContainer, error)
	IsInterfaceNil() bool
}

PreProcessorsContainerFactory defines the functionality to create an PreProcessors container

type RequestBlockBodyHandler

type RequestBlockBodyHandler interface {
	GetBlockBodyFromPool(headerHandler data.HeaderHandler) (data.BodyHandler, error)
}

RequestBlockBodyHandler is the interface needed by process block

type RequestHandler

type RequestHandler interface {
	RequestHeaderByNonce(shardId uint32, nonce uint64)
	RequestTransaction(shardId uint32, txHashes [][]byte)
	RequestUnsignedTransactions(destShardID uint32, scrHashes [][]byte)
	RequestRewardTransactions(destShardID uint32, txHashes [][]byte)
	RequestMiniBlock(shardId uint32, miniblockHash []byte)
	RequestHeader(shardId uint32, hash []byte)
	IsInterfaceNil() bool
}

RequestHandler defines the methods through which request to data can be made

type RequiredDataPool

type RequiredDataPool struct {
	// contains filtered or unexported fields
}

RequiredDataPool represents a structure that can hold a list of required data. Any time one of the expected hash value is received, the associated bit in the receivedBitmap property is set to 1. All of the data is considered received when the ones count of the received bitmap is equal to the expected data length

func (*RequiredDataPool) ExpectedData

func (rh *RequiredDataPool) ExpectedData() [][]byte

ExpectedData returns the RequiredDataPool's expected data

func (*RequiredDataPool) ReceivedAll

func (rh *RequiredDataPool) ReceivedAll() bool

ReceivedAll will return true if the count of ones in the bitmap is greater or equal to the expected data length

func (*RequiredDataPool) SetHashes

func (rh *RequiredDataPool) SetHashes(hashes [][]byte)

SetHashes sets the expected data to the passed hashes parameter. The bitmap is also reset and adapted to the length of the new expected data

func (*RequiredDataPool) SetReceivedHash

func (rh *RequiredDataPool) SetReceivedHash(hash []byte)

SetReceivedHash finds the hash in the expected values and sets the appropriate bit to 1. Nothing will happen if the hash is not actually expected

type RewardTransactionPreProcessor

type RewardTransactionPreProcessor interface {
	AddComputedRewardMiniBlocks(computedRewardMiniblocks block.MiniBlockSlice)
	IsInterfaceNil() bool
}

RewardTransactionPreProcessor prepares the processing of reward transactions

type RewardTransactionProcessor

type RewardTransactionProcessor interface {
	ProcessRewardTransaction(rewardTx *rewardTx.RewardTx) error
	IsInterfaceNil() bool
}

RewardTransactionProcessor is the interface for reward transaction execution engine

type RewardsHandler

type RewardsHandler interface {
	RewardsValue() *big.Int
	CommunityPercentage() float64
	LeaderPercentage() float64
	BurnPercentage() float64
	IsInterfaceNil() bool
}

RewardsHandler will return information about rewards

type SCQuery

type SCQuery struct {
	ScAddress []byte
	FuncName  string
	Arguments [][]byte
}

SCQuery represents a prepared query for executing a function of the smart contract

type SmartContractProcessor

type SmartContractProcessor interface {
	ExecuteSmartContractTransaction(tx data.TransactionHandler, acntSrc, acntDst state.AccountHandler, round uint64) error
	DeploySmartContract(tx data.TransactionHandler, acntSrc state.AccountHandler, round uint64) error
	IsInterfaceNil() bool
}

SmartContractProcessor is the main interface for the smart contract caller engine

type SmartContractResultProcessor

type SmartContractResultProcessor interface {
	ProcessSmartContractResult(scr *smartContractResult.SmartContractResult) error
	IsInterfaceNil() bool
}

SmartContractResultProcessor is the main interface for smart contract result execution engine

type SmartContractToProtocolHandler

type SmartContractToProtocolHandler interface {
	UpdateProtocol(body block.Body, nonce uint64) error
	IsInterfaceNil() bool
}

SmartContractToProtocolHandler is able to translate data from smart contract state into protocol changes

type SpecialAddressHandler added in v1.0.20

type SpecialAddressHandler interface {
	SetShardConsensusData(randomness []byte, round uint64, epoch uint32, shardID uint32) error
	SetMetaConsensusData(randomness []byte, round uint64, epoch uint32) error
	ConsensusShardRewardData() *data.ConsensusRewardData
	ConsensusMetaRewardData() []*data.ConsensusRewardData
	ClearMetaConsensusData()
	ElrondCommunityAddress() []byte
	LeaderAddress() []byte
	BurnAddress() []byte
	SetElrondCommunityAddress(elrond []byte)
	ShardIdForAddress([]byte) (uint32, error)
	Epoch() uint32
	Round() uint64
	IsCurrentNodeInConsensus() bool
	IsInterfaceNil() bool
}

SpecialAddressHandler responds with needed special addresses

type TemporaryAccountsHandler

type TemporaryAccountsHandler interface {
	AddTempAccount(address []byte, balance *big.Int, nonce uint64)
	CleanTempAccounts()
	TempAccount(address []byte) state.AccountHandler
	IsInterfaceNil() bool
}

TemporaryAccountsHandler defines the functionality to create temporary accounts and pass to VM. This holder will contain usually one account from shard X that calls a SC in shard Y so when executing the code in shard Y, this impl will hold an ephemeral copy of the sender account from shard X

type TopicHandler

type TopicHandler interface {
	HasTopic(name string) bool
	CreateTopic(name string, createChannelForTopic bool) error
	RegisterMessageProcessor(topic string, handler p2p.MessageProcessor) error
	IsInterfaceNil() bool
}

TopicHandler defines the functionality needed by structs to manage topics and message processors

type TransactionCoordinator

type TransactionCoordinator interface {
	RequestMiniBlocks(header data.HeaderHandler)
	RequestBlockTransactions(body block.Body)
	IsDataPreparedForProcessing(haveTime func() time.Duration) error

	SaveBlockDataToStorage(body block.Body) error
	RestoreBlockDataFromStorage(body block.Body) (int, error)
	RemoveBlockDataFromPool(body block.Body) error

	ProcessBlockTransaction(body block.Body, round uint64, haveTime func() time.Duration) error

	CreateBlockStarted()
	CreateMbsAndProcessCrossShardTransactionsDstMe(header data.HeaderHandler, processedMiniBlocksHashes map[string]struct{}, maxTxSpaceRemained uint32, maxMbSpaceRemained uint32, round uint64, haveTime func() bool) (block.MiniBlockSlice, uint32, bool)
	CreateMbsAndProcessTransactionsFromMe(maxTxSpaceRemained uint32, maxMbSpaceRemained uint32, round uint64, haveTime func() bool) block.MiniBlockSlice

	CreateMarshalizedData(body block.Body) (map[uint32]block.MiniBlockSlice, map[string][][]byte)

	GetAllCurrentUsedTxs(blockType block.Type) map[string]data.TransactionHandler

	VerifyCreatedBlockTransactions(body block.Body) error
	IsInterfaceNil() bool
}

TransactionCoordinator is an interface to coordinate transaction processing using multiple processors

type TransactionFeeHandler

type TransactionFeeHandler interface {
	ProcessTransactionFee(cost *big.Int)
	IsInterfaceNil() bool
}

TransactionFeeHandler processes the transaction fee

type TransactionProcessor

type TransactionProcessor interface {
	ProcessTransaction(transaction *transaction.Transaction, round uint64) error
	IsInterfaceNil() bool
}

TransactionProcessor is the main interface for transaction execution engine

type TransactionType

type TransactionType int

TransactionType specifies the type of the transaction

const (
	// MoveBalance defines ID of a payment transaction - moving balances
	MoveBalance TransactionType = iota
	// SCDeployment defines ID of a transaction to store a smart contract
	SCDeployment
	// SCInvoking defines ID of a transaction of type smart contract call
	SCInvoking
	// RewardTx defines ID of a reward transaction
	RewardTx
	// InvalidTransaction defines unknown transaction type
	InvalidTransaction
)

type TransactionVerifier

type TransactionVerifier interface {
	IsTransactionValid(tx data.TransactionHandler) error
}

TransactionVerifier interface validates if the transaction is good and if it should be processed

type TransactionWithFeeHandler

type TransactionWithFeeHandler interface {
	GetGasLimit() uint64
	GetGasPrice() uint64
	GetData() string
}

TransactionWithFeeHandler represents a transaction structure that has economics variables defined

type TxTypeHandler

type TxTypeHandler interface {
	ComputeTransactionType(tx data.TransactionHandler) (TransactionType, error)
	IsInterfaceNil() bool
}

TxTypeHandler is an interface to calculate the transaction type

type TxValidator

type TxValidator interface {
	CheckTxValidity(txHandler TxValidatorHandler) error
	NumRejectedTxs() uint64
	IsInterfaceNil() bool
}

TxValidator can determine if a provided transaction handler is valid or not from the process point of view

type TxValidatorHandler

type TxValidatorHandler interface {
	SenderShardId() uint32
	Nonce() uint64
	SenderAddress() state.AddressContainer
	TotalValue() *big.Int
}

TxValidatorHandler defines the functionality that is needed for a TxValidator to validate a transaction

type ValidatorSettingsHandler

type ValidatorSettingsHandler interface {
	UnBoundPeriod() uint64
	StakeValue() *big.Int
	IsInterfaceNil() bool
}

ValidatorSettingsHandler defines the functionality which is needed for validators' settings

type ValidatorStatisticsProcessor

type ValidatorStatisticsProcessor interface {
	UpdatePeerState(header data.HeaderHandler) ([]byte, error)
	RevertPeerState(header data.HeaderHandler) error
	RevertPeerStateToSnapshot(snapshot int) error
	IsInterfaceNil() bool
	Commit() ([]byte, error)
	RootHash() ([]byte, error)
}

ValidatorStatisticsProcessor is the main interface for validators' consensus participation statistics

type VirtualMachinesContainer

type VirtualMachinesContainer interface {
	Get(key []byte) (vmcommon.VMExecutionHandler, error)
	Add(key []byte, val vmcommon.VMExecutionHandler) error
	AddMultiple(keys [][]byte, vms []vmcommon.VMExecutionHandler) error
	Replace(key []byte, val vmcommon.VMExecutionHandler) error
	Remove(key []byte)
	Len() int
	Keys() [][]byte
	IsInterfaceNil() bool
}

VirtualMachinesContainer defines a virtual machine holder data type with basic functionality

type VirtualMachinesContainerFactory

type VirtualMachinesContainerFactory interface {
	Create() (VirtualMachinesContainer, error)
	BlockChainHookImpl() BlockChainHookHandler
	IsInterfaceNil() bool
}

VirtualMachinesContainerFactory defines the functionality to create a virtual machine container

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL