Documentation
¶
Overview ¶
Package alien implements the delegated-proof-of-stake consensus engine.
Index ¶
- Variables
- type API
- type Confirmation
- type DPos
- func (a *DPos) APIs(chain consensus.ChainReader) []rpc.API
- func (a *DPos) Author(header *types.Header) (common.Address, error)
- func (a *DPos) Authorize(signer common.Address, signFn SignerFn)
- func (a *DPos) CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Header) *big.Int
- func (a *DPos) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, ...) (*types.Block, error)
- func (a *DPos) Prepare(chain consensus.ChainReader, header *types.Header) error
- func (a *DPos) Seal(chain consensus.ChainReader, block *types.Block, stop <-chan struct{}) (*types.Block, error)
- func (a *DPos) VerifyHeader(chain consensus.ChainReader, header *types.Header, seal bool) error
- func (a *DPos) VerifyHeaders(chain consensus.ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error)
- func (a *DPos) VerifySeal(chain consensus.ChainReader, header *types.Header) error
- func (a *DPos) VerifyUncles(chain consensus.ChainReader, block *types.Block) error
- type Declare
- type HeaderExtra
- type Proposal
- type SignerFn
- type SignerItem
- type SignerSlice
- type Snapshot
- type TallyItem
- type TallySlice
- type Vote
Constants ¶
This section is empty.
Variables ¶
var ( // ErrInvalidTimestamp is returned if the timestamp of a block is lower than // the previous block's timestamp + the minimum block period. ErrInvalidTimestamp = errors.New("invalid timestamp") )
Various error messages to mark blocks invalid. These should be private to prevent engine specific errors from being referenced in the remainder of the codebase, inherently breaking if the engine is swapped out. Please put common error types into the consensus package.
var (
SignerBlockReward = big.NewInt(5e+18) // Block reward in wei for successfully mining a block first year
)
Alien delegated-proof-of-stake protocol constants.
Functions ¶
This section is empty.
Types ¶
type API ¶
type API struct {
// contains filtered or unexported fields
}
API is a user facing RPC API to allow controlling the signer and voting mechanisms of the delegated-proof-of-stake scheme.
func (*API) GetSnapshot ¶
func (api *API) GetSnapshot(number *rpc.BlockNumber) (*Snapshot, error)
GetSnapshot retrieves the state snapshot at a given block.
func (*API) GetSnapshotAtHash ¶
GetSnapshotAtHash retrieves the state snapshot at a given block.
type Confirmation ¶
Confirmation : confirmation come from custom tx which data like "ufo:1:event:confirm:123" 123 is the block number be confirmed Sender of tx is Signer only if the signer in the SignerQueue for block number 123
type DPos ¶
type DPos struct {
// contains filtered or unexported fields
}
Alien is the delegated-proof-of-stake consensus engine.
func New ¶
func New(config *params.DPosConfig, db ethdb.Database) *DPos
New creates a Alien delegated-proof-of-stake consensus engine with the initial signers set to the ones provided by the user.
func (*DPos) APIs ¶
func (a *DPos) APIs(chain consensus.ChainReader) []rpc.API
APIs implements consensus.Engine, returning the user facing RPC API to allow controlling the signer voting.
func (*DPos) Author ¶
Author implements consensus.Engine, returning the Ethereum address recovered from the signature in the header's extra-data section.
func (*DPos) Authorize ¶
Authorize injects a private key into the consensus engine to mint new blocks with.
func (*DPos) CalcDifficulty ¶
func (a *DPos) CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Header) *big.Int
CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty that a new block should have based on the previous blocks in the chain and the current signer.
func (*DPos) Finalize ¶
func (a *DPos) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error)
Finalize implements consensus.Engine, ensuring no uncles are set, nor block rewards given, and returns the final block.
func (*DPos) Prepare ¶
Prepare implements consensus.Engine, preparing all the consensus fields of the header for running the transactions on top.
func (*DPos) Seal ¶
func (a *DPos) Seal(chain consensus.ChainReader, block *types.Block, stop <-chan struct{}) (*types.Block, error)
Seal implements consensus.Engine, attempting to create a sealed block using the local signing credentials.
func (*DPos) VerifyHeader ¶
VerifyHeader checks whether a header conforms to the consensus rules.
func (*DPos) VerifyHeaders ¶
func (a *DPos) VerifyHeaders(chain consensus.ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error)
VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers. The method returns a quit channel to abort the operations and a results channel to retrieve the async verifications (the order is that of the input slice).
func (*DPos) VerifySeal ¶
VerifySeal implements consensus.Engine, checking whether the signature contained in the header satisfies the consensus protocol requirements.
func (*DPos) VerifyUncles ¶
VerifyUncles implements consensus.Engine, always returning an error for any uncles as this consensus mechanism doesn't permit uncles.
type Declare ¶
Declare : declare come from custom tx which data like "ufo:1:event:declare:hash:yes" proposal only come from the current candidates hash is the hash of proposal tx
type HeaderExtra ¶
type HeaderExtra struct {
CurrentBlockConfirmations []Confirmation
CurrentBlockVotes []Vote
CurrentBlockProposals []Proposal
CurrentBlockDeclares []Declare
ModifyPredecessorVotes []Vote
LoopStartTime uint64
SignerQueue []common.Address
SignerMissing []common.Address
ConfirmedBlockNumber uint64
}
HeaderExtra is the struct of info in header.Extra[extraVanity:len(header.extra)-extraSeal]
type Proposal ¶
type Proposal struct {
Hash common.Hash // tx hash
ValidationLoopCnt uint64 // validation block number length of this proposal from the received block number
ImplementNumber *big.Int // block number to implement modification in this proposal
DecisionType uint64 // success if condition fill / success if condition fill and block number reach ValidationLoopCnt
ProposalType uint64 // type of proposal 1 - add candidate 2 - remove candidate ...
Proposer common.Address //
Candidate common.Address
MinerRewardPerThousand uint64
Enable bool // Result of proposal
Declares []*Declare // Declare this proposal received
ReceivedNumber *big.Int // block number of proposal received
}
Proposal : proposal come from custom tx which data like "ufo:1:event:proposal:candidate:add:address" or "ufo:1:event:proposal:percentage:60" proposal only come from the current candidates not only candidate add/remove , current signer can proposal for params modify like percentage of reward distribution ...
type SignerFn ¶
SignerFn is a signer callback function to request a hash to be signed by a backing account.
type SignerItem ¶
type SignerItem struct {
// contains filtered or unexported fields
}
type SignerSlice ¶
type SignerSlice []SignerItem
func (SignerSlice) Len ¶
func (s SignerSlice) Len() int
func (SignerSlice) Less ¶
func (s SignerSlice) Less(i, j int) bool
func (SignerSlice) Swap ¶
func (s SignerSlice) Swap(i, j int)
type Snapshot ¶
type Snapshot struct {
LCRS uint64 // Loop count to recreate signers from top tally
Number uint64 `json:"number"` // Block number where the snapshot was created
ConfirmedNumber uint64 `json:"confirmedNumber"` // Block number confirmed when the snapshot was created
Hash common.Hash `json:"hash"` // Block hash where the snapshot was created
HistoryHash []common.Hash `json:"historyHash"` // Block hash list for two recent loop
Signers []*common.Address `json:"signers"` // Signers queue in current header
Votes map[common.Address]*Vote `json:"votes"` // All validate votes from genesis block
Tally map[common.Address]*big.Int `json:"tally"` // Stake for each candidate address
Voters map[common.Address]*big.Int `json:"voters"` // Block number for each voter address
Candidates map[common.Address]uint64 `json:"candidates"` // Candidates for Signers (0- adding procedure 1- normal 2- removing procedure)
Punished map[common.Address]uint64 `json:"punished"` // The signer be punished count cause of missing seal
Confirmations map[uint64][]*common.Address `json:"confirms"` // The signer confirm given block number
Proposals map[common.Hash]*Proposal `json:"proposals"` // The Proposals going or success (failed proposal will be removed)
HeaderTime uint64 `json:"headerTime"` // Time of the current header
LoopStartTime uint64 `json:"loopStartTime"` // Start Time of the current loop
// contains filtered or unexported fields
}
Snapshot is the state of the authorization voting at a given point in time.
type TallySlice ¶
type TallySlice []TallyItem
func (TallySlice) Len ¶
func (s TallySlice) Len() int
func (TallySlice) Less ¶
func (s TallySlice) Less(i, j int) bool
func (TallySlice) Swap ¶
func (s TallySlice) Swap(i, j int)