Package clique implements the proof-of-authority consensus engine.



    This section is empty.


    This section is empty.


    func CliqueRLP

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

      CliqueRLP returns the rlp bytes which needs to be signed for the proof-of-authority 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 SealHash

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

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


        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 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) GetSigners

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

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

              func (*API) GetSignersAtHash

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

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

                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) 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

                          type Clique

                          type Clique struct {
                          	// contains filtered or unexported fields

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

                            func New

                            func New(config *params.CliqueConfig, db ethdb.Database) *Clique

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

                              func (*Clique) APIs

                              func (c *Clique) APIs(chain consensus.ChainHeaderReader) []rpc.API

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

                                func (*Clique) Author

                                func (c *Clique) 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 (*Clique) Authorize

                                  func (c *Clique) Authorize(signer common.Address, signFn SignerFn)

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

                                    func (*Clique) CalcDifficulty

                                    func (c *Clique) 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: * DIFF_NOTURN(2) if BLOCK_NUMBER % SIGNER_COUNT != SIGNER_INDEX * DIFF_INTURN(1) if BLOCK_NUMBER % SIGNER_COUNT == SIGNER_INDEX

                                      func (*Clique) Close

                                      func (c *Clique) Close() error

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

                                        func (*Clique) Finalize

                                        func (c *Clique) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header)

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

                                          func (*Clique) FinalizeAndAssemble

                                          func (c *Clique) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error)

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

                                            func (*Clique) Prepare

                                            func (c *Clique) 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 (*Clique) Seal

                                              func (c *Clique) 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 (*Clique) SealHash

                                                func (c *Clique) SealHash(header *types.Header) common.Hash

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

                                                  func (*Clique) VerifyHeader

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

                                                    VerifyHeader checks whether a header conforms to the consensus rules.

                                                    func (*Clique) VerifyHeaders

                                                    func (c *Clique) 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 (*Clique) VerifySeal

                                                      func (c *Clique) VerifySeal(chain consensus.ChainHeaderReader, header *types.Header) error

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

                                                        func (*Clique) VerifyUncles

                                                        func (c *Clique) 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 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.

                                                            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
                                                            	Signers map[common.Address]struct{} `json:"signers"` // Set of authorized signers at this moment
                                                            	Recents map[uint64]common.Address   `json:"recents"` // Set of recent signers for spam protections
                                                            	Votes   []*Vote                     `json:"votes"`   // List of votes cast in chronological order
                                                            	Tally   map[common.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 Vote

                                                                type Vote struct {
                                                                	Signer    common.Address `json:"signer"`    // Authorized signer that cast this vote
                                                                	Block     uint64         `json:"block"`     // Block number the vote was cast in (expire old votes)
                                                                	Address   common.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.