dpos

package
v1.0.2 Latest Latest
Warning

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

 Go to latest Published: Apr 9, 2025 License: GPL-3.0 Imports: 45 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	Running uint8 = iota
	Punish
	Pause
	Stop
)
View Source 
const (
	NotStart uint8 = iota
	Create
	Success
	Fail
)
View Source 
const (
	DirectionFrom blacklistDirection = iota
	DirectionTo
	DirectionBoth
)

Variables

View Source 
var (

	//ProviderFactoryAddr = common.Address{}
	StakeThreshold = new(big.Int).Mul(big.NewInt(1000), big.NewInt(params.Ether))
	LuckyRate      = big.NewInt(6)
	LuckyPorRate   = big.NewInt(4)
	MaxStorage     = big.NewInt(1)
	MaxMemory      = big.NewInt(4)
)
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")
)

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 CalcDifficulty 

func CalcDifficulty(snap *Snapshot, signer common.Address) *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 DposRLP 

func DposRLP(header *types.Header, chainId *big.Int) []byte

DposRLP returns the rlp bytes which needs to be signed for the dpos sealing. The RLP to sign consists of the entire header apart from the 65 byte signature contained at the end of the extra data.

Note, the method requires the extra data to be at least 65 bytes, otherwise it panics. This is done to avoid accidentally using both forms (signature present or not), which could be abused to produce different hashes for the same header.

func FindAncientHeader 

func FindAncientHeader(header *types.Header, ite uint64, chain consensus.ChainHeaderReader, candidateParents []*types.Header) *types.Header

func ParseValidators 

func ParseValidators(validatorsBytes []byte) ([]common.Address, error)

func SealHash 

func SealHash(header *types.Header, chainId *big.Int) (hash common.Hash)

=========================== utility function ========================== 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 validator and voting mechanisms of the proof-of-authority 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) GetValidators 

func (api *API) GetValidators(number *rpc.BlockNumber) ([]common.Address, error)

GetValidators retrieves the list of validators at the specified block.

func (*API) GetValidatorsAtHash 

func (api *API) GetValidatorsAtHash(hash common.Hash) ([]common.Address, error)

GetValidatorsAtHash retrieves the list of authorized validators at the specified block.

func (*API) Status 

func (api *API) Status() (*status, error)

Status returns the status of the last N blocks, - the number of active validators, - the number of validators, - the percentage of in-turn blocks

type Dpos 

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

Dpos is the consensus engine of BSC

func New 

func New(
	chainConfig *params.ChainConfig,
	db ethdb.Database,
	ethAPI *ethapi.PublicBlockChainAPI,
	genesisHash common.Hash,
) *Dpos

New creates a Dpos consensus engine.

func (*Dpos) APIs 

func (p *Dpos) APIs(chain consensus.ChainHeaderReader) []rpc.API

APIs implements consensus.Engine, returning the user facing RPC API to query snapshot.

func (*Dpos) Author 

func (p *Dpos) Author(header *types.Header) (common.Address, error)

Author implements consensus.Engine, returning the SystemAddress

func (*Dpos) Authorize 

func (p *Dpos) Authorize(val common.Address, signFn SignerFn, signTxFn SignerTxFn) bool
func (p *Dpos) decreaseMissedBlocksCounter(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB) error {
	// method
	method := "decreaseMissedBlocksCounter"
	data, err := p.abi[systemcontract.PunishV1ContractName].Pack(method, new(big.Int).SetUint64(p.config.Epoch))
	if err != nil {
		log.Error("Can't pack data for decreaseMissedBlocksCounter", "error", err)
		return err
	}

	// call contract
	nonce := state.GetNonce(header.Coinbase)
	msg := types.NewMessage(header.Coinbase, systemcontract.GetPunishAddr(header.Number, p.chainConfig), nonce, new(big.Int), math.MaxUint64, new(big.Int), data, nil, true)
	if _, err := vmcaller.ExecuteMsg(msg, state, header, newChainContext(chain, p), p.chainConfig); err != nil {
		log.Error("Can't decrease missed blocks counter for validator", "err", err)
		return err
	}

	return nil
}

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

func (*Dpos) CalcDifficulty 

func (p *Dpos) CalcDifficulty(chain consensus.ChainHeaderReader, 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) CanCreate 

func (p *Dpos) CanCreate(state consensus.StateReader, addr common.Address, height *big.Int) bool

CanCreate determines where a given address can create a new contract.

This will queries the system Developers contract, by DIRECTLY to get the target slot value of the contract, it means that it's strongly relative to the layout of the Developers contract's state variables

func (*Dpos) CheckHasInTurn 

func (p *Dpos) CheckHasInTurn(chain consensus.ChainHeaderReader, coinbases []common.Address, header *types.Header) common.Address

func (*Dpos) Close 

func (p *Dpos) Close() error

Close implements consensus.Engine. It's a noop for dpos as there are no background threads.

func (*Dpos) CreateChallengeFinish 

func (p *Dpos) CreateChallengeFinish(validator common.Address, provider common.Address, seed uint64, challengeAmount uint64, rootHash *big.Int, challengeState int, nonceDiff uint64, state *state.StateDB, header *types.Header) (*types.Transaction, error)

func (*Dpos) Delay 

func (p *Dpos) Delay(chain consensus.ChainReader, header *types.Header) *time.Duration

func (*Dpos) EnoughDistance 

func (p *Dpos) EnoughDistance(chain consensus.ChainReader, header *types.Header) bool

func (*Dpos) Finalize 

func (p *Dpos) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs *[]*types.Transaction,
	uncles []*types.Header, receipts *[]*types.Receipt, systemTxs *[]*types.Transaction, usedGas *uint64, isSkip bool) error

Finalize implements consensus.Engine, ensuring no uncles are set, nor block rewards given.

func (*Dpos) FinalizeAndAssemble 

func (p *Dpos) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB,
	txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (b *types.Block, rs []*types.Receipt, err error)

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

func (*Dpos) IsLocalBlock 

func (p *Dpos) IsLocalBlock(header *types.Header) bool

func (*Dpos) IsSysTransaction 

func (p *Dpos) IsSysTransaction(tx *types.Transaction, header *types.Header) (bool, error)

IsSysTransaction checks whether a specific transaction is a system transaction.

func (*Dpos) IsSystemContract 

func (p *Dpos) IsSystemContract(to *common.Address) bool

func (*Dpos) IsSystemTransaction 

func (p *Dpos) IsSystemTransaction(tx *types.Transaction, header *types.Header) (bool, error)

func (*Dpos) PreHandle 

func (p *Dpos) PreHandle(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB) error

func (*Dpos) Prepare 

func (p *Dpos) Prepare(chain consensus.ChainHeaderReader, 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 (p *Dpos) Seal(chain consensus.ChainHeaderReader, 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 (p *Dpos) SealHash(header *types.Header) common.Hash

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

func (*Dpos) SetStateFn 

func (p *Dpos) SetStateFn(fn StateFn)

SetStateFn sets the function to get state.

func (*Dpos) SignRecently 

func (p *Dpos) SignRecently(chain consensus.ChainReader, parent *types.Header) (bool, error)

func (*Dpos) SignSeed 

func (p *Dpos) SignSeed(header *types.Header, seed uint64) ([]byte, error)

func (*Dpos) TryCreateChallenge 

func (p *Dpos) TryCreateChallenge(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB) (*types.Transaction, uint64, common.Address, error, int)

func (*Dpos) ValidateTx 

func (p *Dpos) ValidateTx(tx *types.Transaction, header *types.Header, parentState *state.StateDB) error

ValidateTx do a consensus-related validation on the given transaction at the given header and state. the parentState must be the state of the header's parent block.

func (*Dpos) VerifyHeader 

func (p *Dpos) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, seal bool) error

VerifyHeader checks whether a header conforms to the consensus rules.

func (*Dpos) VerifyHeaders 

func (p *Dpos) VerifyHeaders(chain consensus.ChainHeaderReader, 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 (p *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 (p *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 Proposal 

type Proposal struct {
	Id     *big.Int
	Action *big.Int
	From   common.Address
	To     common.Address
	Value  *big.Int
	Data   []byte
}

Proposal is the system governance proposal info.

type ProviderInfos 

type ProviderInfos struct {
	ProviderContract common.Address
	Info             providerInfo
	MarginAmount     *big.Int
	Audits           []common.Address
}

type SignerFn 

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

type SignerTxFn 

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

type Snapshot 

type Snapshot struct {
	Number           uint64                      `json:"number"`             // Block number where the snapshot was created
	Hash             common.Hash                 `json:"hash"`               // Block hash where the snapshot was created
	Validators       map[common.Address]struct{} `json:"validators"`         // Set of authorized validators at this moment
	Recents          map[uint64]common.Address   `json:"recents"`            // Set of recent validators for spam protections
	RecentForkHashes map[uint64]string           `json:"recent_fork_hashes"` // Set of recent forkHash
	// contains filtered or unexported fields
}

Snapshot is the state of the validatorSet at a given point.

type StateFn 

type StateFn func(hash common.Hash) (*state.StateDB, error)

SignerFn is a signer callback function to request a header to be signed by a backing account.

type VoteInfo 

type VoteInfo struct {
	ProviderAddress common.Address `json:"provider_address"`
	VotingPower     *big.Int       `json:"voting_power"`
}

Source Files

View all Source files

Directories

Path Synopsis

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.