polybft

package
v0.0.0-...-f672fcd Latest Latest
Warning

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

 Go to latest Published: Jan 28, 2024 License: Apache-2.0 Imports: 52 Imported by: 0

README

Polybft consensus protocol

Polybft is a consensus protocol, which runs go-ibft consensus engine.

It has a native support for running bridge, which enables running cross-chain transactions with Ethereum-compatible blockchains.

Setup local testing environment

  1. Build binary

    $ go build -o polygon-edge .

  2. Init secrets - this command is used to generate account secrets (ECDSA, BLS as well as P2P networking node id). --data-dir denotes folder prefix names and --num how many accounts need to be created. This command is for testing purposes only.

    $ polygon-edge polybft-secrets --data-dir test-chain- --num 4

  3. Create chain configuration - this command creates chain configuration, which is needed to run a blockchain. It contains initial validator set as well and there are two ways to specify it:

    • all the validators information are present in local storage of single host and therefore directory if provided using --validators-path flag and validators folder prefix names using --validators-prefix flag
    • for reward distribution to work, user must define a reward wallet address with its balance. Wallet address is used to distribute reward tokens from that address to validators that signed blocks in that epoch.
    $ polygon-edge genesis --block-gas-limit 10000000 --epoch-size 10 \
    [--validators-path ./] [--validators-prefix test-chain-] \
    [--consensus polybft] \
    [--reward-wallet address:amount]
    • validators information are scafollded on multiple hosts and therefore necessary information are supplied using --validators flag. Validator information needs to be supplied in the strictly following format: <multi address>:<public ECDSA address>:<public BLS key>:<BLS signature>. Note: when specifying validators via validators flag, entire multi address must be specified.
    $ polygon-edge genesis --block-gas-limit 10000000 --epoch-size 10 \
    --validators /ip4/127.0.0.1/tcp/30301/p2p/16Uiu2HAmV5hqAp77untfJRorxqKmyUxgaVn8YHFjBJm9gKMms3mr:0xDcBe0024206ec42b0Ef4214Ac7B71aeae1A11af0:1cf134e02c6b2afb2ceda50bf2c9a01da367ac48f7783ee6c55444e1cab418ec0f52837b90a4d8cf944814073fc6f2bd96f35366a3846a8393e3cb0b19197cde23e2b40c6401fa27ff7d0c36779d9d097d1393cab6fc1d332f92fb3df850b78703b2989d567d1344e219f0667a1863f52f7663092276770cf513f9704b5351c4:11b18bde524f4b02258a8d196b687f8d8e9490d536718666dc7babca14eccb631c238fb79aa2b44a5a4dceccad2dd797f537008dda185d952226a814c1acf7c2
    [--validators /ip4/127.0.0.1/tcp/30302/p2p/16Uiu2HAmGmidRQY5BGJPGVRF8p1pYFdfzuf1StHzXGLDizuxJxex:0x2da750eD4AE1D5A7F7c996Faec592F3d44060e90:088d92c25b5f278750534e8a902da604a1aa39b524b4511f5f47c3a386374ca3031b667beb424faef068a01cee3428a1bc8c1c8bab826f30a1ee03fbe90cb5f01abcf4abd7af3bbe83eaed6f82179b9cbdc417aad65d919b802d91c2e1aaefec27ba747158bc18a0556e39bfc9175c099dd77517a85731894bbea3d191a622bc:08dc3006352fdc01b331907fd3a68d4d68ed40329032598c1c0faa260421d66720965ace3ba29c6d6608ec1facdbf4624bca72df36c34afd4bdd753c4dfe049c]

  4. Start rootchain server - rootchain server is a Geth instance running in dev mode, which simulates Ethereum network. This command is for testing purposes only.

    $ polygon-edge rootchain server

  5. Deploy StakeManager - if not already deployed to rootchain. Command has a test flag used only in testing purposes which would deploy a mock ERC20 token which would be used for staking. If not used for testing, stake-token flag should be provided:

    $ polygon-edge polybft stake-manager-deploy \
 --deployer-key <hex_encoded_rootchain_account_private_key> \
[--genesis ./genesis.json] \
[--json-rpc http://127.0.0.1:8545] \
[--stake-token 0xaddressOfStakeToken] \
[--test]

  6. Deploy and initialize rootchain contracts - this command deploys rootchain smart contracts and initializes them. It also updates genesis configuration with rootchain contract addresses and rootchain default sender address.

    $ polygon-edge rootchain deploy \
--deployer-key <hex_encoded_rootchain_account_private_key> \
--stake-manager <address_of_stake_manager_contract> \
--stake-token 0xaddressOfStakeToken \
[--genesis ./genesis.json] \
[--json-rpc http://127.0.0.1:8545] \
[--test]

  7. Fund validators on rootchain - in order for validators to be able to send transactions to Ethereum, they need to be funded in order to be able to cover gas cost. This command is for testing purposes only.

    $ polygon-edge rootchain fund \
    --addresses 0x1234567890123456789012345678901234567890 \
    --amounts 200000000000000000000

  8. Whitelist validators on rootchain - in order for validators to be able to be registered on the SupernetManager contract on rootchain. Note that only deployer of SupernetManager contract (the one who run the deploy command) can whitelist validators on rootchain. He can use either its hex encoded private key, or data-dir flag if he has secerets initialized:

    $ polygon-edge polybft whitelist-validators --private-key <hex_encoded_rootchain_account_private_key_of_supernetManager_deployer> \
--addresses <addresses_of_validators> --supernet-manager <address_of_SupernetManager_contract>

  9. Register validators on rootchain - each validator registers itself on SupernetManager. This command is for testing purposes only.

    $ polygon-edge polybft register-validator --data-dir ./test-chain-1 \
--supernet-manager <address_of_SupernetManager_contract>

  10. Initial staking on rootchain - each validator needs to do initial staking on rootchain (StakeManager) contract. This command is for testing purposes only.

    $ polygon-edge polybft stake --data-dir ./test-chain-1 --supernet-id <supernet_id_from_genesis> \
--amount <amount_of_tokens_to_stake> \
--stake-manager <address_of_StakeManager_contract> --stake-token <address_of_erc20_token_used_for_staking>

  11. Finalize genesis validator set on rootchain (SupernetManager) contract. This is done after all validators from genesis do initial staking on rootchain, and it's a final step that is required before starting the child chain. This needs to be done by the deployer of SupernetManager contract (the user that run the deploy command). He can use either its hex encoded private key, or data-dir flag if he has secerets initialized. If enable-staking flag is provided, validators will be able to continue staking on rootchain. If not, genesis validators will not be able update its stake or unstake, nor will newly registered validators after genesis will be able to stake tokens on the rootchain. Enabling of staking can be done through this command, or later after the child chain starts.

    $ polygon-edge polybft supernet --private-key <hex_encoded_rootchain_account_private_key_of_supernetManager_deployer> \
--genesis <path_to_genesis_file> \
--supernet-manager <address_of_SupernetManager_contract> \
--stake-manager <address_of_StakeManager_contract> \
--finalize-genesis --enable-staking

  12. Run (child chain) cluster, consisting of 4 Edge clients in this particular example

    $ polygon-edge server --data-dir ./test-chain-1 --chain genesis.json --grpc-address :5001 --libp2p :30301 --jsonrpc :9545 \
--seal --log-level DEBUG

$ polygon-edge server --data-dir ./test-chain-2 --chain genesis.json --grpc-address :5002 --libp2p :30302 --jsonrpc :10002 \
--seal --log-level DEBUG

$ polygon-edge server --data-dir ./test-chain-3 --chain genesis.json --grpc-address :5003 --libp2p :30303 --jsonrpc :10003 \
--seal --log-level DEBUG

$ polygon-edge server --data-dir ./test-chain-4 --chain genesis.json --grpc-address :5004 --libp2p :30304 --jsonrpc :10004 \
--seal --log-level DEBUG

    It is possible to run child chain nodes in "relayer" mode. It allows automatic execution of deposit events on behalf of users. In order to start node in relayer mode, it is necessary to supply --relayer flag:

    $ polygon-edge server --data-dir ./test-chain-1 --chain genesis.json --grpc-address :5001 --libp2p :30301 --jsonrpc :9545 \
--seal --log-level DEBUG --relayer

Documentation

Overview

Package polybft implements PBFT consensus algorithm integration and bridge feature

Index

Constants

View Source 
const (
	// ExtraVanity represents a fixed number of extra-data bytes reserved for proposer vanity
	ExtraVanity = 32

	// ExtraSeal represents the fixed number of extra-data bytes reserved for proposer seal
	ExtraSeal = 65
)
View Source 
const ConsensusName = "polybft"

Variables

View Source 
var PolyBFTMixDigest = types.StringToHash("adce6e5230abe012342a44e4e9b6d05997d6f015387ae0e59be924afc7ec70c1")

PolyBFTMixDigest represents a hash of "PolyBFT Mix" to identify whether the block is from PolyBFT consensus engine

Functions

func Factory 

func Factory(params *consensus.Params) (consensus.Consensus, error)

Factory is the factory function to create a discovery consensus

func ForkManagerFactory 

func ForkManagerFactory(forks *chain.Forks) error

func ForkManagerInitialParamsFactory 

func ForkManagerInitialParamsFactory(config *chain.Chain) (*forkmanager.ForkParams, error)

func GenesisPostHookFactory 

func GenesisPostHookFactory(config *chain.Chain, engineName string) func(txn *state.Transition) error

func GetIbftExtraClean 

func GetIbftExtraClean(extraRaw []byte) ([]byte, error)

GetIbftExtraClean returns unmarshaled extra field from the passed in header, but without signatures for the given header (it only includes signatures for the parent block)

func NewStateProvider 

func NewStateProvider(transition *state.Transition) contract.Provider

NewStateProvider initializes EVM against given state and chain config and returns stateProvider instance which is an abstraction for smart contract calls

Types

type BlockBuilder 

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

func NewBlockBuilder 

func NewBlockBuilder(params *BlockBuilderParams) *BlockBuilder

func (*BlockBuilder) Block 

func (b *BlockBuilder) Block() *types.Block

Block returns the built block if nil, it is not built yet

func (*BlockBuilder) Build 

func (b *BlockBuilder) Build(handler func(h *types.Header)) (*types.FullBlock, error)

Build creates the state and the final block

func (*BlockBuilder) Fill 

func (b *BlockBuilder) Fill()

Fill fills the block with transactions from the txpool

func (*BlockBuilder) GetState 

func (b *BlockBuilder) GetState() *state.Transition

GetState returns Transition reference

func (*BlockBuilder) Receipts 

func (b *BlockBuilder) Receipts() []*types.Receipt

Receipts returns the collection of transaction receipts for given block

func (*BlockBuilder) Reset 

func (b *BlockBuilder) Reset() error

Init initializes block builder before adding transactions and actual block building

func (*BlockBuilder) WriteTx 

func (b *BlockBuilder) WriteTx(tx *types.Transaction) error

WriteTx applies given transaction to the state. If transaction apply fails, it reverts the saved snapshot.

type BlockBuilderParams 

type BlockBuilderParams struct {
	// Parent block
	Parent *types.Header

	// Executor
	Executor *state.Executor

	// Coinbase that is signing the block
	Coinbase types.Address

	// GasLimit is the gas limit for the block
	GasLimit uint64

	// duration for one block
	BlockTime time.Duration

	// Logger
	Logger hcf.Logger

	// txPoolInterface implementation
	TxPool txPoolInterface

	// BaseFee is the base fee
	BaseFee uint64
}

BlockBuilderParams are fields for the block that cannot be changed

type BridgeConfig 

type BridgeConfig struct {
	StateSenderAddr                   types.Address `json:"stateSenderAddress"`
	CheckpointManagerAddr             types.Address `json:"checkpointManagerAddress"`
	ExitHelperAddr                    types.Address `json:"exitHelperAddress"`
	RootERC20PredicateAddr            types.Address `json:"erc20PredicateAddress"`
	ChildMintableERC20PredicateAddr   types.Address `json:"erc20ChildMintablePredicateAddress"`
	RootNativeERC20Addr               types.Address `json:"nativeERC20Address"`
	RootERC721PredicateAddr           types.Address `json:"erc721PredicateAddress"`
	ChildMintableERC721PredicateAddr  types.Address `json:"erc721ChildMintablePredicateAddress"`
	RootERC1155PredicateAddr          types.Address `json:"erc1155PredicateAddress"`
	ChildMintableERC1155PredicateAddr types.Address `json:"erc1155ChildMintablePredicateAddress"`
	ChildERC20Addr                    types.Address `json:"childERC20Address"`
	ChildERC721Addr                   types.Address `json:"childERC721Address"`
	ChildERC1155Addr                  types.Address `json:"childERC1155Address"`
	CustomSupernetManagerAddr         types.Address `json:"customSupernetManagerAddr"`
	StakeManagerAddr                  types.Address `json:"stakeManagerAddr"`
	// only populated if stake-manager-deploy command is executed, and used for e2e tests
	StakeTokenAddr types.Address `json:"stakeTokenAddr,omitempty"`
	BLSAddress     types.Address `json:"blsAddr"`
	BN256G2Address types.Address `json:"bn256G2Addr"`

	JSONRPCEndpoint         string                   `json:"jsonRPCEndpoint"`
	EventTrackerStartBlocks map[types.Address]uint64 `json:"eventTrackerStartBlocks"`
}

BridgeConfig is the rootchain configuration, needed for bridging

type BridgeTransport 

type BridgeTransport interface {
	Multicast(msg interface{})
}

BridgeTransport is an abstraction of network layer for a bridge

type BurnContractInfo 

type BurnContractInfo struct {
	BlockNumber        uint64
	Address            types.Address
	DestinationAddress types.Address
}

BurnContractInfo contains metadata for burn contract, which is part of EIP-1559 specification

type CheckpointData 

type CheckpointData struct {
	BlockRound            uint64
	EpochNumber           uint64
	CurrentValidatorsHash types.Hash
	NextValidatorsHash    types.Hash
	EventRoot             types.Hash
}

CheckpointData represents data needed for checkpointing mechanism

func (*CheckpointData) Copy 

func (c *CheckpointData) Copy() *CheckpointData

Copy returns deep copy of CheckpointData instance

func (*CheckpointData) Hash 

func (c *CheckpointData) Hash(chainID uint64, blockNumber uint64, blockHash types.Hash) (types.Hash, error)

Hash calculates keccak256 hash of the CheckpointData. CheckpointData is ABI encoded and then hashed.

func (*CheckpointData) MarshalRLPWith 

func (c *CheckpointData) MarshalRLPWith(ar *fastrlp.Arena) *fastrlp.Value

MarshalRLPWith defines the marshal function implementation for CheckpointData

func (*CheckpointData) UnmarshalRLPWith 

func (c *CheckpointData) UnmarshalRLPWith(v *fastrlp.Value) error

UnmarshalRLPWith unmarshals CheckpointData object from the RLP format

func (*CheckpointData) Validate 

func (c *CheckpointData) Validate(parentCheckpoint *CheckpointData,
	currentValidators validator.AccountSet, nextValidators validator.AccountSet,
	exitRootHash types.Hash) error

Validate encapsulates validation logic for checkpoint data (with regards to current and next epoch validators)

func (*CheckpointData) ValidateBasic 

func (c *CheckpointData) ValidateBasic(parentCheckpoint *CheckpointData) error

ValidateBasic encapsulates basic validation logic for checkpoint data. It only checks epoch numbers validity and whether validators hashes are non-empty.

type CheckpointManager 

type CheckpointManager interface {
	PostBlock(req *PostBlockRequest) error
	BuildEventRoot(epoch uint64) (types.Hash, error)
	GenerateExitProof(exitID uint64) (types.Proof, error)
}

type CheckpointStore 

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

Bolt DB schema:

exit events/ |--> (id+epoch+blockNumber) -> *ExitEvent (json marshalled) |--> (exitEventID) -> epochNumber |--> (lastProcessedBlockKey) -> block number

type CommitmentMessageSigned 

type CommitmentMessageSigned struct {
	Message      *contractsapi.StateSyncCommitment
	AggSignature Signature
	PublicKeys   [][]byte
}

CommitmentMessageSigned encapsulates commitment message with aggregated signatures

func (*CommitmentMessageSigned) ContainsStateSync 

func (cm *CommitmentMessageSigned) ContainsStateSync(stateSyncID uint64) bool

ContainsStateSync checks if commitment contains given state sync event

func (*CommitmentMessageSigned) DecodeAbi 

func (cm *CommitmentMessageSigned) DecodeAbi(txData []byte) error

DecodeAbi contains logic for decoding given ABI data

func (*CommitmentMessageSigned) EncodeAbi 

func (cm *CommitmentMessageSigned) EncodeAbi() ([]byte, error)

EncodeAbi contains logic for encoding arbitrary data into ABI format

func (*CommitmentMessageSigned) Hash 

func (cm *CommitmentMessageSigned) Hash() (types.Hash, error)

Hash calculates hash value for commitment object.

func (*CommitmentMessageSigned) VerifyStateSyncProof 

func (cm *CommitmentMessageSigned) VerifyStateSyncProof(proof []types.Hash,
	stateSync *contractsapi.StateSyncedEvent) error

VerifyStateSyncProof validates given state sync proof against merkle tree root hash contained in the CommitmentMessage

type EpochStore 

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

type ExitEvent 

type ExitEvent struct {
	*contractsapi.L2StateSyncedEvent
	// EpochNumber is the epoch number in which exit event was added
	EpochNumber uint64 `abi:"-"`
	// BlockNumber is the block in which exit event was added
	BlockNumber uint64 `abi:"-"`
}

ExitEvent is an event emitted by Exit contract

type Extra 

type Extra struct {
	Validators *validator.ValidatorSetDelta
	Parent     *Signature
	Committed  *Signature
	Checkpoint *CheckpointData
}

Extra defines the structure of the extra field for Istanbul

func GetIbftExtra 

func GetIbftExtra(extraRaw []byte) (*Extra, error)

GetIbftExtra returns the istanbul extra data field from the passed in header

func (*Extra) MarshalRLPTo 

func (i *Extra) MarshalRLPTo(dst []byte) []byte

MarshalRLPTo defines the marshal function wrapper for Extra

func (*Extra) MarshalRLPWith 

func (i *Extra) MarshalRLPWith(ar *fastrlp.Arena) *fastrlp.Value

MarshalRLPWith defines the marshal function implementation for Extra

func (*Extra) UnmarshalRLP 

func (i *Extra) UnmarshalRLP(input []byte) error

UnmarshalRLP defines the unmarshal function wrapper for Extra

func (*Extra) UnmarshalRLPWith 

func (i *Extra) UnmarshalRLPWith(v *fastrlp.Value) error

UnmarshalRLPWith defines the unmarshal implementation for Extra

func (*Extra) ValidateFinalizedData 

func (i *Extra) ValidateFinalizedData(header *types.Header, parent *types.Header, parents []*types.Header,
	chainID uint64, consensusBackend polybftBackend, domain []byte, logger hclog.Logger) error

ValidateFinalizedData contains extra data validations for finalized headers

func (*Extra) ValidateParentSignatures 

func (i *Extra) ValidateParentSignatures(blockNumber uint64, consensusBackend polybftBackend, parents []*types.Header,
	parent *types.Header, parentExtra *Extra, chainID uint64, domain []byte, logger hclog.Logger) error

ValidateParentSignatures validates signatures for parent block

type IBFTConsensusWrapper 

type IBFTConsensusWrapper struct {
	*core.IBFT
}

IBFTConsensusWrapper is a convenience wrapper for the go-ibft package

type MessageSignature 

type MessageSignature struct {
	// Signer of the vote
	From string
	// Signature of the message
	Signature []byte
}

MessageSignature encapsulates sender identifier and its signature

type PendingCommitment 

type PendingCommitment struct {
	*contractsapi.StateSyncCommitment
	MerkleTree *merkle.MerkleTree
	Epoch      uint64
}

PendingCommitment holds merkle trie of bridge transactions accompanied by epoch number

func NewPendingCommitment 

func NewPendingCommitment(epoch uint64, stateSyncEvents []*contractsapi.StateSyncedEvent) (*PendingCommitment, error)

NewPendingCommitment creates a new commitment object

func (*PendingCommitment) Hash 

func (cm *PendingCommitment) Hash() (types.Hash, error)

Hash calculates hash value for commitment object.

type PolyBFTConfig 

type PolyBFTConfig struct {
	// InitialValidatorSet are the genesis validators
	InitialValidatorSet []*validator.GenesisValidator `json:"initialValidatorSet"`

	// Bridge is the rootchain bridge configuration
	Bridge *BridgeConfig `json:"bridge"`

	// EpochSize is size of epoch
	EpochSize uint64 `json:"epochSize"`

	// EpochReward is assigned to validators for blocks sealing
	EpochReward uint64 `json:"epochReward"`

	// SprintSize is size of sprint
	SprintSize uint64 `json:"sprintSize"`

	// BlockTime is target frequency of blocks production
	BlockTime common.Duration `json:"blockTime"`

	// Governance is the initial governance address
	Governance types.Address `json:"governance"`

	// NativeTokenConfig defines name, symbol and decimal count of the native token
	NativeTokenConfig *TokenConfig `json:"nativeTokenConfig"`

	InitialTrieRoot types.Hash `json:"initialTrieRoot"`

	// SupernetID indicates ID of given supernet generated by stake manager contract
	SupernetID int64 `json:"supernetID"`

	// MinValidatorSetSize indicates the minimum size of validator set
	MinValidatorSetSize uint64 `json:"minValidatorSetSize"`

	// MaxValidatorSetSize indicates the maximum size of validator set
	MaxValidatorSetSize uint64 `json:"maxValidatorSetSize"`

	// RewardConfig defines rewards configuration
	RewardConfig *RewardsConfig `json:"rewardConfig"`

	// BlockTimeDrift defines the time slot in which a new block can be created
	BlockTimeDrift uint64 `json:"blockTimeDrift"`
}

PolyBFTConfig is the configuration file for the Polybft consensus protocol.

func GetPolyBFTConfig 

func GetPolyBFTConfig(chainConfig *chain.Chain) (PolyBFTConfig, error)

GetPolyBFTConfig deserializes provided chain config and returns PolyBFTConfig

func LoadPolyBFTConfig 

func LoadPolyBFTConfig(chainConfigFile string) (PolyBFTConfig, error)

LoadPolyBFTConfig loads chain config from provided path and unmarshals PolyBFTConfig

func (*PolyBFTConfig) IsBridgeEnabled 

func (p *PolyBFTConfig) IsBridgeEnabled() bool

type Polybft 

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

func (*Polybft) Close 

func (p *Polybft) Close() error

Close closes the connection

func (*Polybft) FilterExtra 

func (p *Polybft) FilterExtra(extra []byte) ([]byte, error)

GetBridgeProvider is an implementation of Consensus interface Filters extra data to not contain Committed field

func (*Polybft) GetBlockCreator 

func (p *Polybft) GetBlockCreator(h *types.Header) (types.Address, error)

GetBlockCreator retrieves the block creator (or signer) given the block header

func (*Polybft) GetBridgeProvider 

func (p *Polybft) GetBridgeProvider() consensus.BridgeDataProvider

GetBridgeProvider is an implementation of Consensus interface Returns an instance of BridgeDataProvider

func (*Polybft) GetSyncProgression 

func (p *Polybft) GetSyncProgression() *progress.Progression

GetSyncProgression retrieves the current sync progression, if any

func (*Polybft) GetValidators 

func (p *Polybft) GetValidators(blockNumber uint64, parents []*types.Header) (validator.AccountSet, error)

func (*Polybft) Initialize 

func (p *Polybft) Initialize() error

Initialize initializes the consensus (e.g. setup data)

func (*Polybft) Multicast 

func (p *Polybft) Multicast(msg *ibftProto.Message)

Multicast is implementation of core.Transport interface

func (*Polybft) PreCommitState 

func (p *Polybft) PreCommitState(block *types.Block, _ *state.Transition) error

PreCommitState a hook to be called before finalizing state transition on inserting block

func (*Polybft) ProcessHeaders 

func (p *Polybft) ProcessHeaders(_ []*types.Header) error

ProcessHeaders updates the snapshot based on the verified headers

func (*Polybft) Start 

func (p *Polybft) Start() error

Start starts the consensus and servers

func (*Polybft) VerifyHeader 

func (p *Polybft) VerifyHeader(header *types.Header) error

VerifyHeader implements consensus.Engine and checks whether a header conforms to the consensus rules

type PostBlockRequest 

type PostBlockRequest struct {
	// FullBlock is a reference of the executed block
	FullBlock *types.FullBlock
	// Epoch is the epoch number of the executed block
	Epoch uint64
	// IsEpochEndingBlock indicates if this was the last block of given epoch
	IsEpochEndingBlock bool
}

type PostEpochRequest 

type PostEpochRequest struct {
	// NewEpochID is the id of the new epoch
	NewEpochID uint64

	// FirstBlockOfEpoch is the number of the epoch beginning block
	FirstBlockOfEpoch uint64

	// SystemState is the state of the governance smart contracts
	// after this block
	SystemState SystemState

	// ValidatorSet is the validator set for the new epoch
	ValidatorSet validator.ValidatorSet
}

type PrioritizedValidator 

type PrioritizedValidator struct {
	Metadata         *validator.ValidatorMetadata
	ProposerPriority *big.Int
}

PrioritizedValidator holds ValidatorMetadata together with priority

type ProposerCalculator 

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

func NewProposerCalculator 

func NewProposerCalculator(config *runtimeConfig, logger hclog.Logger) (*ProposerCalculator, error)

NewProposerCalculator creates a new proposer calculator object

func NewProposerCalculatorFromSnapshot 

func NewProposerCalculatorFromSnapshot(pcs *ProposerSnapshot, config *runtimeConfig,
	logger hclog.Logger) *ProposerCalculator

NewProposerCalculator creates a new proposer calculator object

func (*ProposerCalculator) GetSnapshot 

func (pc *ProposerCalculator) GetSnapshot() (*ProposerSnapshot, bool)

Get copy of the proposers' snapshot

func (*ProposerCalculator) PostBlock 

func (pc *ProposerCalculator) PostBlock(req *PostBlockRequest) error

PostBlock is called on every insert of finalized block (either from consensus or syncer) It will update priorities and save the updated snapshot to db

type ProposerSnapshot 

type ProposerSnapshot struct {
	Height     uint64
	Round      uint64
	Proposer   *PrioritizedValidator
	Validators []*PrioritizedValidator
}

ProposerSnapshot represents snapshot of one proposer calculation

func NewProposerSnapshot 

func NewProposerSnapshot(height uint64, validators []*validator.ValidatorMetadata) *ProposerSnapshot

NewProposerSnapshot creates ProposerSnapshot with height and validators with all priorities set to zero

func NewProposerSnapshotFromState 

func NewProposerSnapshotFromState(config *runtimeConfig) (*ProposerSnapshot, error)

NewProposerSnapshotFromState create ProposerSnapshot from state if possible or from genesis block

func (*ProposerSnapshot) CalcProposer 

func (pcs *ProposerSnapshot) CalcProposer(round, height uint64) (types.Address, error)

CalcProposer calculates next proposer

func (*ProposerSnapshot) Copy 

func (pcs *ProposerSnapshot) Copy() *ProposerSnapshot

Copy Returns copy of current ProposerSnapshot object

func (*ProposerSnapshot) GetLatestProposer 

func (pcs *ProposerSnapshot) GetLatestProposer(round, height uint64) (types.Address, error)

GetLatestProposer returns latest calculated proposer if any

func (ProposerSnapshot) GetTotalVotingPower 

func (pcs ProposerSnapshot) GetTotalVotingPower() *big.Int

GetTotalVotingPower returns total voting power from all the validators

type ProposerSnapshotStore 

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

type RewardsConfig 

type RewardsConfig struct {
	// TokenAddress is the address of reward token on child chain
	TokenAddress types.Address

	// WalletAddress is the address of reward wallet on child chain
	WalletAddress types.Address

	// WalletAmount is the amount of tokens in reward wallet
	WalletAmount *big.Int
}

func (*RewardsConfig) MarshalJSON 

func (r *RewardsConfig) MarshalJSON() ([]byte, error)

func (*RewardsConfig) UnmarshalJSON 

func (r *RewardsConfig) UnmarshalJSON(data []byte) error

type RootchainConfig 

type RootchainConfig struct {
	JSONRPCAddr string

	StateSenderAddress                   types.Address
	CheckpointManagerAddress             types.Address
	BLSAddress                           types.Address
	BN256G2Address                       types.Address
	ExitHelperAddress                    types.Address
	RootERC20PredicateAddress            types.Address
	ChildMintableERC20PredicateAddress   types.Address
	RootNativeERC20Address               types.Address
	ChildERC20Address                    types.Address
	RootERC721PredicateAddress           types.Address
	ChildMintableERC721PredicateAddress  types.Address
	ChildERC721Address                   types.Address
	RootERC1155PredicateAddress          types.Address
	ChildMintableERC1155PredicateAddress types.Address
	ChildERC1155Address                  types.Address
	CustomSupernetManagerAddress         types.Address
	StakeManagerAddress                  types.Address
	StakeTokenAddress                    types.Address
}

RootchainConfig contains rootchain metadata (such as JSON RPC endpoint and contract addresses)

func (*RootchainConfig) ToBridgeConfig 

func (r *RootchainConfig) ToBridgeConfig() *BridgeConfig

ToBridgeConfig creates BridgeConfig instance

type Runtime 

type Runtime interface {
	IsActiveValidator() bool
}

type Signature 

type Signature struct {
	AggregatedSignature []byte
	Bitmap              []byte
}

Signature represents aggregated signatures of signers accompanied with a bitmap (in order to be able to determine identities of each signer)

func (*Signature) MarshalRLPWith 

func (s *Signature) MarshalRLPWith(ar *fastrlp.Arena) *fastrlp.Value

MarshalRLPWith marshals Signature object into RLP format

func (*Signature) UnmarshalRLPWith 

func (s *Signature) UnmarshalRLPWith(v *fastrlp.Value) error

UnmarshalRLPWith unmarshals Signature object from the RLP format

func (*Signature) Verify 

func (s *Signature) Verify(blockNumber uint64, validators validator.AccountSet,
	hash types.Hash, domain []byte, logger hclog.Logger) error

Verify is used to verify aggregated signature based on current validator set, message hash and domain

type StakeManager 

type StakeManager interface {
	PostBlock(req *PostBlockRequest) error
	PostEpoch(req *PostEpochRequest) error
	UpdateValidatorSet(epoch uint64, currentValidatorSet validator.AccountSet) (*validator.ValidatorSetDelta, error)
}

StakeManager interface provides functions for handling stake change of validators and updating validator set based on changed stake

type StakeStore 

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

type State 

type State struct {
	StateSyncStore        *StateSyncStore
	CheckpointStore       *CheckpointStore
	EpochStore            *EpochStore
	ProposerSnapshotStore *ProposerSnapshotStore
	StakeStore            *StakeStore
	// contains filtered or unexported fields
}

State represents a persistence layer which persists consensus data off-chain

type StateSyncManager 

type StateSyncManager interface {
	Init() error
	Close()
	Commitment(blockNumber uint64) (*CommitmentMessageSigned, error)
	GetStateSyncProof(stateSyncID uint64) (types.Proof, error)
	PostBlock(req *PostBlockRequest) error
	PostEpoch(req *PostEpochRequest) error
}

StateSyncManager is an interface that defines functions for state sync workflow

type StateSyncProof 

type StateSyncProof struct {
	Proof     []types.Hash
	StateSync *contractsapi.StateSyncedEvent
}

type StateSyncStore 

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

type SystemState 

type SystemState interface {
	// GetEpoch retrieves current epoch number from the smart contract
	GetEpoch() (uint64, error)
	// GetNextCommittedIndex retrieves next committed bridge state sync index
	GetNextCommittedIndex() (uint64, error)
}

SystemState is an interface to interact with the consensus system contracts in the chain

type SystemStateImpl 

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

SystemStateImpl is implementation of SystemState interface

func NewSystemState 

func NewSystemState(valSetAddr types.Address, stateRcvAddr types.Address, provider contract.Provider) *SystemStateImpl

NewSystemState initializes new instance of systemState which abstracts smart contracts functions

func (*SystemStateImpl) GetEpoch 

func (s *SystemStateImpl) GetEpoch() (uint64, error)

GetEpoch retrieves current epoch number from the smart contract

func (*SystemStateImpl) GetNextCommittedIndex 

func (s *SystemStateImpl) GetNextCommittedIndex() (uint64, error)

GetNextCommittedIndex retrieves next committed bridge state sync index

type TokenConfig 

type TokenConfig struct {
	Name       string        `json:"name"`
	Symbol     string        `json:"symbol"`
	Decimals   uint8         `json:"decimals"`
	IsMintable bool          `json:"isMintable"`
	Owner      types.Address `json:"owner"`
}

TokenConfig is the configuration of native token used by edge network

type TransportMessage 

type TransportMessage struct {
	// Hash is encoded data
	Hash []byte
	// Message signature
	Signature []byte
	// From is the address of the message signer
	From string
	// Number of epoch
	EpochNumber uint64
}

TransportMessage represents the payload which is gossiped across the network

type ValidatorInfo 

type ValidatorInfo struct {
	Address             ethgo.Address `json:"address"`
	Stake               *big.Int      `json:"stake"`
	WithdrawableRewards *big.Int      `json:"withdrawableRewards"`
	IsActive            bool          `json:"isActive"`
	IsWhitelisted       bool          `json:"isWhitelisted"`
}

ValidatorInfo is data transfer object which holds validator information, provided by smart contract

Source Files

View all Source files

Directories

Path Synopsis
Code generated by scapi/gen.
 Code generated by scapi/gen.
artifact
artifacts-gen
bindings-gen

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.