apos

package
v0.1.3 Latest Latest
Warning

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

 Go to latest Published: Jan 16, 2024 License: GPL-3.0 Imports: 37 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func APosProto 

func APosProto(header block.IHeader) []byte

func AccumulateRewards 

func AccumulateRewards(r *Reward, number *uint256.Int, chain consensus.ChainHeaderReader) (map[types.Address]*uint256.Int, map[types.Address]*uint256.Int, error)

func New 

func New(config *params.APosConfig, db kv.RwDB, chainConfig *params.ChainConfig) consensus.Engine

New creates a APos proof-of-authority consensus engine with the initial signers set to the ones provided by the user.

func NewFaker 

func NewFaker() consensus.Engine

func SealHash 

func SealHash(header block.IHeader) (hash types.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 jsonrpc API to allow controlling the signer and voting mechanisms of the proof-of-authority scheme.

func (*API) Discard 

func (api *API) Discard(address common.Address)

Discard drops a currently running proposal, stopping the signer from casting further votes (either for or against).

func (*API) GetAccountRewardUnpaid 

func (api *API) GetAccountRewardUnpaid(address types.Address) (val *uint256.Int, err error)

func (*API) GetBlockRewards 

func (api *API) GetBlockRewards(blockNr jsonrpc.BlockNumberOrHash) (resp []*block.Reward, err error)

GetRewards todo:needs check

func (*API) GetDepositInfo 

func (api *API) GetDepositInfo(address common.Address) (*deposit.Info, error)

GetRewards

func (*API) GetMinedBlock 

func (api *API) GetMinedBlock(address common.Address, from jsonrpc.BlockNumberOrHash, wantCount uint64) (*MinedBlockResponse, error)

GetTasks

func (*API) GetRewards 

func (api *API) GetRewards(address common.Address, from jsonrpc.BlockNumberOrHash, to jsonrpc.BlockNumberOrHash) (resp *RewardResponse, err error)

GetRewards

func (*API) GetSigner 

func (api *API) GetSigner(rlpOrBlockNr *blockNumberOrHashOrRLP) (types.Address, error)

GetSigner returns the signer for a specific Apos block. Can be called with either a blocknumber, blockhash or an rlp encoded blob. The RLP encoded blob can either be a block or a header.

func (*API) GetSigners 

func (api *API) GetSigners(number *jsonrpc.BlockNumber) ([]common.Address, error)

GetSigners retrieves the list of authorized signers at the specified block.

func (*API) GetSignersAtHash 

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

GetSignersAtHash retrieves the list of authorized signers at the specified block.

func (*API) GetSnapshot 

func (api *API) GetSnapshot(number *jsonrpc.BlockNumber) (*Snapshot, error)

GetSnapshot retrieves the state snapshot at a given block.

func (*API) GetSnapshotAtHash 

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

GetSnapshotAtHash retrieves the state snapshot at a given block.

func (*API) Proposals 

func (api *API) Proposals() map[common.Address]bool

Proposals returns the current proposals the node tries to uphold and vote on.

func (*API) Propose 

func (api *API) Propose(address common.Address, auth bool)

Propose injects a new authorization proposal that the signer will attempt to push through.

func (*API) Status 

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

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

func (*API) VerifiedBlock 

func (api *API) VerifiedBlock(address common.Address, from jsonrpc.BlockNumberOrHash, wantCount uint64, to *jsonrpc.BlockNumber) (*VerifiedBlockResponse, error)

VerifiedBlock

type APos 

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

APos is the proof-of-authority consensus engine proposed to support the Ethereum testnet following the Ropsten attacks.

func (*APos) APIs 

func (c *APos) APIs(chain consensus.ChainReader) []jsonrpc.API

APIs implements consensus.Engine, returning the user facing RPC API to allow controlling the signer voting.

func (*APos) Author 

func (c *APos) Author(header block.IHeader) (types.Address, error)

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

func (*APos) Authorize 

func (c *APos) Authorize(signer types.Address, signFn SignerFn)

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

func (*APos) CalcDifficulty 

func (c *APos) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent block.IHeader) *uint256.Int

CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty that a new block should have: * DIFF_NOTURN(2) if BLOCK_NUMBER % SIGNER_COUNT != SIGNER_INDEX * DIFF_INTURN(1) if BLOCK_NUMBER % SIGNER_COUNT == SIGNER_INDEX

func (*APos) Close 

func (c *APos) Close() error

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

func (*APos) CountDepositor 

func (c *APos) CountDepositor() uint64

func (*APos) Finalize 

func (c *APos) Finalize(chain consensus.ChainHeaderReader, header block.IHeader, state *state.IntraBlockState, txs []*transaction.Transaction, uncles []block.IHeader) ([]*block.Reward, map[types.Address]*uint256.Int, error)

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

func (*APos) FinalizeAndAssemble 

func (c *APos) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header block.IHeader, state *state.IntraBlockState, txs []*transaction.Transaction, uncles []block.IHeader, receipts []*block.Receipt) (block.IBlock, []*block.Reward, map[types.Address]*uint256.Int, error)

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

func (*APos) IsServiceTransaction 

func (c *APos) IsServiceTransaction(sender types.Address, syscall consensus.SystemCall) bool

func (*APos) Prepare 

func (c *APos) Prepare(chain consensus.ChainHeaderReader, header block.IHeader) error

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

func (*APos) Rewards 

func (c *APos) Rewards(tx kv.RwTx, header block.IHeader, state *state.IntraBlockState, setRewards bool) ([]*block.Reward, error)

func (*APos) Seal 

func (c *APos) Seal(chain consensus.ChainHeaderReader, b block.IBlock, results chan<- block.IBlock, stop <-chan struct{}) error

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

func (*APos) SealHash 

func (c *APos) SealHash(header block.IHeader) types.Hash

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

func (*APos) SetBlockChain 

func (c *APos) SetBlockChain(bc amcCommon.IBlockChain)

func (*APos) Type 

func (c *APos) Type() params.ConsensusType

func (*APos) VerifyHeader 

func (c *APos) VerifyHeader(chain consensus.ChainHeaderReader, header block.IHeader, seal bool) error

VerifyHeader checks whether a header conforms to the consensus rules.

func (*APos) VerifyHeaders 

func (c *APos) VerifyHeaders(chain consensus.ChainHeaderReader, headers []block.IHeader, 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 (*APos) VerifyUncles 

func (c *APos) VerifyUncles(chain consensus.ChainReader, block block.IBlock) error

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

type AccountReward 

type AccountReward struct {
	Account types.Address
	Number  *uint256.Int
	Value   *uint256.Int
}

type AccountRewards 

type AccountRewards []*AccountReward

func (AccountRewards) Len 

func (r AccountRewards) Len() int

func (AccountRewards) Less 

func (r AccountRewards) Less(i, j int) bool

func (AccountRewards) Swap 

func (r AccountRewards) Swap(i, j int)

type Faker 

type Faker struct{}

func (Faker) APIs 

func (f Faker) APIs(chain consensus.ChainReader) []jsonrpc.API

func (Faker) Author 

func (f Faker) Author(header block.IHeader) (types.Address, error)

func (Faker) CalcDifficulty 

func (f Faker) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent block.IHeader) *uint256.Int

func (Faker) Close 

func (f Faker) Close() error

func (Faker) Finalize 

func (f Faker) Finalize(chain consensus.ChainHeaderReader, header block.IHeader, state *state.IntraBlockState, txs []*transaction.Transaction, uncles []block.IHeader) ([]*block.Reward, map[types.Address]*uint256.Int, error)

func (Faker) FinalizeAndAssemble 

func (f Faker) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header block.IHeader, state *state.IntraBlockState, txs []*transaction.Transaction, uncles []block.IHeader, receipts []*block.Receipt) (block.IBlock, []*block.Reward, map[types.Address]*uint256.Int, error)

func (Faker) IsServiceTransaction 

func (f Faker) IsServiceTransaction(sender types.Address, syscall consensus.SystemCall) bool

func (Faker) Prepare 

func (f Faker) Prepare(chain consensus.ChainHeaderReader, header block.IHeader) error

func (Faker) Rewards 

func (f Faker) Rewards(tx kv.RwTx, header block.IHeader, state *state.IntraBlockState, setRewards bool) ([]*block.Reward, error)

func (Faker) Seal 

func (f Faker) Seal(chain consensus.ChainHeaderReader, block block.IBlock, results chan<- block.IBlock, stop <-chan struct{}) error

func (Faker) SealHash 

func (f Faker) SealHash(header block.IHeader) types.Hash

func (Faker) Type 

func (f Faker) Type() params.ConsensusType

func (Faker) VerifyHeader 

func (f Faker) VerifyHeader(chain consensus.ChainHeaderReader, header block.IHeader, seal bool) error

func (Faker) VerifyHeaders 

func (f Faker) VerifyHeaders(chain consensus.ChainHeaderReader, headers []block.IHeader, seals []bool) (chan<- struct{}, <-chan error)

func (Faker) VerifyUncles 

func (f Faker) VerifyUncles(chain consensus.ChainReader, block block.IBlock) error

type MinedBlock 

type MinedBlock struct {
	BlockNumber *uint256.Int `json:"blockNumber"`
	Timestamp   uint64       `json:"timestamp"`
	Reward      *uint256.Int `json:"reward"`
}

type MinedBlockResponse 

type MinedBlockResponse struct {
	MinedBlocks        []MinedBlock `json:"minedBlocks"`
	CurrentBlockNumber *uint256.Int `json:"currentBlockNumber"`
}

type Reward 

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

func (*Reward) GetRewards 

func (r *Reward) GetRewards(addr types.Address, from *uint256.Int, to *uint256.Int, getBlockByNumber func(*uint256.Int) (block.IBlock, error)) (*RewardResponse, error)

func (*Reward) SetRewards 

func (r *Reward) SetRewards(tx kv.RwTx, number *uint256.Int, setRewards bool) (AccountRewards, error)

type RewardResponse 

type RewardResponse struct {
	Address types.Address        `json:"address" yaml:"address"`
	Data    RewardResponseValues `json:"data" yaml:"data"`
	Total   *uint256.Int         `json:"total" yaml:"total"`
}

type RewardResponseValue 

type RewardResponseValue struct {
	Value       uint256.Int    `json:"value" yaml:"value"`
	Timestamp   hexutil.Uint64 `json:"timestamp" yaml:"timestamp"`
	BlockNumber string         `json:"blockNumber" yaml:"blockNumber"`
}

type RewardResponseValues 

type RewardResponseValues []*RewardResponseValue

func (RewardResponseValues) Len 

func (r RewardResponseValues) Len() int

func (RewardResponseValues) Less 

func (r RewardResponseValues) Less(i, j int) bool

func (RewardResponseValues) Swap 

func (r RewardResponseValues) Swap(i, j int)

type SignerFn 

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

SignerFn hashes and signs the data to be signed by a backing account. todo types.address to account

type Snapshot 

type Snapshot struct {
	Number  uint64                     `json:"number"`  // Block number where the snapshot was created
	Hash    types.Hash                 `json:"hash"`    // Block hash where the snapshot was created
	Signers map[types.Address]struct{} `json:"signers"` // Set of authorized signers at this moment
	Recents map[uint64]types.Address   `json:"recents"` // Set of recent signers for spam protections
	Votes   []*Vote                    `json:"votes"`   // List of votes cast in chronological order
	Tally   map[types.Address]Tally    `json:"tally"`   // Current vote tally to avoid recalculating
	// contains filtered or unexported fields
}

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

type Tally 

type Tally struct {
	Authorize bool `json:"authorize"` // Whether the vote is about authorizing or kicking someone
	Votes     int  `json:"votes"`     // Number of votes until now wanting to pass the proposal
}

Tally is a simple vote tally to keep the current score of votes. Votes that go against the proposal aren't counted since it's equivalent to not voting.

type VerifiedBlockResponse 

type VerifiedBlockResponse struct {
	MinedBlocks []MinedBlock `json:"minedBlocks"`
	Total       *uint256.Int `json:"totalBlocks"`
}

type Vote 

type Vote struct {
	Signer    types.Address `json:"signer"`    // Authorized signer that cast this vote
	Block     uint64        `json:"block"`     // Block number the vote was cast in (expire old votes)
	Address   types.Address `json:"address"`   // Account being voted on to change its authorization
	Authorize bool          `json:"authorize"` // Whether to authorize or deauthorize the voted account
}

Vote represents a single vote that an authorized signer made to modify the list of authorizations.

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.