Documentation
¶
Index ¶
- Variables
- func CalculateFunctionSelector(functionSignature string) []byte
- func CheckConfigure(chainConfig ChainConfig, parentTimestamp *uint64, blockContext BlockContext, ...)
- type AddressRange
- type BlockContext
- type ChainConfig
- type PrecompileAccessibleState
- type RunStatefulPrecompileFunc
- type StateDB
- type StatefulPrecompileConfig
- type StatefulPrecompiledContract
Constants ¶
This section is empty.
Variables ¶
var ( UsedAddresses = []common.Address{} // ReservedRanges contains addresses ranges that are reserved // for precompiles and cannot be used as EOA or deployed contracts. ReservedRanges = []AddressRange{ { common.HexToAddress("0x0100000000000000000000000000000000000000"), common.HexToAddress("0x01000000000000000000000000000000000000ff"), }, } )
Designated addresses of stateful precompiles Note: it is important that none of these addresses conflict with each other or any other precompiles in core/vm/contracts.go. We start at 0x0100000000000000000000000000000000000000 and will increment by 1 from here to reduce the risk of conflicts.
Functions ¶
func CalculateFunctionSelector ¶
CalculateFunctionSelector returns the 4 byte function selector that results from [functionSignature] Ex. the function setBalance(addr address, balance uint256) should be passed in as the string: "setBalance(address,uint256)"
func CheckConfigure ¶
func CheckConfigure(chainConfig ChainConfig, parentTimestamp *uint64, blockContext BlockContext, precompileConfig StatefulPrecompileConfig, state StateDB)
CheckConfigure checks if [config] is activated by the transition from block at [parentTimestamp] to the timestamp set in [blockContext]. If it does, then it calls Configure on [precompileConfig] to make the necessary state update to enable the StatefulPrecompile. Note: this function is called within genesis to configure the starting state if [precompileConfig] specifies that it should be configured at genesis, or happens during block processing to update the state before processing the given block. TODO: add ability to call Configure at different timestamps, so that developers can easily re-configure by updating the stateful precompile config. Assumes that [config] is non-nil.
Types ¶
type AddressRange ¶
AddressRange represents a continuous range of addresses
type BlockContext ¶
BlockContext defines an interface that provides information to a stateful precompile about the block that activates the upgrade. The precompile can access this information to initialize its state.
type ChainConfig ¶
type ChainConfig interface { }
ChainContext defines an interface that provides information to a stateful precompile about the chain configuration. The precompile can access this information to initialize its state.
type PrecompileAccessibleState ¶
type PrecompileAccessibleState interface { GetStateDB() StateDB GetBlockContext() BlockContext NativeAssetCall(caller common.Address, input []byte, suppliedGas uint64, gasGost uint64, readOnly bool) (ret []byte, remainingGas uint64, err error) }
PrecompileAccessibleState defines the interface exposed to stateful precompile contracts
type StateDB ¶
type StateDB interface { GetState(common.Address, common.Hash) common.Hash SetState(common.Address, common.Hash, common.Hash) SetCode(common.Address, []byte) SetNonce(common.Address, uint64) GetNonce(common.Address) uint64 GetBalance(common.Address) *big.Int AddBalance(common.Address, *big.Int) SubBalance(common.Address, *big.Int) SubBalanceMultiCoin(common.Address, common.Hash, *big.Int) AddBalanceMultiCoin(common.Address, common.Hash, *big.Int) GetBalanceMultiCoin(common.Address, common.Hash) *big.Int CreateAccount(common.Address) Exist(common.Address) bool }
StateDB is the interface for accessing DELTA state
type StatefulPrecompileConfig ¶
type StatefulPrecompileConfig interface { // Address returns the address where the stateful precompile is accessible. Address() common.Address // Timestamp returns the timestamp at which this stateful precompile should be enabled. // 1) 0 indicates that the precompile should be enabled from genesis. // 2) n indicates that the precompile should be enabled in the first block with timestamp >= [n]. // 3) nil indicates that the precompile is never enabled. Timestamp() *uint64 // Configure is called on the first block where the stateful precompile should be enabled. // This allows the stateful precompile to configure its own state via [StateDB] as necessary. // This function must be deterministic since it will impact the DELTA state. If a change to the // config causes a change to the state modifications made in Configure, then it cannot be safely // made to the config after the network upgrade has gone into effect. // // Configure is called on the first block where the stateful precompile should be enabled. This // provides the config the ability to set its initial state and should only modify the state within // its own address space. Configure(ChainConfig, StateDB, BlockContext) // Contract returns a thread-safe singleton that can be used as the StatefulPrecompiledContract when // this config is enabled. Contract() StatefulPrecompiledContract }
StatefulPrecompileConfig defines the interface for a stateful precompile to
type StatefulPrecompiledContract ¶
type StatefulPrecompiledContract interface { // Run executes the precompiled contract. Run(accessibleState PrecompileAccessibleState, caller common.Address, addr common.Address, input []byte, suppliedGas uint64, readOnly bool) (ret []byte, remainingGas uint64, err error) }
StatefulPrecompiledContract is the interface for executing a precompiled contract