dpos

package
v1.0.6 Latest Latest
Warning

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

 Go to latest Published: Jun 12, 2023 License: GPL-3.0 Imports: 23 Imported by: 0

Documentation

Overview

Package dpos implements the delegated-proof-of-stake consensus engine.

Index

Constants

This section is empty.

Variables

View Source 
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")

	// ErrUnauthorized is returned if a header is signed by a non-authorized entity.
	ErrUnauthorized = errors.New("unauthorized")
)

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.

Functions

func DposRLP 

func DposRLP(header *types.Header) []byte

func SealHash 

func SealHash(header *types.Header) (hash common.Hash)

SealHash returns the hash of a block prior to it being sealed.

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 

func (api *API) GetSnapshotAtHash(hash common.Hash) (*Snapshot, error)

GetSnapshotAtHash retrieves the state snapshot at a given block.

func (*API) GetSnapshotAtNumber 

func (api *API) GetSnapshotAtNumber(number uint64) (*Snapshot, error)

GetSnapshotAtNumber retrieves the state snapshot at a given block.

type Confirmation 

type Confirmation struct {
	Signer      common.Address
	BlockNumber *big.Int
}

Confirmation : confirmation come from custom tx which data like "dpos: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
}

DPoS is the delegated-proof-of-stake consensus engine.

func New 

func New(config *params.DPoSConfig, db ethdb.Database) *DPoS

New creates a DPoS delegated-proof-of-stake consensus engine with the initial signers set to the ones provided by the user.

func (*DPoS) APIs 

func (d *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) ApplyGenesis 

func (d *DPoS) ApplyGenesis(chain consensus.ChainReader, genesisHash common.Hash) error

ApplyGenesis

func (*DPoS) Author 

func (d *DPoS) Author(header *types.Header) (common.Address, error)

Author implements consensus.Engine, returning the Ethereum address recovered from the signature in the header's extra-data section.

func (*DPoS) Authorize 

func (d *DPoS) Authorize(signer common.Address, signFn SignerFn)

Authorize injects a private key into the consensus engine to mint new blocks with.

func (*DPoS) CalcDifficulty 

func (d *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) Close 

func (d *DPoS) Close() error

func (*DPoS) Finalize 

func (d *DPoS) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) error

Finalize implements consensus.Engine, ensuring no uncles are set, nor block rewards given, and returns the final block.

func (*DPoS) FinalizeAndAssemble 

func (d *DPoS) FinalizeAndAssemble(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction,
	uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error)

func (*DPoS) Prepare 

func (d *DPoS) Prepare(chain consensus.ChainReader, header *types.Header) error

Prepare implements consensus.Engine, preparing all the consensus fields of the header for running the transactions on top.

func (*DPoS) Seal 

func (d *DPoS) Seal(chain consensus.ChainReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error

Seal implements consensus.Engine, attempting to create a sealed block using the local signing credentials.

func (*DPoS) SealHash 

func (d *DPoS) SealHash(header *types.Header) common.Hash

func (*DPoS) VerifyHeader 

func (d *DPoS) VerifyHeader(chain consensus.ChainReader, header *types.Header, seal bool) error

VerifyHeader checks whether a header conforms to the consensus rules.

func (*DPoS) VerifyHeaders 

func (d *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 

func (d *DPoS) VerifySeal(chain consensus.ChainReader, header *types.Header) error

VerifySeal implements consensus.Engine, checking whether the signature contained in the header satisfies the consensus protocol requirements.

func (*DPoS) VerifyUncles 

func (d *DPoS) VerifyUncles(chain consensus.ChainReader, block *types.Block) error

VerifyUncles implements consensus.Engine, always returning an error for any uncles as this consensus mechanism doesn't permit uncles.

type Declare 

type Declare struct {
	ProposalHash common.Hash
	Declarer     common.Address
	Decision     bool
}

Declare : declare come from custom tx which data like "dpos: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    []PredecessorVoter // modify when voter's balance changed
	LoopStartTime             uint64
	SignerQueue               []common.Address
	SignerMissing             []common.Address
	ConfirmedBlockNumber      uint64
}

HeaderExtra is the struct of info in header.Extra[extraVanity:len(header.extra)-extraSeal] HeaderExtra is the current struct DPoS data save in header.Extra[32:len(header.extra)-65]. The header.Extra[:32] keep the geth and go version, and header.Extra[len(header.extra)-65:] keep the signature of miner

type PredecessorVoter 

type PredecessorVoter struct {
	Voter common.Address
	Stake *big.Int
}

type Proposal 

type Proposal struct {
	Hash                   common.Hash    // tx hash
	ReceivedNumber         *big.Int       // block number of proposal received
	CurrentDeposit         *big.Int       // received deposit for this proposal
	ValidationLoopCnt      uint64         // validation block number length of this proposal from the received block number
	ProposalType           uint64         // type of proposal 1 - add candidate 2 - remove candidate ...
	Proposer               common.Address // proposer
	TargetAddress          common.Address // candidate need to add/remove if candidateNeedPD == true
	MinerRewardPerThousand uint64         // reward of chain miner
	Declares               []*Declare     // Declare this proposal received (always empty in block header)
	MinVoterBalance        uint64         // value of minVoterBalance , need to mul big.Int(1e+18)
	ProposalDeposit        uint64         // The deposit need to be frozen during before the proposal get final conclusion. (TTC)
}

Proposal : proposal come from custom tx which data like "dpos:1:event:proposal:candidate:add:address" or "dpos: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 RefundGas 

type RefundGas map[common.Address]*big.Int

RefundGas : refund gas to tx sender

type RefundHash 

type RefundHash map[common.Hash]RefundPair

RefundHash :

type RefundPair 

type RefundPair struct {
	Sender   common.Address
	GasPrice *big.Int
}

RefundPair :

type SignTxFn 

type SignTxFn func(accounts.Account, *types.Transaction, *big.Int) (*types.Transaction, error)

SignTxFn is a signTx

type SignerFn 

type SignerFn func(account accounts.Account, mimeType string, data []byte) ([]byte, error)

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

	Period          uint64                                 `json:"period"`          // Period of seal each block
	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
	ProposalRefund  map[uint64]map[common.Address]*big.Int `json:"proposalRefund"`  // Refund proposal deposit
	MinerReward     uint64                                 `json:"minerReward"`     // miner reward per thousand
	MinVB           *big.Int                               `json:"minVoterBalance"` // min voter balance
	// contains filtered or unexported fields
}

Snapshot is the state of the authorization voting at a given point in time.

type TallyItem 

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

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)

type Vote 

type Vote struct {
	Voter     common.Address
	Candidate common.Address
	Stake     *big.Int
}

Vote : vote come from custom tx which data like "dpos:1:event:vote" Sender of tx is Voter, the tx.to is Candidate Stake is the balance of Voter when create this vote

Source Files

View all Source files

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.