123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322 |
- // Copyright 2020 The go-ethereum Authors
- // This file is part of the go-ethereum library.
- //
- // The go-ethereum library is free software: you can redistribute it and/or modify
- // it under the terms of the GNU Lesser General Public License as published by
- // the Free Software Foundation, either version 3 of the License, or
- // (at your option) any later version.
- //
- // The go-ethereum library is distributed in the hope that it will be useful,
- // but WITHOUT ANY WARRANTY; without even the implied warranty of
- // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- // GNU Lesser General Public License for more details.
- //
- // You should have received a copy of the GNU Lesser General Public License
- // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
- // Package catalyst implements the temporary eth1/eth2 RPC integration.
- package catalyst
- import (
- "errors"
- "fmt"
- "math/big"
- "time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/mps"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- chainParams "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/trie"
- )
- // Register adds catalyst APIs to the node.
- func Register(stack *node.Node, backend *eth.Ethereum) error {
- chainconfig := backend.BlockChain().Config()
- if chainconfig.CatalystBlock == nil {
- return errors.New("catalystBlock is not set in genesis config")
- } else if chainconfig.CatalystBlock.Sign() != 0 {
- return errors.New("catalystBlock of genesis config must be zero")
- }
- log.Warn("Catalyst mode enabled")
- stack.RegisterAPIs([]rpc.API{
- {
- Namespace: "consensus",
- Version: "1.0",
- Service: newConsensusAPI(backend),
- Public: true,
- },
- })
- return nil
- }
- type consensusAPI struct {
- eth *eth.Ethereum
- }
- func newConsensusAPI(eth *eth.Ethereum) *consensusAPI {
- return &consensusAPI{eth: eth}
- }
- // blockExecutionEnv gathers all the data required to execute
- // a block, either when assembling it or when inserting it.
- type blockExecutionEnv struct {
- chain *core.BlockChain
- state *state.StateDB
- tcount int
- gasPool *core.GasPool
- header *types.Header
- txs []*types.Transaction
- receipts []*types.Receipt
- // Quorum
- privateStateRepo mps.PrivateStateRepository
- privateState *state.StateDB
- forceNonParty bool
- isInnerPrivateTxn bool
- privateReceipts []*types.Receipt
- }
- func (env *blockExecutionEnv) commitTransaction(tx *types.Transaction, coinbase common.Address) error {
- vmconfig := *env.chain.GetVMConfig()
- receipt, privateReceipt, err := core.ApplyTransaction(env.chain.Config(), env.chain, &coinbase, env.gasPool, env.state, env.privateState, env.header, tx, &env.header.GasUsed, vmconfig, env.forceNonParty, env.privateStateRepo, env.isInnerPrivateTxn)
- if err != nil {
- return err
- }
- env.txs = append(env.txs, tx)
- env.receipts = append(env.receipts, receipt)
- env.privateReceipts = append(env.privateReceipts, privateReceipt)
- return nil
- }
- func (api *consensusAPI) makeEnv(parent *types.Block, header *types.Header) (*blockExecutionEnv, error) {
- state, mpsr, err := api.eth.BlockChain().StateAt(parent.Root())
- if err != nil {
- return nil, err
- }
- privateState, err := mpsr.DefaultState() // TODO merge add PSI?
- if err != nil {
- return nil, err
- }
- env := &blockExecutionEnv{
- chain: api.eth.BlockChain(),
- state: state,
- header: header,
- gasPool: new(core.GasPool).AddGas(header.GasLimit),
- // Quorum
- privateState: privateState,
- }
- return env, nil
- }
- // AssembleBlock creates a new block, inserts it into the chain, and returns the "execution
- // data" required for eth2 clients to process the new block.
- func (api *consensusAPI) AssembleBlock(params assembleBlockParams) (*executableData, error) {
- log.Info("Producing block", "parentHash", params.ParentHash)
- bc := api.eth.BlockChain()
- parent := bc.GetBlockByHash(params.ParentHash)
- if parent == nil {
- log.Warn("Cannot assemble block with parent hash to unknown block", "parentHash", params.ParentHash)
- return nil, fmt.Errorf("cannot assemble block with unknown parent %s", params.ParentHash)
- }
- pool := api.eth.TxPool()
- if parent.Time() >= params.Timestamp {
- return nil, fmt.Errorf("child timestamp lower than parent's: %d >= %d", parent.Time(), params.Timestamp)
- }
- if now := uint64(time.Now().Unix()); params.Timestamp > now+1 {
- wait := time.Duration(params.Timestamp-now) * time.Second
- log.Info("Producing block too far in the future", "wait", common.PrettyDuration(wait))
- time.Sleep(wait)
- }
- pending, err := pool.Pending()
- if err != nil {
- return nil, err
- }
- coinbase, err := api.eth.Etherbase()
- if err != nil {
- return nil, err
- }
- num := parent.Number()
- header := &types.Header{
- ParentHash: parent.Hash(),
- Number: num.Add(num, common.Big1),
- Coinbase: coinbase,
- GasLimit: parent.GasLimit(), // Keep the gas limit constant in this prototype
- Extra: []byte{},
- Time: params.Timestamp,
- }
- err = api.eth.Engine().Prepare(bc, header)
- if err != nil {
- return nil, err
- }
- env, err := api.makeEnv(parent, header)
- if err != nil {
- return nil, err
- }
- var (
- signer = types.MakeSigner(bc.Config(), header.Number)
- txHeap = types.NewTransactionsByPriceAndNonce(signer, pending)
- transactions []*types.Transaction
- )
- for {
- if env.gasPool.Gas() < chainParams.TxGas {
- log.Trace("Not enough gas for further transactions", "have", env.gasPool, "want", chainParams.TxGas)
- break
- }
- tx := txHeap.Peek()
- if tx == nil {
- break
- }
- // The sender is only for logging purposes, and it doesn't really matter if it's correct.
- from, _ := types.Sender(signer, tx)
- // Execute the transaction
- env.state.Prepare(tx.Hash(), common.Hash{}, env.tcount)
- err = env.commitTransaction(tx, coinbase)
- switch err {
- case core.ErrGasLimitReached:
- // Pop the current out-of-gas transaction without shifting in the next from the account
- log.Trace("Gas limit exceeded for current block", "sender", from)
- txHeap.Pop()
- case core.ErrNonceTooLow:
- // New head notification data race between the transaction pool and miner, shift
- log.Trace("Skipping transaction with low nonce", "sender", from, "nonce", tx.Nonce())
- txHeap.Shift()
- case core.ErrNonceTooHigh:
- // Reorg notification data race between the transaction pool and miner, skip account =
- log.Trace("Skipping account with high nonce", "sender", from, "nonce", tx.Nonce())
- txHeap.Pop()
- case nil:
- // Everything ok, collect the logs and shift in the next transaction from the same account
- env.tcount++
- txHeap.Shift()
- transactions = append(transactions, tx)
- default:
- // Strange error, discard the transaction and get the next in line (note, the
- // nonce-too-high clause will prevent us from executing in vain).
- log.Debug("Transaction failed, account skipped", "hash", tx.Hash(), "err", err)
- txHeap.Shift()
- }
- }
- // Create the block.
- block, err := api.eth.Engine().FinalizeAndAssemble(bc, header, env.state, transactions, nil /* uncles */, env.receipts)
- if err != nil {
- return nil, err
- }
- return &executableData{
- BlockHash: block.Hash(),
- ParentHash: block.ParentHash(),
- Miner: block.Coinbase(),
- StateRoot: block.Root(),
- Number: block.NumberU64(),
- GasLimit: block.GasLimit(),
- GasUsed: block.GasUsed(),
- Timestamp: block.Time(),
- ReceiptRoot: block.ReceiptHash(),
- LogsBloom: block.Bloom().Bytes(),
- Transactions: encodeTransactions(block.Transactions()),
- }, nil
- }
- func encodeTransactions(txs []*types.Transaction) [][]byte {
- var enc = make([][]byte, len(txs))
- for i, tx := range txs {
- enc[i], _ = tx.MarshalBinary()
- }
- return enc
- }
- func decodeTransactions(enc [][]byte) ([]*types.Transaction, error) {
- var txs = make([]*types.Transaction, len(enc))
- for i, encTx := range enc {
- var tx types.Transaction
- if err := tx.UnmarshalBinary(encTx); err != nil {
- return nil, fmt.Errorf("invalid transaction %d: %v", i, err)
- }
- txs[i] = &tx
- }
- return txs, nil
- }
- func insertBlockParamsToBlock(params executableData) (*types.Block, error) {
- txs, err := decodeTransactions(params.Transactions)
- if err != nil {
- return nil, err
- }
- number := big.NewInt(0)
- number.SetUint64(params.Number)
- header := &types.Header{
- ParentHash: params.ParentHash,
- UncleHash: types.EmptyUncleHash,
- Coinbase: params.Miner,
- Root: params.StateRoot,
- TxHash: types.DeriveSha(types.Transactions(txs), trie.NewStackTrie(nil)),
- ReceiptHash: params.ReceiptRoot,
- Bloom: types.BytesToBloom(params.LogsBloom),
- Difficulty: big.NewInt(1),
- Number: number,
- GasLimit: params.GasLimit,
- GasUsed: params.GasUsed,
- Time: params.Timestamp,
- }
- block := types.NewBlockWithHeader(header).WithBody(txs, nil /* uncles */)
- return block, nil
- }
- // NewBlock creates an Eth1 block, inserts it in the chain, and either returns true,
- // or false + an error. This is a bit redundant for go, but simplifies things on the
- // eth2 side.
- func (api *consensusAPI) NewBlock(params executableData) (*newBlockResponse, error) {
- parent := api.eth.BlockChain().GetBlockByHash(params.ParentHash)
- if parent == nil {
- return &newBlockResponse{false}, fmt.Errorf("could not find parent %x", params.ParentHash)
- }
- block, err := insertBlockParamsToBlock(params)
- if err != nil {
- return nil, err
- }
- _, err = api.eth.BlockChain().InsertChainWithoutSealVerification(block)
- return &newBlockResponse{err == nil}, err
- }
- // Used in tests to add a the list of transactions from a block to the tx pool.
- func (api *consensusAPI) addBlockTxs(block *types.Block) error {
- for _, tx := range block.Transactions() {
- api.eth.TxPool().AddLocal(tx)
- }
- return nil
- }
- // FinalizeBlock is called to mark a block as synchronized, so
- // that data that is no longer needed can be removed.
- func (api *consensusAPI) FinalizeBlock(blockHash common.Hash) (*genericResponse, error) {
- return &genericResponse{true}, nil
- }
- // SetHead is called to perform a force choice.
- func (api *consensusAPI) SetHead(newHead common.Hash) (*genericResponse, error) {
- return &genericResponse{true}, nil
- }
|