taiko-geth

diff --git ethereum/go-ethereum/beacon/engine/types.go taikoxyz/taiko-geth/beacon/engine/types.go index 07ebe544b438f4c0d356efc4362928c37de8062b..02207ceb9345a938756158df21db03dd37091f49 100644 --- ethereum/go-ethereum/beacon/engine/types.go +++ taikoxyz/taiko-geth/beacon/engine/types.go @@ -22,6 +22,7 @@ "math/big"   "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/trie" ) @@ -35,6 +36,10 @@ Timestamp uint64 `json:"timestamp" gencodec:"required"` Random common.Hash `json:"prevRandao" gencodec:"required"` SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` + // CHANGE(taiko): extra fields. + BaseFeePerGas *big.Int `json:"baseFeePerGas" gencodec:"required"` + BlockMetadata *BlockMetadata `json:"blockMetadata" gencodec:"required"` + L1Origin *rawdb.L1Origin `json:"l1Origin" gencodec:"required"` }   // JSON type overrides for PayloadAttributes. @@ -42,25 +47,52 @@ type payloadAttributesMarshaling struct { Timestamp hexutil.Uint64 }   -//go:generate go run github.com/fjl/gencodec -type ExecutableData -field-override executableDataMarshaling -out gen_ed.go +//go:generate go run github.com/fjl/gencodec -type BlockMetadata -field-override blockMetadataMarshaling -out gen_blockmetadata.go + +// CHANGE(taiko): BlockMetadata represents a `BlockMetadata` struct defined in +// protocol's `LibData`. +type BlockMetadata struct { + // Fields defined in `LibData.blockMetadata`. + Beneficiary common.Address `json:"beneficiary" gencodec:"required"` + GasLimit uint64 `json:"gasLimit" gencodec:"required"` + Timestamp uint64 `json:"timestamp" gencodec:"required"` + MixHash common.Hash `json:"mixHash" gencodec:"required"` + ExtraData []byte `json:"extraData" gencodec:"required"` + + // Extra fields required in go-taiko. + TxList []byte `json:"txList" gencodec:"required"` + HighestBlockID *big.Int `json:"highestBlockID" gencodec:"required"` +} + +// CHANGE(taiko): JSON type overrides for BlockMetadata. +type blockMetadataMarshaling struct { + Timestamp hexutil.Uint64 + TxList hexutil.Bytes + ExtraData hexutil.Bytes +}   // ExecutableData is the data necessary to execute an EL payload. +// +//go:generate go run github.com/fjl/gencodec -type ExecutableData -field-override executableDataMarshaling -out gen_ed.go type ExecutableData struct { - ParentHash common.Hash `json:"parentHash" gencodec:"required"` - FeeRecipient common.Address `json:"feeRecipient" gencodec:"required"` - StateRoot common.Hash `json:"stateRoot" gencodec:"required"` - ReceiptsRoot common.Hash `json:"receiptsRoot" gencodec:"required"` - LogsBloom []byte `json:"logsBloom" gencodec:"required"` - Random common.Hash `json:"prevRandao" gencodec:"required"` - Number uint64 `json:"blockNumber" gencodec:"required"` - GasLimit uint64 `json:"gasLimit" gencodec:"required"` - GasUsed uint64 `json:"gasUsed" gencodec:"required"` - Timestamp uint64 `json:"timestamp" gencodec:"required"` - ExtraData []byte `json:"extraData" gencodec:"required"` - BaseFeePerGas *big.Int `json:"baseFeePerGas" gencodec:"required"` - BlockHash common.Hash `json:"blockHash" gencodec:"required"` - Transactions [][]byte `json:"transactions" gencodec:"required"` - Withdrawals []*types.Withdrawal `json:"withdrawals"` + ParentHash common.Hash `json:"parentHash" gencodec:"required"` + FeeRecipient common.Address `json:"feeRecipient" gencodec:"required"` + StateRoot common.Hash `json:"stateRoot" gencodec:"required"` + ReceiptsRoot common.Hash `json:"receiptsRoot" gencodec:"required"` + LogsBloom []byte `json:"logsBloom" gencodec:"required"` + Random common.Hash `json:"prevRandao" gencodec:"required"` + Number uint64 `json:"blockNumber" gencodec:"required"` + GasLimit uint64 `json:"gasLimit" gencodec:"required"` + GasUsed uint64 `json:"gasUsed" gencodec:"required"` + Timestamp uint64 `json:"timestamp" gencodec:"required"` + ExtraData []byte `json:"extraData" gencodec:"required"` + BaseFeePerGas *big.Int `json:"baseFeePerGas" gencodec:"required"` + BlockHash common.Hash `json:"blockHash" gencodec:"required"` + Transactions [][]byte `json:"transactions"` + Withdrawals []*types.Withdrawal `json:"withdrawals"` + TxHash common.Hash `json:"txHash"` // CHANGE(taiko): allow passing txHash directly instead of transactions list + WithdrawalsHash common.Hash `json:"withdrawalsHash"` // CHANGE(taiko): allow passing WithdrawalsHash directly instead of withdrawals + TaikoBlock bool // CHANGE(taiko): whether this is a Taiko L2 block, only used by ExecutableDataToBlock }   // JSON type overrides for executableData. @@ -179,9 +211,15 @@ // ExecutableData before withdrawals are enabled by marshaling // Withdrawals as the json null value. var withdrawalsRoot *common.Hash if params.Withdrawals != nil { - h := types.DeriveSha(types.Withdrawals(params.Withdrawals), trie.NewStackTrie(nil)) + var h common.Hash + if params.TaikoBlock { + h = types.CalcWithdrawalsRootTaiko(params.Withdrawals) + } else { + h = types.DeriveSha(types.Withdrawals(params.Withdrawals), trie.NewStackTrie(nil)) + } withdrawalsRoot = &h } + header := &types.Header{ ParentHash: params.ParentHash, UncleHash: types.EmptyUncleHash,

diff --git ethereum/go-ethereum/cmd/geth/config.go taikoxyz/taiko-geth/cmd/geth/config.go index 0b856d1c1b7a9c25a29c0b467a3f88487ef09ebb..827c453a0f313ef3bb1fd5b64a92b86715d8c7b6 100644 --- ethereum/go-ethereum/cmd/geth/config.go +++ taikoxyz/taiko-geth/cmd/geth/config.go @@ -164,6 +164,9 @@ cfg.Eth.OverrideShanghai = &v } backend, eth := utils.RegisterEthService(stack, &cfg.Eth)   + // CHANGE(TAIKO): register Taiko RPC APIs. + utils.RegisterTaikoAPIs(stack, &cfg.Eth, eth) + // Configure log filter RPC API. filterSystem := utils.RegisterFilterAPI(stack, backend, &cfg.Eth)

diff --git ethereum/go-ethereum/cmd/utils/taiko_flags.go taikoxyz/taiko-geth/cmd/utils/taiko_flags.go new file mode 100644 index 0000000000000000000000000000000000000000..d6d23c96cfbe517dc2264ff5d367bb87d62ebf78 --- /dev/null +++ taikoxyz/taiko-geth/cmd/utils/taiko_flags.go @@ -0,0 +1,35 @@ +package utils + +import ( + "os" + + "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rpc" + "github.com/urfave/cli/v2" +) + +var ( + TaikoFlag = cli.BoolFlag{ + Name: "taiko", + Usage: "Taiko network", + } +) + +// RegisterTaikoAPIs initializes and registers the Taiko RPC APIs. +func RegisterTaikoAPIs(stack *node.Node, cfg *ethconfig.Config, backend *eth.Ethereum) { + if os.Getenv("TAIKO_TEST") != "" { + return + } + // Add methods under "taiko_" RPC namespace to the available APIs list + stack.RegisterAPIs([]rpc.API{ + { + Namespace: "taiko", + Version: params.VersionWithMeta, + Service: eth.NewTaikoAPIBackend(backend), + Public: true, + }, + }) +}

diff --git ethereum/go-ethereum/cmd/geth/main.go taikoxyz/taiko-geth/cmd/geth/main.go index a970e76523426210919e122b5881a18d9a688412..28858b0f90d60b9ef8d3820dede496ba773665b2 100644 --- ethereum/go-ethereum/cmd/geth/main.go +++ taikoxyz/taiko-geth/cmd/geth/main.go @@ -250,6 +250,9 @@ debug.Flags, metricsFlags, )   + // CHANGE(taiko): append Taiko flags into the original GETH flags + app.Flags = append(app.Flags, &utils.TaikoFlag) + app.Before = func(ctx *cli.Context) error { flags.MigrateGlobalFlags(ctx) return debug.Setup(ctx)

diff --git ethereum/go-ethereum/cmd/utils/flags.go taikoxyz/taiko-geth/cmd/utils/flags.go index 08de71ee831bfb9e29441c76226842e748108702..2794f9ef79cb4c837291c0e38529204504ed098b 100644 --- ethereum/go-ethereum/cmd/utils/flags.go +++ taikoxyz/taiko-geth/cmd/utils/flags.go @@ -1860,6 +1860,9 @@ }   // Override any default configs for hard coded networks. switch { + // CHANGE(taiko): when --taiko flag is set, use the Taiko genesis. + case ctx.IsSet(TaikoFlag.Name): + cfg.Genesis = core.TaikoGenesisBlock(cfg.NetworkId) case ctx.Bool(MainnetFlag.Name): if !ctx.IsSet(NetworkIdFlag.Name) { cfg.NetworkId = 1 @@ -2234,7 +2237,7 @@ ethashConfig := ethconfig.Defaults.Ethash if ctx.Bool(FakePoWFlag.Name) { ethashConfig.PowMode = ethash.ModeFake } - engine := ethconfig.CreateConsensusEngine(stack, &ethashConfig, cliqueConfig, nil, false, chainDb) + engine := ethconfig.CreateConsensusEngine(stack, &ethashConfig, cliqueConfig, nil, false, chainDb, ctx.Bool(TaikoFlag.Name)) if gcmode := ctx.String(GCModeFlag.Name); gcmode != "full" && gcmode != "archive" { Fatalf("--%s must be either 'full' or 'archive'", GCModeFlag.Name) }

diff --git ethereum/go-ethereum/consensus/taiko/consensus_test.go taikoxyz/taiko-geth/consensus/taiko/consensus_test.go new file mode 100644 index 0000000000000000000000000000000000000000..68c7be72215109ae9d0ad8737463df55bbf8585c --- /dev/null +++ taikoxyz/taiko-geth/consensus/taiko/consensus_test.go @@ -0,0 +1,212 @@ +package taiko_test + +import ( + "bytes" + "math/big" + "testing" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus" + "github.com/ethereum/go-ethereum/consensus/taiko" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/params" + "github.com/stretchr/testify/assert" +) + +var ( + testL2RollupAddress = common.HexToAddress("0x79fcdef22feed20eddacbb2587640e45491b757f") + testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + testAddr = crypto.PubkeyToAddress(testKey.PublicKey) + + genesis *core.Genesis + txs []*types.Transaction + testEngine *taiko.Taiko +) + +func init() { + config := params.TestChainConfig + config.GrayGlacierBlock = nil + config.ArrowGlacierBlock = nil + config.Ethash = nil + config.Taiko = true + testEngine = taiko.New() + + genesis = &core.Genesis{ + Config: config, + Alloc: core.GenesisAlloc{testAddr: {Balance: big.NewInt(2e15)}}, + ExtraData: []byte("test genesis"), + Timestamp: 9000, + Difficulty: common.Big0, + BaseFee: big.NewInt(params.InitialBaseFee), + } + + txs = []*types.Transaction{ + types.MustSignNewTx(testKey, types.LatestSigner(genesis.Config), &types.LegacyTx{ + Nonce: 0, + Value: big.NewInt(12), + GasPrice: big.NewInt(params.InitialBaseFee), + Gas: params.TxGas, + To: &common.Address{2}, + }), + types.MustSignNewTx(testKey, types.LatestSigner(genesis.Config), &types.LegacyTx{ + Nonce: 1, + Value: big.NewInt(8), + GasPrice: big.NewInt(params.InitialBaseFee), + Gas: params.TxGas, + To: &common.Address{2}, + }), + // prepareBlockTx + types.MustSignNewTx(testKey, types.LatestSigner(genesis.Config), &types.LegacyTx{ + Nonce: 2, + Value: big.NewInt(8), + GasPrice: big.NewInt(params.InitialBaseFee), + Gas: params.TxGas, + To: &testL2RollupAddress, + }), + } +} + +func newTestBackend(t *testing.T) (*eth.Ethereum, []*types.Block) { + // Generate test chain. + blocks := generateTestChain() + + // Create node + n, err := node.New(&node.Config{}) + if err != nil { + t.Fatalf("can't create new node: %v", err) + } + + // Create Ethereum Service + config := &ethconfig.Config{ + Genesis: genesis, + } + + ethservice, err := eth.New(n, config) + if err != nil { + t.Fatalf("can't create new ethereum service: %v", err) + } + + // Import the test chain. + if err := n.Start(); err != nil { + t.Fatalf("can't start test node: %v", err) + } + + if _, err := ethservice.BlockChain().InsertChain(blocks[1:]); err != nil { + t.Fatalf("can't import test blocks: %v", err) + } + + if _, ok := ethservice.Engine().(*taiko.Taiko); !ok { + t.Fatalf("not use taiko engine") + } + + return ethservice, blocks +} + +func generateTestChain() []*types.Block { + db := rawdb.NewMemoryDatabase() + generate := func(i int, g *core.BlockGen) { + g.OffsetTime(5) + + g.SetExtra([]byte("test_taiko")) + g.SetDifficulty(common.Big0) + + for _, tx := range txs { + g.AddTx(tx) + } + } + + gblock := genesis.MustCommit(db) + + blocks, _ := core.GenerateChain(genesis.Config, gblock, testEngine, db, 1, generate) + + blocks = append([]*types.Block{gblock}, blocks...) + return blocks +} + +func TestVerifyHeader(t *testing.T) { + ethService, blocks := newTestBackend(t) + + for _, b := range blocks { + err := testEngine.VerifyHeader(ethService.BlockChain(), b.Header(), true) + assert.NoErrorf(t, err, "VerifyHeader error: %s", err) + } + + err := testEngine.VerifyHeader(ethService.BlockChain(), &types.Header{ + Number: common.Big1, + Time: uint64(time.Now().Unix()), + BaseFee: big.NewInt(params.InitialBaseFee), + WithdrawalsHash: &types.EmptyWithdrawalsHash, + UncleHash: types.EmptyUncleHash, + }, true) + assert.ErrorIs(t, err, consensus.ErrUnknownAncestor, "VerifyHeader should throw ErrUnknownAncestor when parentHash is unknown") + + err = testEngine.VerifyHeader(ethService.BlockChain(), &types.Header{ + ParentHash: blocks[len(blocks)-1].Hash(), + Number: common.Big0, + Time: uint64(time.Now().Unix()), + BaseFee: big.NewInt(params.InitialBaseFee), + WithdrawalsHash: &types.EmptyWithdrawalsHash, + UncleHash: types.EmptyUncleHash, + }, true) + assert.ErrorIs(t, err, consensus.ErrInvalidNumber, "VerifyHeader should throw ErrInvalidNumber when the block number is wrong") + + err = testEngine.VerifyHeader(ethService.BlockChain(), &types.Header{ + ParentHash: blocks[len(blocks)-1].Hash(), + Number: new(big.Int).SetInt64(int64(len(blocks))), + Time: uint64(time.Now().Unix()), + Extra: bytes.Repeat([]byte{1}, int(params.MaximumExtraDataSize+1)), + BaseFee: big.NewInt(params.InitialBaseFee), + WithdrawalsHash: &types.EmptyWithdrawalsHash, + UncleHash: types.EmptyUncleHash, + }, true) + assert.ErrorContains(t, err, "extra-data too long", "VerifyHeader should throw ErrExtraDataTooLong when the block has too much extra data") + + err = testEngine.VerifyHeader(ethService.BlockChain(), &types.Header{ + ParentHash: blocks[len(blocks)-1].Hash(), + Number: new(big.Int).SetInt64(int64(len(blocks))), + Time: uint64(time.Now().Unix()), + Difficulty: common.Big1, + BaseFee: big.NewInt(params.InitialBaseFee), + WithdrawalsHash: &types.EmptyWithdrawalsHash, + UncleHash: types.EmptyUncleHash, + }, true) + assert.ErrorContains(t, err, "invalid difficulty", "VerifyHeader should throw ErrInvalidDifficulty when difficulty is not 0") + + err = testEngine.VerifyHeader(ethService.BlockChain(), &types.Header{ + ParentHash: blocks[len(blocks)-1].Hash(), + Number: new(big.Int).SetInt64(int64(len(blocks))), + Time: uint64(time.Now().Unix()), + GasLimit: params.MaxGasLimit + 1, + BaseFee: big.NewInt(params.InitialBaseFee), + WithdrawalsHash: &types.EmptyWithdrawalsHash, + UncleHash: types.EmptyUncleHash, + }, true) + assert.ErrorContains(t, err, "invalid gasLimit", "VerifyHeader should throw ErrInvalidGasLimit when gasLimit is higher than the limit") + + err = testEngine.VerifyHeader(ethService.BlockChain(), &types.Header{ + ParentHash: blocks[len(blocks)-1].Hash(), + Number: new(big.Int).SetInt64(int64(len(blocks))), + Time: uint64(time.Now().Unix()), + GasLimit: params.MaxGasLimit, + BaseFee: big.NewInt(params.InitialBaseFee), + UncleHash: types.EmptyUncleHash, + }, true) + assert.ErrorContains(t, err, "withdrawals hash missing", "VerifyHeader should throw ErrWithdrawalsHashMissing withdrawalshash is nil") + + err = testEngine.VerifyHeader(ethService.BlockChain(), &types.Header{ + ParentHash: blocks[len(blocks)-1].Hash(), + Number: new(big.Int).SetInt64(int64(len(blocks))), + Time: uint64(time.Now().Unix()), + GasLimit: params.MaxGasLimit, + BaseFee: big.NewInt(params.InitialBaseFee), + WithdrawalsHash: &types.EmptyWithdrawalsHash, + }, true) + assert.ErrorContains(t, err, "uncles not empty", "VerifyHeader should throw ErrUnclesNotEmpty if uncles is not the empty hash") +}

diff --git ethereum/go-ethereum/consensus/taiko/consensus.go taikoxyz/taiko-geth/consensus/taiko/consensus.go new file mode 100644 index 0000000000000000000000000000000000000000..d0ea3e2c5e71a165f42d3bd12e1813e775cfc7ba --- /dev/null +++ taikoxyz/taiko-geth/consensus/taiko/consensus.go @@ -0,0 +1,288 @@ +package taiko + +import ( + "errors" + "fmt" + "math/big" + "runtime" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rpc" + "github.com/ethereum/go-ethereum/trie" +) + +var ( + ErrOlderBlockTime = errors.New("timestamp older than parent") + ErrUnclesNotEmpty = errors.New("uncles not empty") + ErrEmptyBasefee = errors.New("empty base fee") + ErrEmptyWithdrawalsHash = errors.New("withdrawals hash missing") +) + +// Taiko is a consensus engine used by L2 rollup. +type Taiko struct{} + +var defaultTaiko = new(Taiko) + +func New() *Taiko { + return defaultTaiko +} + +// check all method stubs for interface `Engine` without affect performance. +var _ consensus.Engine = (*Taiko)(nil) + +// Author retrieves the Ethereum address of the account that minted the given +// block, who proposes the block (not the prover). +func (t *Taiko) Author(header *types.Header) (common.Address, error) { + return header.Coinbase, nil +} + +// VerifyHeader checks whether a header conforms to the consensus rules of a +// given engine. Verifying the seal may be done optionally here, or explicitly +// via the VerifySeal method. +func (t *Taiko) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, seal bool) error { + // Short circuit if the header is known, or its parent not + number := header.Number.Uint64() + if chain.GetHeader(header.Hash(), number) != nil { + return nil + } + parent := chain.GetHeader(header.ParentHash, number-1) + if parent == nil { + return consensus.ErrUnknownAncestor + } + // Sanity checks passed, do a proper verification + return t.verifyHeader(chain, header, parent, seal, time.Now().Unix()) +} + +// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers +// concurrently. 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 (t *Taiko) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) { + // Spawn as many workers as allowed threads + workers := runtime.GOMAXPROCS(0) + if len(headers) < workers { + workers = len(headers) + } + + // Create a task channel and spawn the verifiers + var ( + inputs = make(chan int) + done = make(chan int, workers) + errors = make([]error, len(headers)) + abort = make(chan struct{}) + unixNow = time.Now().Unix() + ) + for i := 0; i < workers; i++ { + go func() { + for index := range inputs { + errors[index] = t.verifyHeaderWorker(chain, headers, seals, index, unixNow) + done <- index + } + }() + } + + errorsOut := make(chan error, len(headers)) + go func() { + defer close(inputs) + var ( + in, out = 0, 0 + checked = make([]bool, len(headers)) + inputs = inputs + ) + for { + select { + case inputs <- in: + if in++; in == len(headers) { + // Reached end of headers. Stop sending to workers. + inputs = nil + } + case index := <-done: + for checked[index] = true; checked[out]; out++ { + errorsOut <- errors[out] + if out == len(headers)-1 { + return + } + } + case <-abort: + return + } + } + }() + return abort, errorsOut +} + +func (t *Taiko) verifyHeader(chain consensus.ChainHeaderReader, header, parent *types.Header, seal bool, unixNow int64) error { + if header.Time > uint64(unixNow) { + return consensus.ErrFutureBlock + } + + // Ensure that the header's extra-data section is of a reasonable size (<= 32 bytes) + if uint64(len(header.Extra)) > params.MaximumExtraDataSize { + return fmt.Errorf("extra-data too long: %d > %d", len(header.Extra), params.MaximumExtraDataSize) + } + + // Timestamp should later than or equal to parent (when many L2 blocks included in one L1 block) + if header.Time < parent.Time { + return ErrOlderBlockTime + } + + // Verify that the block number is parent's +1 + if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 { + return consensus.ErrInvalidNumber + } + + // Difficulty should always be zero + if header.Difficulty != nil && header.Difficulty.Cmp(common.Big0) != 0 { + return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficulty, common.Big0) + } + + // Verify that the gas limit is <= 2^63-1 + if header.GasLimit > params.MaxGasLimit { + return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, params.MaxGasLimit) + } + + // Verify that the gasUsed is <= gasLimit + if header.GasUsed > header.GasLimit { + return fmt.Errorf("invalid gasUsed: have %d, gasLimit %d", header.GasUsed, header.GasLimit) + } + + // Uncles should be empty + if header.UncleHash != types.CalcUncleHash(nil) { + return ErrUnclesNotEmpty + } + + // BaseFee should not be empty + if header.BaseFee == nil { + return ErrEmptyBasefee + } + + // WithdrawalsHash should not be empty + if header.WithdrawalsHash == nil { + return ErrEmptyWithdrawalsHash + } + + return nil +} + +func (t *Taiko) verifyHeaderWorker(chain consensus.ChainHeaderReader, headers []*types.Header, seals []bool, index int, unixNow int64) error { + var parent *types.Header + if index == 0 { + parent = chain.GetHeader(headers[0].ParentHash, headers[0].Number.Uint64()-1) + } else if headers[index-1].Hash() == headers[index].ParentHash { + parent = headers[index-1] + } + if parent == nil { + return consensus.ErrUnknownAncestor + } + + return t.verifyHeader(chain, headers[index], parent, seals[index], unixNow) +} + +// VerifyUncles verifies that the given block's uncles conform to the consensus +// rules of a given engine. +// +// always returning an error for any uncles as this consensus mechanism doesn't permit uncles. +func (t *Taiko) VerifyUncles(chain consensus.ChainReader, block *types.Block) error { + if len(block.Uncles()) > 0 { + return ErrUnclesNotEmpty + } + + return nil +} + +// Prepare initializes the consensus fields of a block header according to the +// rules of a particular engine. The changes are executed inline. +func (t *Taiko) Prepare(chain consensus.ChainHeaderReader, header *types.Header) error { + parent := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1) + if parent == nil { + return consensus.ErrUnknownAncestor + } + header.Difficulty = common.Big0 + return nil +} + +// Finalize runs any post-transaction state modifications (e.g. block rewards) +// but does not assemble the block. +// +// Note: The block header and state database might be updated to reflect any +// consensus rules that happen at finalization (e.g. block rewards). +func (t *Taiko) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) { + // no block rewards in l2 + header.UncleHash = types.CalcUncleHash(nil) + header.Difficulty = common.Big0 + // Withdrawals processing. + for _, w := range withdrawals { + state.AddBalance(w.Address, new(big.Int).SetUint64(w.Amount)) + } + header.Root = state.IntermediateRoot(true) +} + +// FinalizeAndAssemble runs any post-transaction state modifications (e.g. block +// rewards) and assembles the final block. +// +// Note: The block header and state database might be updated to reflect any +// consensus rules that happen at finalization (e.g. block rewards). +func (t *Taiko) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) { + if withdrawals == nil { + withdrawals = make([]*types.Withdrawal, 0) + } + + // Finalize block + t.Finalize(chain, header, state, txs, uncles, withdrawals) + return types.NewTaikoBlockWithWithdrawals( + header, txs, nil /* ignore uncles */, receipts, withdrawals, trie.NewStackTrie(nil), + ), nil +} + +// Seal generates a new sealing request for the given input block and pushes +// the result into the given channel. +// +// Note, the method returns immediately and will send the result async. More +// than one result may also be returned depending on the consensus algorithm. +func (t *Taiko) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error { + header := block.Header() + + // Sealing the genesis block is not supported + number := header.Number.Uint64() + if number == 0 { + return consensus.ErrInvalidNumber + } + + select { + case results <- block.WithSeal(header): + case <-stop: + return nil + default: + log.Warn("Sealing result is not read by miner", "sealHash", t.SealHash(header)) + } + + return nil +} + +// SealHash returns the hash of a block prior to it being sealed. +func (t *Taiko) SealHash(header *types.Header) common.Hash { + // Keccak(rlp(header)) + return header.Hash() +} + +// CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty +// that a new block should have. +func (t *Taiko) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent *types.Header) *big.Int { + return common.Big0 +} + +// APIs returns the RPC APIs this consensus engine provides. +func (t *Taiko) APIs(chain consensus.ChainHeaderReader) []rpc.API { + return nil +} + +// Close terminates any background threads maintained by the consensus engine. +func (t *Taiko) Close() error { + return nil +}

diff --git ethereum/go-ethereum/core/taiko_pool_content_splitter.go taikoxyz/taiko-geth/core/taiko_pool_content_splitter.go new file mode 100644 index 0000000000000000000000000000000000000000..8742479185d1e889385e19406fd67486abcfb35c --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_pool_content_splitter.go @@ -0,0 +1,203 @@ +package core + +import ( + "fmt" + "math/big" + "strings" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" +) + +// PoolContent represents a response body of a `txpool_content` RPC call. +type PoolContent map[common.Address]types.Transactions + +// Len returns the number of transactions in the PoolContent. +func (pc PoolContent) Len() int { + len := 0 + for _, pendingTxs := range pc { + len += pendingTxs.Len() + } + + return len +} + +// ToTxsByPriceAndNonce creates a transaction set that can retrieve price sorted transactions in a nonce-honouring way. +func (pc PoolContent) ToTxsByPriceAndNonce( + chainID *big.Int, + localAddresses []common.Address, +) ( + locals *types.TransactionsByPriceAndNonce, + remotes *types.TransactionsByPriceAndNonce, +) { + var ( + localTxs = map[common.Address]types.Transactions{} + remoteTxs = map[common.Address]types.Transactions{} + ) + + for address, txsWithNonce := range pc { + out: + for _, tx := range txsWithNonce { + for _, localAddress := range localAddresses { + if address == localAddress { + localTxs[address] = append(localTxs[address], tx) + continue out + } + } + remoteTxs[address] = append(remoteTxs[address], tx) + } + } + + return types.NewTransactionsByPriceAndNonce(types.LatestSignerForChainID(chainID), localTxs, nil), + types.NewTransactionsByPriceAndNonce(types.LatestSignerForChainID(chainID), remoteTxs, nil) +} + +// PoolContentSplitter is responsible for splitting the pool content +// which fetched from a `txpool_content` RPC call response into several smaller transactions lists +// and make sure each splitted list satisfies the limits defined in Taiko protocol. +type PoolContentSplitter struct { + chainID *big.Int + maxTransactionsPerBlock uint64 + blockMaxGasLimit uint64 + maxBytesPerTxList uint64 + minTxGasLimit uint64 + locals []common.Address +} + +// NewPoolContentSplitter creates a new PoolContentSplitter instance. +func NewPoolContentSplitter( + chainID *big.Int, + maxTransactionsPerBlock uint64, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + minTxGasLimit uint64, + locals []string, +) (*PoolContentSplitter, error) { + var localsAddresses []common.Address + for _, account := range locals { + if trimmed := strings.TrimSpace(account); !common.IsHexAddress(trimmed) { + return nil, fmt.Errorf("invalid account: %s", trimmed) + } else { + localsAddresses = append(localsAddresses, common.HexToAddress(account)) + } + } + + return &PoolContentSplitter{ + chainID: chainID, + maxTransactionsPerBlock: maxTransactionsPerBlock, + blockMaxGasLimit: blockMaxGasLimit, + maxBytesPerTxList: maxBytesPerTxList, + minTxGasLimit: minTxGasLimit, + locals: localsAddresses, + }, nil +} + +// Split splits the given transaction pool content to make each splitted +// transactions list satisfies the rules defined in Taiko protocol. +func (p *PoolContentSplitter) Split(poolContent PoolContent) []types.Transactions { + var ( + localTxs, remoteTxs = poolContent.ToTxsByPriceAndNonce(p.chainID, p.locals) + splittedLocalTxLists = p.splitTxs(localTxs) + splittedRemoteTxLists = p.splitTxs(remoteTxs) + ) + + splittedTxLists := append(splittedLocalTxLists, splittedRemoteTxLists...) + + return splittedTxLists +} + +// validateTx checks whether the given transaction is valid according +// to the rules in Taiko protocol. +func (p *PoolContentSplitter) validateTx(tx *types.Transaction) error { + if tx.Gas() < p.minTxGasLimit || tx.Gas() > p.blockMaxGasLimit { + return fmt.Errorf( + "transaction %s gas limit reaches the limits, got=%v, lowerBound=%v, upperBound=%v", + tx.Hash(), tx.Gas(), p.minTxGasLimit, p.blockMaxGasLimit, + ) + } + + b, err := rlp.EncodeToBytes(tx) + if err != nil { + return fmt.Errorf( + "failed to rlp encode the pending transaction %s: %w", tx.Hash(), err, + ) + } + + if len(b) > int(p.maxBytesPerTxList) { + return fmt.Errorf( + "size of transaction %s's rlp encoded bytes is bigger than the limit, got=%v, limit=%v", + tx.Hash(), len(b), p.maxBytesPerTxList, + ) + } + + return nil +} + +// isTxBufferFull checks whether the given transaction can be appended to the +// current transaction list +// NOTE: this function *MUST* be called after using `validateTx` to check every +// inside transaction is valid. +func (p *PoolContentSplitter) isTxBufferFull(t *types.Transaction, txs []*types.Transaction, gas uint64) bool { + if len(txs) >= int(p.maxTransactionsPerBlock) { + return true + } + + if gas+t.Gas() > p.blockMaxGasLimit { + return true + } + + // Transactions list's RLP encoding error has already been checked in + // `validateTx`, so no need to check the error here. + if b, _ := rlp.EncodeToBytes(append([]*types.Transaction{t}, txs...)); len(b) > int(p.maxBytesPerTxList) { + return true + } + + return false +} + +// splitTxs the internal implementation Split, splits the given transactions into small transactions lists +// which satisfy the protocol constraints. +func (p *PoolContentSplitter) splitTxs(txs *types.TransactionsByPriceAndNonce) []types.Transactions { + var ( + splittedTxLists = make([]types.Transactions, 0) + txBuffer = make([]*types.Transaction, 0, p.maxTransactionsPerBlock) + gasBuffer uint64 = 0 + ) + for { + tx := txs.Peek() + if tx == nil { + break + } + + // If the transaction is invalid, we simply ignore it. + if err := p.validateTx(tx); err != nil { + log.Debug("Invalid pending transaction", "hash", tx.Hash(), "error", err) + txs.Pop() // If this tx is invalid, ignore this sender's other txs in pool. + continue + } + + // If the transactions buffer is full, we make all transactions in + // current buffer a new splitted transaction list, and then reset the + // buffer. + if p.isTxBufferFull(tx, txBuffer, gasBuffer) { + splittedTxLists = append(splittedTxLists, txBuffer) + txBuffer = make([]*types.Transaction, 0, p.maxTransactionsPerBlock) + gasBuffer = 0 + } + + txBuffer = append(txBuffer, tx) + gasBuffer += tx.Gas() + + txs.Shift() + } + + // Maybe there are some remaining transactions in current buffer, + // make them a new transactions list too. + if len(txBuffer) > 0 { + splittedTxLists = append(splittedTxLists, txBuffer) + } + + return splittedTxLists +}

diff --git ethereum/go-ethereum/core/state_prefetcher.go taikoxyz/taiko-geth/core/state_prefetcher.go index c258eee4f4cc0ba508fa209ec233121428017763..af9486861f9027224daec0912cb9c05006525485 100644 --- ethereum/go-ethereum/core/state_prefetcher.go +++ taikoxyz/taiko-geth/core/state_prefetcher.go @@ -63,7 +63,7 @@ if interrupt != nil && atomic.LoadUint32(interrupt) == 1 { return } // Convert the transaction into an executable message and pre-cache its sender - msg, err := TransactionToMessage(tx, signer, header.BaseFee) + msg, err := TransactionToMessage(tx, signer, header.BaseFee, i == 0) if err != nil { return // Also invalid block, bail out }

diff --git ethereum/go-ethereum/core/state_transition.go taikoxyz/taiko-geth/core/state_transition.go index 1802f1daf70ae988a08010bf2089da55690159cd..6975d127c5cdf5e19ca8bc9ba0bd828e2efca617 100644 --- ethereum/go-ethereum/core/state_transition.go +++ taikoxyz/taiko-geth/core/state_transition.go @@ -140,10 +140,13 @@ // When SkipAccountCheckss is true, the message nonce is not checked against the // account nonce in state. It also disables checking that the sender is an EOA. // This field will be set to true for operations like RPC eth_call. SkipAccountChecks bool + + // CHANGE(taiko): Whteher the current transaction is the first transaction in a block. + IsFirstTx bool }   // TransactionToMessage converts a transaction into a Message. -func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int) (*Message, error) { +func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int, isFirstTx bool) (*Message, error) { msg := &Message{ Nonce: tx.Nonce(), GasLimit: tx.Gas(), @@ -155,6 +158,7 @@ Value: tx.Value(), Data: tx.Data(), AccessList: tx.AccessList(), SkipAccountChecks: false, + IsFirstTx: isFirstTx, } // If baseFee provided, set gasPrice to effectiveGasPrice. if baseFee != nil { @@ -234,6 +238,11 @@ balanceCheck = new(big.Int).SetUint64(st.msg.GasLimit) balanceCheck = balanceCheck.Mul(balanceCheck, st.msg.GasFeeCap) balanceCheck.Add(balanceCheck, st.msg.Value) } + // CHANGE(taiko): skip balance check for TaikoL2.anchor transaction. + if st.isAnchor() { + balanceCheck = common.Big0 + mgval = common.Big0 + } if have, want := st.state.GetBalance(st.msg.From), balanceCheck; have.Cmp(want) < 0 { return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From.Hex(), have, want) } @@ -274,7 +283,7 @@ // Make sure that transaction gasFeeCap is greater than the baseFee (post london) if st.evm.ChainConfig().IsLondon(st.evm.Context.BlockNumber) { // Skip the checks if gas fields are zero and baseFee was explicitly disabled (eth_call) - if !st.evm.Config.NoBaseFee || msg.GasFeeCap.BitLen() > 0 || msg.GasTipCap.BitLen() > 0 { + if (!st.evm.Config.NoBaseFee || msg.GasFeeCap.BitLen() > 0 || msg.GasTipCap.BitLen() > 0) && !st.isAnchor() { if l := msg.GasFeeCap.BitLen(); l > 256 { return fmt.Errorf("%w: address %v, maxFeePerGas bit length: %d", ErrFeeCapVeryHigh, msg.From.Hex(), l) @@ -395,6 +404,13 @@ } else { fee := new(big.Int).SetUint64(st.gasUsed()) fee.Mul(fee, effectiveTip) st.state.AddBalance(st.evm.Context.Coinbase, fee) + // CHANGE(taiko): basefee is not burnt, but sent to a treasury instead. + if st.evm.ChainConfig().Taiko && st.evm.Context.BaseFee != nil && !st.isAnchor() { + st.state.AddBalance( + st.evm.ChainConfig().Treasury, + new(big.Int).Mul(st.evm.Context.BaseFee, new(big.Int).SetUint64(st.gasUsed())), + ) + } }   return &ExecutionResult{ @@ -425,3 +441,9 @@ // gasUsed returns the amount of gas used up by the state transition. func (st *StateTransition) gasUsed() uint64 { return st.initialGas - st.gasRemaining } + +func (st *StateTransition) isAnchor() bool { + return st.evm.ChainConfig().Taiko && + st.msg.IsFirstTx && + st.msg.From == common.HexToAddress("0x0000777735367b36bC9B61C50022d9D0700dB4Ec") +}

diff --git ethereum/go-ethereum/core/taiko_pool_content_splitter_test.go taikoxyz/taiko-geth/core/taiko_pool_content_splitter_test.go new file mode 100644 index 0000000000000000000000000000000000000000..b420e94bf93b197c252d50eb52c0de9d2ef5ad33 --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_pool_content_splitter_test.go @@ -0,0 +1,101 @@ +package core + +import ( + "crypto/rand" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" + "github.com/stretchr/testify/require" +) + +func TestPoolContentSplit(t *testing.T) { + testAddress := "0x0000777735367b36bC9B61C50022d9D0700dB4Ec" + testPrivKey := "92954368afd3caa1f3ce3ead0069c1af414054aefe1ef9aeacc1bf426222ce38" + + // Gas limit is smaller than the limit. + splitter := &PoolContentSplitter{ + chainID: new(big.Int).SetUint64(1336), + minTxGasLimit: 21000, + } + + splitted := splitter.Split(PoolContent{ + common.BytesToAddress(randomBytes(32)): { + types.NewTx(&types.LegacyTx{}), + }, + }) + + require.Empty(t, splitted) + + // Gas limit is larger than the limit. + splitter = &PoolContentSplitter{ + chainID: new(big.Int).SetUint64(1336), + minTxGasLimit: 21000, + } + + splitted = splitter.Split(PoolContent{ + common.BytesToAddress(randomBytes(32)): { + types.NewTx(&types.LegacyTx{Gas: 21001}), + }, + }) + + require.Empty(t, splitted) + + // Transaction's RLP encoded bytes is larger than the limit. + txBytesTooLarge := types.NewTx(&types.LegacyTx{}) + + bytes, err := rlp.EncodeToBytes(txBytesTooLarge) + require.Nil(t, err) + require.NotEmpty(t, bytes) + + splitter = &PoolContentSplitter{ + chainID: new(big.Int).SetUint64(1336), + maxBytesPerTxList: uint64(len(bytes) - 1), + minTxGasLimit: uint64(len(bytes) - 2), + } + + splitted = splitter.Split(PoolContent{ + common.BytesToAddress(randomBytes(32)): {txBytesTooLarge}, + }) + + require.Empty(t, splitted) + + // Transactions that meet the limits + testKey, err := crypto.HexToECDSA(testPrivKey) + require.Nil(t, err) + + signer := types.LatestSignerForChainID(new(big.Int).SetUint64(1336)) + tx1 := types.MustSignNewTx(testKey, signer, &types.LegacyTx{Gas: 21001, Nonce: 1}) + tx2 := types.MustSignNewTx(testKey, signer, &types.LegacyTx{Gas: 21001, Nonce: 2}) + + bytes, err = rlp.EncodeToBytes(tx1) + require.Nil(t, err) + require.NotEmpty(t, bytes) + + splitter = &PoolContentSplitter{ + chainID: new(big.Int).SetUint64(1336), + minTxGasLimit: 21000, + maxBytesPerTxList: uint64(len(bytes) + 1000), + maxTransactionsPerBlock: 1, + blockMaxGasLimit: tx1.Gas() + 1000, + } + + splitted = splitter.Split(PoolContent{ + common.HexToAddress(testAddress): {tx1, tx2}, + }) + + require.Equal(t, 2, len(splitted)) +} + +// RandomBytes generates a random bytes. +func randomBytes(size int) (b []byte) { + b = make([]byte, size) + if _, err := rand.Read(b); err != nil { + log.Crit("Generate random bytes error", "error", err) + } + return +}

diff --git ethereum/go-ethereum/core/taiko_genesis.go taikoxyz/taiko-geth/core/taiko_genesis.go new file mode 100644 index 0000000000000000000000000000000000000000..5248cf26b92f1e56e760ee65bbd0a84cbc8a2601 --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_genesis.go @@ -0,0 +1,52 @@ +package core + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" + taikoGenesis "github.com/ethereum/go-ethereum/core/taiko_genesis" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" +) + +// TaikoGenesisBlock returns the Taiko network genesis block configs. +func TaikoGenesisBlock(networkID uint64) *Genesis { + chainConfig := params.TaikoChainConfig + + var allocJSON []byte + switch networkID { + case params.TaikoInternal1NetworkID.Uint64(): + chainConfig.ChainID = params.TaikoInternal1NetworkID + allocJSON = taikoGenesis.Internal1GenesisAllocJSON + case params.TaikoInternal2NetworkID.Uint64(): + chainConfig.ChainID = params.TaikoInternal2NetworkID + allocJSON = taikoGenesis.Internal2GenesisAllocJSON + case params.SnæfellsjökullNetworkID.Uint64(): + chainConfig.ChainID = params.SnæfellsjökullNetworkID + allocJSON = taikoGenesis.SnæfellsjökullGenesisAllocJSON + case params.AskjaNetworkID.Uint64(): + chainConfig.ChainID = params.AskjaNetworkID + allocJSON = taikoGenesis.AskjaGenesisAllocJSON + case params.GrimsvotnNetworkID.Uint64(): + chainConfig.ChainID = params.GrimsvotnNetworkID + allocJSON = taikoGenesis.GrimsvotnGenesisAllocJSON + default: + chainConfig.ChainID = params.TaikoMainnetNetworkID + allocJSON = taikoGenesis.MainnetGenesisAllocJSON + } + + var alloc GenesisAlloc + if err := alloc.UnmarshalJSON(allocJSON); err != nil { + log.Crit("unmarshal alloc json error", "error", err) + } + + return &Genesis{ + Config: chainConfig, + ExtraData: []byte{}, + GasLimit: uint64(6000000), + Difficulty: common.Big0, + Alloc: alloc, + GasUsed: 0, + BaseFee: new(big.Int).SetUint64(10000000), + } +}

diff --git ethereum/go-ethereum/core/block_validator.go taikoxyz/taiko-geth/core/block_validator.go index bcb228830d4ea77a5d76cbce303c7631874699fc..158481eec5edc9b32ea8a99399c91212c09b604c 100644 --- ethereum/go-ethereum/core/block_validator.go +++ taikoxyz/taiko-geth/core/block_validator.go @@ -19,6 +19,7 @@ import ( "fmt"   + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -73,7 +74,14 @@ // Withdrawals list must be present in body after Shanghai. if block.Withdrawals() == nil { return fmt.Errorf("missing withdrawals in block body") } - if hash := types.DeriveSha(block.Withdrawals(), trie.NewStackTrie(nil)); hash != *header.WithdrawalsHash { + + var hash common.Hash + if v.config.Taiko { + hash = types.CalcWithdrawalsRootTaiko(block.Withdrawals()) + } else { + hash = types.DeriveSha(block.Withdrawals(), trie.NewStackTrie(nil)) + } + if hash != *header.WithdrawalsHash { return fmt.Errorf("withdrawals root hash mismatch (header value %x, calculated %x)", *header.WithdrawalsHash, hash) } } else if block.Withdrawals() != nil {

diff --git ethereum/go-ethereum/core/state_processor.go taikoxyz/taiko-geth/core/state_processor.go index 2fa9c41bcc018b50f2509959206eb1bbce60efdb..20ab4fbdc001ff07e20c1905bb7824bedf3a928e 100644 --- ethereum/go-ethereum/core/state_processor.go +++ taikoxyz/taiko-geth/core/state_processor.go @@ -74,7 +74,7 @@ blockContext := NewEVMBlockContext(header, p.bc, nil) vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg) // Iterate over and process the individual transactions for i, tx := range block.Transactions() { - msg, err := TransactionToMessage(tx, types.MakeSigner(p.config, header.Number), header.BaseFee) + msg, err := TransactionToMessage(tx, types.MakeSigner(p.config, header.Number), header.BaseFee, i == 0) if err != nil { return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err) } @@ -146,8 +146,8 @@ // ApplyTransaction attempts to apply a transaction to the given state database // and uses the input parameters for its environment. It returns the receipt // for the transaction, gas used and an error if the transaction failed, // indicating the block was invalid. -func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, error) { - msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number), header.BaseFee) +func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, isAnchor bool) (*types.Receipt, error) { + msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number), header.BaseFee, isAnchor) if err != nil { return nil, err }

diff --git ethereum/go-ethereum/core/chain_makers.go taikoxyz/taiko-geth/core/chain_makers.go index 61d0098af3f6bef6d814bc8fa20af195f8d5d543..94e85519145dd798691106fb0304e634bad4b197 100644 --- ethereum/go-ethereum/core/chain_makers.go +++ taikoxyz/taiko-geth/core/chain_makers.go @@ -98,7 +98,7 @@ if b.gasPool == nil { b.SetCoinbase(common.Address{}) } b.statedb.SetTxContext(tx.Hash(), len(b.txs)) - receipt, err := ApplyTransaction(b.config, bc, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, vmConfig) + receipt, err := ApplyTransaction(b.config, bc, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, vmConfig, false) if err != nil { panic(err) }

diff --git ethereum/go-ethereum/core/rawdb/taiko_l1_origin_test.go taikoxyz/taiko-geth/core/rawdb/taiko_l1_origin_test.go new file mode 100644 index 0000000000000000000000000000000000000000..dae37a354fa5a6f9afae623e30cc2e9e8e1d69e8 --- /dev/null +++ taikoxyz/taiko-geth/core/rawdb/taiko_l1_origin_test.go @@ -0,0 +1,59 @@ +package rawdb + +import ( + "crypto/rand" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/log" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// randomBigInt generates a random big integer. +func randomBigInt() *big.Int { + randomBigInt, err := rand.Int(rand.Reader, common.Big256) + if err != nil { + log.Crit(err.Error()) + } + + return randomBigInt +} + +// randomHash generates a random blob of data and returns it as a hash. +func randomHash() common.Hash { + var hash common.Hash + if n, err := rand.Read(hash[:]); n != common.HashLength || err != nil { + panic(err) + } + return hash +} + +func TestL1Origin(t *testing.T) { + db := NewMemoryDatabase() + testL1Origin := &L1Origin{ + BlockID: randomBigInt(), + L2BlockHash: randomHash(), + L1BlockHeight: randomBigInt(), + L1BlockHash: randomHash(), + } + WriteL1Origin(db, testL1Origin.BlockID, testL1Origin) + l1Origin, err := ReadL1Origin(db, testL1Origin.BlockID) + require.Nil(t, err) + require.NotNil(t, l1Origin) + assert.Equal(t, testL1Origin.BlockID, l1Origin.BlockID) + assert.Equal(t, testL1Origin.L2BlockHash, l1Origin.L2BlockHash) + assert.Equal(t, testL1Origin.L1BlockHeight, l1Origin.L1BlockHeight) + assert.Equal(t, testL1Origin.L1BlockHash, l1Origin.L1BlockHash) +} + +func TestHeadL1Origin(t *testing.T) { + db := NewMemoryDatabase() + testBlockID := randomBigInt() + WriteHeadL1Origin(db, testBlockID) + blockID, err := ReadHeadL1Origin(db) + require.Nil(t, err) + require.NotNil(t, blockID) + assert.Equal(t, testBlockID, blockID) +}

diff --git ethereum/go-ethereum/core/txpool/txpool.go taikoxyz/taiko-geth/core/txpool/txpool.go index ac4486c6cba8c011da4dfa474294c64567c1ac4c..2e64051599e6bd6030407bea264e1281fe41e834 100644 --- ethereum/go-ethereum/core/txpool/txpool.go +++ taikoxyz/taiko-geth/core/txpool/txpool.go @@ -1364,7 +1364,13 @@ return } pool.currentState = statedb pool.pendingNonces = newNoncer(statedb) - pool.currentMaxGas = newHead.GasLimit + // CHANGE(taiko): current gas limit for transaction caps is always + // LibSharedConfig.blockMaxGasLimit defined in protocol. + if pool.chainconfig.Taiko { + pool.currentMaxGas = 6000000 // LibSharedConfig.blockMaxGasLimit + } else { + pool.currentMaxGas = newHead.GasLimit + }   // Inject any transactions discarded due to reorgs log.Debug("Reinjecting stale transactions", "count", len(reinject))

diff --git ethereum/go-ethereum/core/types/block.go taikoxyz/taiko-geth/core/types/block.go index e2c71abebd7056b7ad0c09f72ed673bd8304c0db..aedb34824d692546c4c34317924cefb095dfe0f8 100644 --- ethereum/go-ethereum/core/types/block.go +++ taikoxyz/taiko-geth/core/types/block.go @@ -26,8 +26,10 @@ "reflect" "sync/atomic" "time"   + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/rlp" )   @@ -254,6 +256,16 @@ return b.WithWithdrawals(withdrawals) }   +// CHANGE(taiko): use custom withdrawals hasher +func NewTaikoBlockWithWithdrawals(header *Header, txs []*Transaction, uncles []*Header, receipts []*Receipt, withdrawals []*Withdrawal, hasher TrieHasher) *Block { + b := NewBlock(header, txs, uncles, receipts, hasher) + + h := CalcWithdrawalsRootTaiko(withdrawals) + b.header.WithdrawalsHash = &h + + return b.WithWithdrawals(withdrawals) +} + // NewBlockWithHeader creates a block with the given header data. The // header data is copied, changes to header and to the field values // will not affect the block. @@ -453,3 +465,44 @@ return common.Hash{} } return common.BytesToHash(parentHash) } + +var ( + ethDepositsType, _ = abi.NewType("tuple[]", "[]TaikoData.EthDeposit", []abi.ArgumentMarshaling{ + {Name: "recipient", Type: "address"}, + {Name: "amount", Type: "uint96"}, + {Name: "id", Type: "uint64"}, + }) + ethDepositsArgs = abi.Arguments{{Name: "EthDeposit", Type: ethDepositsType}} +) + +type ethDeposit struct { + Recipient common.Address + Amount *big.Int + Id uint64 +} + +// CHANGE(taiko): calc withdrawals root by abi.encode deposits with keccak256. +// Golang equivalent to this solidity function: +// +// function hashEthDeposits(TaikoData.EthDeposit[] memory deposits) internal pure returns (bytes32) { +// return keccak256(abi.encode(deposits)); +// } +func CalcWithdrawalsRootTaiko(withdrawals []*Withdrawal) common.Hash { + // only process withdrawals/deposits of `TaikoConfig.minEthDepositsPerBlock` minimum. + if len(withdrawals) == 0 { + return common.HexToHash("0x569e75fc77c1a856f6daaf9e69d8a9566ca34aa47f9133711ce065a571af0cfd") // a known keccak256 hash of zero withdrawal. + } + + var deposits []ethDeposit + for _, withdrawal := range withdrawals { + deposits = append(deposits, ethDeposit{ + Recipient: withdrawal.Address, + Amount: new(big.Int).SetUint64(withdrawal.Amount), + Id: withdrawal.Index, + }) + } + + b, _ := ethDepositsArgs.Pack(deposits) + + return crypto.Keccak256Hash(b) +}

diff --git ethereum/go-ethereum/core/types/block_test.go taikoxyz/taiko-geth/core/types/block_test.go index 49197c923764d9c0fc1ea5551b722c925e4bb8a6..c196b487d06dbacf19f53c0cb54286d140412180 100644 --- ethereum/go-ethereum/core/types/block_test.go +++ taikoxyz/taiko-geth/core/types/block_test.go @@ -28,6 +28,7 @@ "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" + "github.com/stretchr/testify/assert" "golang.org/x/crypto/sha3" )   @@ -342,3 +343,71 @@ } } } } + +// CHANGE(taiko): test `CalcWithdrawalsRootTaiko` +func TestCalcWithdrawalsRootTaiko(t *testing.T) { + tests := []struct { + name string + withdrawals []*Withdrawal + want common.Hash + }{ + { + "empty", + nil, + common.HexToHash("0x569e75fc77c1a856f6daaf9e69d8a9566ca34aa47f9133711ce065a571af0cfd"), + }, + { + "withWithdrawals", + []*Withdrawal{ + { + Address: common.HexToAddress("0xa9bcF99f5eb19277f48b71F9b14f5960AEA58a89"), + Amount: 1000000000000000000, + Index: 0, + }, + { + Address: common.HexToAddress("0x200708D76eB1B69761c23821809d53F65049939e"), + Amount: 2000000000000000000, + Index: 1, + }, + { + Address: common.HexToAddress("0x300C9b60E19634e12FC6D68B7FEa7bFB26c2E419"), + Amount: 3000000000000000000, + Index: 2, + }, + { + Address: common.HexToAddress("0x400147C0Eb43D8D71b2B03037bB7B31f8f78EF5F"), + Amount: 4000000000000000000, + Index: 3, + }, + { + Address: common.HexToAddress("0x50081b12838240B1bA02b3177153Bca678a86078"), + Amount: 5000000000000000000, + Index: 4, + }, + { + Address: common.HexToAddress("0x430c9b60e19634e12FC6d68B7fEa7bFB26c2e419"), + Amount: 6000000000000000000, + Index: 5, + }, + { + Address: common.HexToAddress("0x520147C0eB43d8D71b2b03037bB7b31f8F78EF5f"), + Amount: 7000000000000000000, + Index: 6, + }, + { + Address: common.HexToAddress("0x61081B12838240B1Ba02b3177153BcA678a86078"), + Amount: 8000000000000000000, + Index: 7, + }, + }, + common.HexToHash("0x60386add6a400d9b23968e1239bd600d22d2eea4709246895c0e5d8f5ae49dc3"), + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := CalcWithdrawalsRootTaiko(tt.withdrawals) + assert.Equal(t, tt.want, got) + }) + } +}

diff --git ethereum/go-ethereum/core/taiko_genesis/genesis_alloc.go taikoxyz/taiko-geth/core/taiko_genesis/genesis_alloc.go new file mode 100644 index 0000000000000000000000000000000000000000..2efa4ec15620d50aa0f5f0882fdfa2b83f58f832 --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_genesis/genesis_alloc.go @@ -0,0 +1,23 @@ +package taiko_genesis + +import ( + _ "embed" +) + +//go:embed mainnet.json +var MainnetGenesisAllocJSON []byte + +//go:embed internal-1.json +var Internal1GenesisAllocJSON []byte + +//go:embed internal-2.json +var Internal2GenesisAllocJSON []byte + +//go:embed snæfellsjökull.json +var SnæfellsjökullGenesisAllocJSON []byte + +//go:embed askja.json +var AskjaGenesisAllocJSON []byte + +//go:embed grimsvotn.json +var GrimsvotnGenesisAllocJSON []byte

diff --git ethereum/go-ethereum/core/rawdb/taiko_l1_origin.go taikoxyz/taiko-geth/core/rawdb/taiko_l1_origin.go new file mode 100644 index 0000000000000000000000000000000000000000..aaa5c14832f39b524e863ad9ef0a64c044a9a1d6 --- /dev/null +++ taikoxyz/taiko-geth/core/rawdb/taiko_l1_origin.go @@ -0,0 +1,92 @@ +package rawdb + +import ( + "bytes" + "fmt" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" +) + +var ( + // Database key prefix for L2 block's L1Origin. + l1OriginPrefix = []byte("TKO:L1O") + headL1OriginKey = []byte("TKO:LastL1O") +) + +// l1OriginKey calculates the L1Origin key. +// l1OriginPrefix + l2HeaderHash -> l1OriginKey +func l1OriginKey(blockID *big.Int) []byte { + data, _ := (*math.HexOrDecimal256)(blockID).MarshalText() + return append(l1OriginPrefix, data...) +} + +//go:generate go run github.com/fjl/gencodec -type L1Origin -field-override l1OriginMarshaling -out gen_taiko_l1_origin.go + +// L1Origin represents a L1Origin of a L2 block. +type L1Origin struct { + BlockID *big.Int `json:"blockID" gencodec:"required"` + L2BlockHash common.Hash `json:"l2BlockHash"` + L1BlockHeight *big.Int `json:"l1BlockHeight" gencodec:"required"` + L1BlockHash common.Hash `json:"l1BlockHash" gencodec:"required"` +} + +type l1OriginMarshaling struct { + BlockID *math.HexOrDecimal256 + L1BlockHeight *math.HexOrDecimal256 +} + +// WriteL1Origin stores a L1Origin into the database. +func WriteL1Origin(db ethdb.KeyValueWriter, blockID *big.Int, l1Origin *L1Origin) { + data, err := rlp.EncodeToBytes(l1Origin) + if err != nil { + log.Crit("Failed to encode L1Origin", "err", err) + } + + if err := db.Put(l1OriginKey(blockID), data); err != nil { + log.Crit("Failed to store L1Origin", "err", err) + } +} + +// ReadL1Origin retrieves the given L2 block's L1Origin from database. +func ReadL1Origin(db ethdb.KeyValueReader, blockID *big.Int) (*L1Origin, error) { + data, _ := db.Get(l1OriginKey(blockID)) + if len(data) == 0 { + return nil, nil + } + + l1Origin := new(L1Origin) + if err := rlp.Decode(bytes.NewReader(data), l1Origin); err != nil { + return nil, fmt.Errorf("invalid L1Origin RLP bytes: %w", err) + } + + return l1Origin, nil +} + +// WriteHeadL1Origin stores the given L1Origin as the last L1Origin. +func WriteHeadL1Origin(db ethdb.KeyValueWriter, blockID *big.Int) { + data, _ := (*math.HexOrDecimal256)(blockID).MarshalText() + if err := db.Put(headL1OriginKey, data); err != nil { + log.Crit("Failed to store head L1Origin", "error", err) + } +} + +// ReadHeadL1Origin retrieves the last L1Origin from database. +func ReadHeadL1Origin(db ethdb.KeyValueReader) (*big.Int, error) { + data, _ := db.Get(headL1OriginKey) + if len(data) == 0 { + return nil, nil + } + + blockID := new(math.HexOrDecimal256) + if err := blockID.UnmarshalText(data); err != nil { + log.Error("Unmarshal L1Origin unmarshal error", "error", err) + return nil, fmt.Errorf("invalid L1Origin unmarshal: %w", err) + } + + return (*big.Int)(blockID), nil +}

diff --git ethereum/go-ethereum/eth/backend.go taikoxyz/taiko-geth/eth/backend.go index 6368c0e03c564cdc5e457883b7f81e0d8d9c7431..be82c45468cc563927b630ed9cdae77307bf0a1d 100644 --- ethereum/go-ethereum/eth/backend.go +++ taikoxyz/taiko-geth/eth/backend.go @@ -141,7 +141,13 @@ cliqueConfig, err := core.LoadCliqueConfig(chainDb, config.Genesis) if err != nil { return nil, err } - engine := ethconfig.CreateConsensusEngine(stack, &ethashConfig, cliqueConfig, config.Miner.Notify, config.Miner.Noverify, chainDb) + + // CHANGE(taiko): set if `--taiko` flag is set. + var isTaiko bool + if config.Genesis != nil && config.Genesis.Config != nil { + isTaiko = config.Genesis.Config.Taiko + } + engine := ethconfig.CreateConsensusEngine(stack, &ethashConfig, cliqueConfig, config.Miner.Notify, config.Miner.Noverify, chainDb, isTaiko)   eth := &Ethereum{ config: config,

diff --git ethereum/go-ethereum/eth/taiko_api_backend.go taikoxyz/taiko-geth/eth/taiko_api_backend.go new file mode 100644 index 0000000000000000000000000000000000000000..8a651b5ca5b26d4bbc1b54b0d46cf0caa9c91806 --- /dev/null +++ taikoxyz/taiko-geth/eth/taiko_api_backend.go @@ -0,0 +1,111 @@ +package eth + +import ( + "math/big" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common/math" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/log" +) + +// TaikoAPIBackend handles l2 node related RPC calls. +type TaikoAPIBackend struct { + eth *Ethereum +} + +// NewTaikoAPIBackend creates a new TaikoAPIBackend instance. +func NewTaikoAPIBackend(eth *Ethereum) *TaikoAPIBackend { + return &TaikoAPIBackend{ + eth: eth, + } +} + +// HeadL1Origin returns the latest L2 block's corresponding L1 origin. +func (s *TaikoAPIBackend) HeadL1Origin() (*rawdb.L1Origin, error) { + blockID, err := rawdb.ReadHeadL1Origin(s.eth.ChainDb()) + if err != nil { + return nil, err + } + + if blockID == nil { + return nil, ethereum.NotFound + } + + l1Origin, err := rawdb.ReadL1Origin(s.eth.ChainDb(), blockID) + if err != nil { + return nil, err + } + + if l1Origin == nil { + return nil, ethereum.NotFound + } + + return l1Origin, nil +} + +// L1OriginByID returns the L2 block's corresponding L1 origin. +func (s *TaikoAPIBackend) L1OriginByID(blockID *math.HexOrDecimal256) (*rawdb.L1Origin, error) { + l1Origin, err := rawdb.ReadL1Origin(s.eth.ChainDb(), (*big.Int)(blockID)) + if err != nil { + return nil, err + } + + if l1Origin == nil { + return nil, ethereum.NotFound + } + + return l1Origin, nil +} + +// TxPoolContent retrieves the transaction pool content with the given upper limits. +func (s *TaikoAPIBackend) TxPoolContent( + maxTransactionsPerBlock uint64, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + minTxGasLimit uint64, + locals []string, +) ([]types.Transactions, error) { + pending := s.eth.TxPool().Pending(false) + + log.Debug( + "Fetching L2 pending transactions finished", + "length", core.PoolContent(pending).Len(), + "maxTransactionsPerBlock", maxTransactionsPerBlock, + "blockMaxGasLimit", blockMaxGasLimit, + "maxBytesPerTxList", maxBytesPerTxList, + "minTxGasLimit", minTxGasLimit, + "locals", locals, + ) + + contentSplitter, err := core.NewPoolContentSplitter( + s.eth.BlockChain().Config().ChainID, + maxTransactionsPerBlock, + blockMaxGasLimit, + maxBytesPerTxList, + minTxGasLimit, + locals, + ) + if err != nil { + return nil, err + } + + var ( + txsCount = 0 + txLists []types.Transactions + ) + for _, splittedTxs := range contentSplitter.Split(pending) { + if txsCount+splittedTxs.Len() < int(maxTransactionsPerBlock) { + txLists = append(txLists, splittedTxs) + txsCount += splittedTxs.Len() + continue + } + + txLists = append(txLists, splittedTxs[0:(int(maxTransactionsPerBlock)-txsCount)]) + break + } + + return txLists, nil +}

diff --git ethereum/go-ethereum/eth/state_accessor.go taikoxyz/taiko-geth/eth/state_accessor.go index 59b471425542fb4b1cb6241a537a7bd231b54512..68d40ac97a999df7a5800811a475c4d2d0515a06 100644 --- ethereum/go-ethereum/eth/state_accessor.go +++ taikoxyz/taiko-geth/eth/state_accessor.go @@ -212,7 +212,7 @@ // Recompute transactions up to the target index. signer := types.MakeSigner(eth.blockchain.Config(), block.Number()) for idx, tx := range block.Transactions() { // Assemble the transaction call message and return if the requested offset - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), idx == 0) txContext := core.NewEVMTxContext(msg) context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil) if idx == txIndex {

diff --git ethereum/go-ethereum/eth/tracers/api_test.go taikoxyz/taiko-geth/eth/tracers/api_test.go index b1eaf60b16c44e158f335248749b5b067fa23c44..af768ea809cae6ade84be659ab1be1acbdf7e890 100644 --- ethereum/go-ethereum/eth/tracers/api_test.go +++ taikoxyz/taiko-geth/eth/tracers/api_test.go @@ -171,7 +171,7 @@ } // Recompute transactions up to the target index. signer := types.MakeSigner(b.chainConfig, block.Number()) for idx, tx := range block.Transactions() { - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), idx == 0) txContext := core.NewEVMTxContext(msg) context := core.NewEVMBlockContext(block.Header(), b.chain, nil) if idx == txIndex {

diff --git ethereum/go-ethereum/eth/downloader/queue.go taikoxyz/taiko-geth/eth/downloader/queue.go index 5af5068c98cf424906d292a8fd70b670abbd562d..a35c9bd38bd722e41bf09dfb70515e1114d37044 100644 --- ethereum/go-ethereum/eth/downloader/queue.go +++ taikoxyz/taiko-geth/eth/downloader/queue.go @@ -22,6 +22,7 @@ import ( "errors" "fmt" + "os" "sync" "sync/atomic" "time" @@ -792,6 +793,17 @@ } else { // non-nil hash: body must have withdrawals if withdrawalLists[index] == nil { return errInvalidBody } + // CHANGE(taiko): change the empty withdrawalsRoot hash to EmptyCodeHash + if withdrawalListHashes[index] == types.EmptyRootHash { + if os.Getenv("TAIKO_TEST") == "" { + withdrawalListHashes[index] = common.HexToHash("0x569e75fc77c1a856f6daaf9e69d8a9566ca34aa47f9133711ce065a571af0cfd") + } + } else { + if os.Getenv("TAIKO_TEST") == "" { + withdrawalListHashes[index] = types.CalcWithdrawalsRootTaiko(withdrawalLists[index]) + } + } + if withdrawalListHashes[index] != *header.WithdrawalsHash { return errInvalidBody }

diff --git ethereum/go-ethereum/eth/tracers/api.go taikoxyz/taiko-geth/eth/tracers/api.go index 58ad0c3c9ad768f883047d7d75181253b81fe2f1..33acfd4509fb14c3ea891c9916db736a842178ef 100644 --- ethereum/go-ethereum/eth/tracers/api.go +++ taikoxyz/taiko-geth/eth/tracers/api.go @@ -293,7 +293,7 @@ blockCtx = core.NewEVMBlockContext(task.block.Header(), api.chainContext(ctx), nil) ) // Trace all the transactions contained within for i, tx := range task.block.Transactions() { - msg, _ := core.TransactionToMessage(tx, signer, task.block.BaseFee()) + msg, _ := core.TransactionToMessage(tx, signer, task.block.BaseFee(), i == 0) txctx := &Context{ BlockHash: task.block.Hash(), BlockNumber: task.block.Number(), @@ -554,7 +554,7 @@ if err := ctx.Err(); err != nil { return nil, err } var ( - msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee()) + msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), i == 0) txContext = core.NewEVMTxContext(msg) vmenv = vm.NewEVM(vmctx, txContext, statedb, chainConfig, vm.Config{}) ) @@ -628,7 +628,7 @@ results = make([]*txTraceResult, len(txs)) ) for i, tx := range txs { // Generate the next state snapshot fast without tracing - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), i == 0) txctx := &Context{ BlockHash: blockHash, BlockNumber: block.Number(), @@ -671,7 +671,7 @@ go func() { defer pend.Done() // Fetch and execute the next transaction trace tasks for task := range jobs { - msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee()) + msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee(), task.index == 0) txctx := &Context{ BlockHash: blockHash, BlockNumber: block.Number(), @@ -702,7 +702,7 @@ case jobs <- task: }   // Generate the next state snapshot fast without tracing - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), i == 0) statedb.SetTxContext(tx.Hash(), i) vmenv := vm.NewEVM(blockCtx, core.NewEVMTxContext(msg), statedb, api.backend.ChainConfig(), vm.Config{}) if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.GasLimit)); err != nil { @@ -782,7 +782,7 @@ } for i, tx := range block.Transactions() { // Prepare the transaction for un-traced execution var ( - msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee()) + msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), i == 0) txContext = core.NewEVMTxContext(msg) vmConf vm.Config dump *os.File

diff --git ethereum/go-ethereum/eth/tracers/tracers_test.go taikoxyz/taiko-geth/eth/tracers/tracers_test.go index 7c5ec65650ee5dc10a27ea4a408834da4cd8aa49..19bc44a59fe1dafdc59789cdc6809dab01f53c83 100644 --- ethereum/go-ethereum/eth/tracers/tracers_test.go +++ taikoxyz/taiko-geth/eth/tracers/tracers_test.go @@ -88,7 +88,7 @@ //EnableMemory: false, //EnableReturnData: false, }) evm := vm.NewEVM(context, txContext, statedb, params.AllEthashProtocolChanges, vm.Config{Debug: true, Tracer: tracer}) - msg, err := core.TransactionToMessage(tx, signer, nil) + msg, err := core.TransactionToMessage(tx, signer, nil, false) if err != nil { b.Fatalf("failed to prepare transaction for tracing: %v", err) }

diff --git ethereum/go-ethereum/eth/ethconfig/config.go taikoxyz/taiko-geth/eth/ethconfig/config.go index db686c5d0875f43f099e401865558f7ccf2b9224..0a0cde53c5a89de6ec3ae42d51210e6a31c4df19 100644 --- ethereum/go-ethereum/eth/ethconfig/config.go +++ taikoxyz/taiko-geth/eth/ethconfig/config.go @@ -29,6 +29,7 @@ "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/beacon" "github.com/ethereum/go-ethereum/consensus/clique" "github.com/ethereum/go-ethereum/consensus/ethash" + "github.com/ethereum/go-ethereum/consensus/taiko" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/txpool" "github.com/ethereum/go-ethereum/eth/downloader" @@ -210,7 +211,12 @@ OverrideShanghai *uint64 `toml:",omitempty"` }   // CreateConsensusEngine creates a consensus engine for the given chain configuration. -func CreateConsensusEngine(stack *node.Node, ethashConfig *ethash.Config, cliqueConfig *params.CliqueConfig, notify []string, noverify bool, db ethdb.Database) consensus.Engine { +func CreateConsensusEngine(stack *node.Node, ethashConfig *ethash.Config, cliqueConfig *params.CliqueConfig, notify []string, noverify bool, db ethdb.Database, isTaiko bool) consensus.Engine { + // CHANGE(taiko): use Taiko consensus engine when the --taiko flag is set. + if isTaiko { + return taiko.New() + } + // If proof-of-authority is requested, set it up var engine consensus.Engine if cliqueConfig != nil {

diff --git ethereum/go-ethereum/eth/catalyst/api.go taikoxyz/taiko-geth/eth/catalyst/api.go index 9077f20bffccb108ca46e6b334b1fb5464c74c21..6ee71b3f7a5243fdce3769c6cc35c501ce98d097 100644 --- ethereum/go-ethereum/eth/catalyst/api.go +++ taikoxyz/taiko-geth/eth/catalyst/api.go @@ -214,6 +214,7 @@ if update.HeadBlockHash == (common.Hash{}) { log.Warn("Forkchoice requested update to zero hash") return engine.STATUS_INVALID, nil // TODO(karalabe): Why does someone send us this? } + // Stash away the last update to warn the user if the beacon client goes offline api.lastForkchoiceLock.Lock() api.lastForkchoiceUpdate = time.Now() @@ -289,6 +290,10 @@ PayloadStatus: engine.PayloadStatusV1{Status: engine.VALID, LatestValidHash: &update.HeadBlockHash}, PayloadID: id, } } + + // CHANGE(taiko): check whether --taiko flag is set. + isTaiko := api.eth.BlockChain().Config().Taiko + if rawdb.ReadCanonicalHash(api.eth.ChainDb(), block.NumberU64()) != update.HeadBlockHash { // Block is not canonical, set head. if latestValid, err := api.eth.BlockChain().SetCanonical(block); err != nil { @@ -298,6 +303,10 @@ } else if api.eth.BlockChain().CurrentBlock().Hash() == update.HeadBlockHash { // If the specified head matches with our local head, do nothing and keep // generating the payload. It's a special corner case that a few slots are // missing and we are requested to generate the payload in slot. + } else if isTaiko { // CHANGE(taiko): reorg is allowed in L2. + if latestValid, err := api.eth.BlockChain().SetCanonical(block); err != nil { + return engine.ForkChoiceResponse{PayloadStatus: engine.PayloadStatusV1{Status: engine.INVALID, LatestValidHash: &latestValid}}, err + } } else { // If the head block is already in our canonical chain, the beacon client is // probably resyncing. Ignore the update. @@ -342,6 +351,57 @@ // If payload generation was requested, create a new block to be potentially // sealed by the beacon client. The payload will be requested later, and we // will replace it arbitrarily many times in between. if payloadAttributes != nil { + // CHANGE(taiko): create a L2 block by Taiko protocol. + if isTaiko { + // No need to check payloadAttribute here, because all its fields are + // marked as required. + + block, err := api.eth.Miner().SealBlockWith( + update.HeadBlockHash, + payloadAttributes.Timestamp, + payloadAttributes.BlockMetadata, + payloadAttributes.BaseFeePerGas, + payloadAttributes.Withdrawals, + types.CalcWithdrawalsRootTaiko(payloadAttributes.Withdrawals), + ) + if err != nil { + log.Error("Failed to create sealing block", "err", err) + return valid(nil), engine.InvalidPayloadAttributes.With(err) + } + + // Cache the mined block for later use. + args := &miner.BuildPayloadArgs{ + Parent: block.ParentHash(), + Timestamp: block.Time(), + FeeRecipient: block.Coinbase(), + Random: block.MixDigest(), + Withdrawals: block.Withdrawals(), + } + id := args.Id() + payload, err := api.eth.Miner().BuildPayload(args) + if err != nil { + log.Error("Failed to build payload", "err", err) + return valid(nil), engine.InvalidPayloadAttributes.With(err) + } + + payload.SetFullBlock(block, common.Big0) + + api.localBlocks.put(id, payload) + + // L1Origin **MUST NOT** be nil, it's a required field in PayloadAttributesV1. + l1Origin := payloadAttributes.L1Origin + + // Set the block hash before inserting the L1Origin into database. + l1Origin.L2BlockHash = block.Hash() + + // Write L1Origin. + rawdb.WriteL1Origin(api.eth.ChainDb(), l1Origin.BlockID, l1Origin) + // Write the head L1Origin. + rawdb.WriteHeadL1Origin(api.eth.ChainDb(), l1Origin.BlockID) + + return valid(&id), nil + } + args := &miner.BuildPayloadArgs{ Parent: update.HeadBlockHash, Timestamp: payloadAttributes.Timestamp, @@ -430,7 +490,8 @@ // NewPayloadV2 creates an Eth1 block, inserts it in the chain, and returns the status of the chain. func (api *ConsensusAPI) NewPayloadV2(params engine.ExecutableData) (engine.PayloadStatusV1, error) { if api.eth.BlockChain().Config().IsShanghai(params.Timestamp) { - if params.Withdrawals == nil { + if params.Withdrawals == nil && + (api.eth.BlockChain().Config().Taiko && params.WithdrawalsHash == (common.Hash{})) { // CHANGE(taiko): allow only passing `WithdrawalsHash` return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(fmt.Errorf("nil withdrawals post-shanghai")) } } else if params.Withdrawals != nil { @@ -457,10 +518,37 @@ api.newPayloadLock.Lock() defer api.newPayloadLock.Unlock()   log.Trace("Engine API request received", "method", "NewPayload", "number", params.Number, "hash", params.BlockHash) - block, err := engine.ExecutableDataToBlock(params) - if err != nil { - log.Debug("Invalid NewPayload params", "params", params, "error", err) - return engine.PayloadStatusV1{Status: engine.INVALID}, nil + // CHANGE(taiko): allow passing the executable data with txHash instead of all transactions. + var ( + block *types.Block + err error + ) + params.TaikoBlock = api.eth.BlockChain().Config().Taiko + if api.eth.BlockChain().Config().Taiko && params.Transactions == nil && params.Withdrawals == nil { + block = types.NewBlockWithHeader(&types.Header{ + ParentHash: params.ParentHash, + UncleHash: types.EmptyUncleHash, + Coinbase: params.FeeRecipient, + Root: params.StateRoot, + TxHash: params.TxHash, + ReceiptHash: params.ReceiptsRoot, + Bloom: types.BytesToBloom(params.LogsBloom), + Difficulty: common.Big0, + Number: new(big.Int).SetUint64(params.Number), + GasLimit: params.GasLimit, + GasUsed: params.GasUsed, + Time: params.Timestamp, + BaseFee: params.BaseFeePerGas, + Extra: params.ExtraData, + MixDigest: params.Random, + WithdrawalsHash: &params.WithdrawalsHash, + }) + } else { + block, err = engine.ExecutableDataToBlock(params) + if err != nil { + log.Debug("Invalid NewPayload params", "params", params, "error", err) + return engine.PayloadStatusV1{Status: engine.INVALID}, nil + } } // Stash away the last update to warn the user if the beacon client goes offline api.lastNewPayloadLock.Lock() @@ -503,9 +591,18 @@ if parent.Difficulty().BitLen() > 0 && gptd != nil && gptd.Cmp(ttd) >= 0 { log.Error("Ignoring pre-merge parent block", "number", params.Number, "hash", params.BlockHash, "td", ptd, "ttd", ttd) return engine.INVALID_TERMINAL_BLOCK, nil } - if block.Time() <= parent.Time() { - log.Warn("Invalid timestamp", "parent", block.Time(), "block", block.Time()) - return api.invalid(errors.New("invalid timestamp"), parent.Header()), nil + // CHANGE(taiko): a block that has the same timestamp as its parents is + // allowed in Taiko protocol. + if api.eth.BlockChain().Config().Taiko { + if block.Time() < parent.Time() { + log.Warn("Invalid timestamp", "parent", block.Time(), "block", block.Time()) + return api.invalid(errors.New("invalid timestamp"), parent.Header()), nil + } + } else { + if block.Time() <= parent.Time() { + log.Warn("Invalid timestamp", "parent", block.Time(), "block", block.Time()) + return api.invalid(errors.New("invalid timestamp"), parent.Header()), nil + } } // Another cornercase: if the node is in snap sync mode, but the CL client // tries to make it import a block. That should be denied as pushing something

diff --git ethereum/go-ethereum/ethclient/taiko_api_test.go taikoxyz/taiko-geth/ethclient/taiko_api_test.go new file mode 100644 index 0000000000000000000000000000000000000000..010ba0472c31e8665fd58747417f3e80637a2ebb --- /dev/null +++ taikoxyz/taiko-geth/ethclient/taiko_api_test.go @@ -0,0 +1,128 @@ +package ethclient + +import ( + "context" + "crypto/rand" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/ethash" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rpc" + "github.com/stretchr/testify/require" +) + +func newTaikoAPITestClient(t *testing.T) (*Client, []*types.Block, ethdb.Database) { + // Generate test chain. + blocks := generateTestChain() + + // Create node + n, err := node.New(&node.Config{}) + + require.Nil(t, err) + + // Create Ethereum Service + config := &ethconfig.Config{Genesis: genesis} + config.Ethash.PowMode = ethash.ModeFake + ethservice, err := eth.New(n, config) + require.Nil(t, err) + + n.RegisterAPIs([]rpc.API{ + { + Namespace: "taiko", + Version: params.VersionWithMeta, + Service: eth.NewTaikoAPIBackend(ethservice), + Public: true, + }, + }) + + // Start node + require.Nil(t, n.Start()) + + // Insert test blocks + _, err = ethservice.BlockChain().InsertChain(blocks[1:]) + + require.Nil(t, err) + + rpcClient, _ := n.Attach() + + return NewClient(rpcClient), blocks, ethservice.ChainDb() +} + +func TestHeadL1Origin(t *testing.T) { + ec, blocks, db := newTaikoAPITestClient(t) + + headerHash := blocks[len(blocks)-1].Hash() + + l1OriginFound, err := ec.HeadL1Origin(context.Background()) + + require.Equal(t, ethereum.NotFound.Error(), err.Error()) + require.Nil(t, l1OriginFound) + + testL1Origin := &rawdb.L1Origin{ + BlockID: randomBigInt(), + L2BlockHash: headerHash, + L1BlockHeight: randomBigInt(), + L1BlockHash: randomHash(), + } + + rawdb.WriteL1Origin(db, testL1Origin.BlockID, testL1Origin) + rawdb.WriteHeadL1Origin(db, testL1Origin.BlockID) + + l1OriginFound, err = ec.HeadL1Origin(context.Background()) + + require.Nil(t, err) + require.Equal(t, testL1Origin, l1OriginFound) +} + +func TestL1OriginByID(t *testing.T) { + ec, blocks, db := newTaikoAPITestClient(t) + + headerHash := blocks[len(blocks)-1].Hash() + testL1Origin := &rawdb.L1Origin{ + BlockID: randomBigInt(), + L2BlockHash: headerHash, + L1BlockHeight: randomBigInt(), + L1BlockHash: randomHash(), + } + + l1OriginFound, err := ec.L1OriginByID(context.Background(), testL1Origin.BlockID) + require.Equal(t, ethereum.NotFound.Error(), err.Error()) + require.Nil(t, l1OriginFound) + + rawdb.WriteL1Origin(db, testL1Origin.BlockID, testL1Origin) + rawdb.WriteHeadL1Origin(db, testL1Origin.BlockID) + + l1OriginFound, err = ec.L1OriginByID(context.Background(), testL1Origin.BlockID) + + require.Nil(t, err) + require.Equal(t, testL1Origin, l1OriginFound) +} + +// randomHash generates a random blob of data and returns it as a hash. +func randomHash() common.Hash { + var hash common.Hash + if n, err := rand.Read(hash[:]); n != common.HashLength || err != nil { + panic(err) + } + return hash +} + +// randomBigInt generates a random big integer. +func randomBigInt() *big.Int { + randomBigInt, err := rand.Int(rand.Reader, common.Big256) + if err != nil { + log.Crit(err.Error()) + } + + return randomBigInt +}

diff --git ethereum/go-ethereum/ethclient/taiko_api.go taikoxyz/taiko-geth/ethclient/taiko_api.go new file mode 100644 index 0000000000000000000000000000000000000000..9637608d062f16bbc7e855d81647e8babe3c8ab9 --- /dev/null +++ taikoxyz/taiko-geth/ethclient/taiko_api.go @@ -0,0 +1,31 @@ +package ethclient + +import ( + "context" + "math/big" + + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/rawdb" +) + +// HeadL1Origin returns the latest L2 block's corresponding L1 origin. +func (ec *Client) HeadL1Origin(ctx context.Context) (*rawdb.L1Origin, error) { + var res *rawdb.L1Origin + + if err := ec.c.CallContext(ctx, &res, "taiko_headL1Origin"); err != nil { + return nil, err + } + + return res, nil +} + +// L1OriginByID returns the L2 block's corresponding L1 origin. +func (ec *Client) L1OriginByID(ctx context.Context, blockID *big.Int) (*rawdb.L1Origin, error) { + var res *rawdb.L1Origin + + if err := ec.c.CallContext(ctx, &res, "taiko_l1OriginByID", hexutil.EncodeBig(blockID)); err != nil { + return nil, err + } + + return res, nil +}

diff --git ethereum/go-ethereum/les/client.go taikoxyz/taiko-geth/les/client.go index 9ac85ecdac6fb5d2f41c88f13ad9e5fd37ae09c2..494a12ffdb67490ef4b42052a73be786b7730b94 100644 --- ethereum/go-ethereum/les/client.go +++ taikoxyz/taiko-geth/les/client.go @@ -126,7 +126,7 @@ eventMux: stack.EventMux(), reqDist: newRequestDistributor(peers, &mclock.System{}), accountManager: stack.AccountManager(), merger: merger, - engine: ethconfig.CreateConsensusEngine(stack, &config.Ethash, chainConfig.Clique, nil, false, chainDb), + engine: ethconfig.CreateConsensusEngine(stack, &config.Ethash, chainConfig.Clique, nil, false, chainDb, chainConfig.Taiko), bloomRequests: make(chan chan *bloombits.Retrieval), bloomIndexer: core.NewBloomIndexer(chainDb, params.BloomBitsBlocksClient, params.HelperTrieConfirmations), p2pServer: stack.Server(),

diff --git ethereum/go-ethereum/les/state_accessor.go taikoxyz/taiko-geth/les/state_accessor.go index 030d6b5a50044abe36d871f474c14a64c9eef77c..68c52486dda77f43f958f88f0d8a479cd49de3ce 100644 --- ethereum/go-ethereum/les/state_accessor.go +++ taikoxyz/taiko-geth/les/state_accessor.go @@ -60,7 +60,7 @@ // Recompute transactions up to the target index. signer := types.MakeSigner(leth.blockchain.Config(), block.Number()) for idx, tx := range block.Transactions() { // Assemble the transaction call message and return if the requested offset - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), idx == 0) txContext := core.NewEVMTxContext(msg) context := core.NewEVMBlockContext(block.Header(), leth.blockchain, nil) statedb.SetTxContext(tx.Hash(), idx)

diff --git ethereum/go-ethereum/miner/taiko_miner.go taikoxyz/taiko-geth/miner/taiko_miner.go new file mode 100644 index 0000000000000000000000000000000000000000..5344897ff9a1520a8a07cfe600997f204efaaf0a --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_miner.go @@ -0,0 +1,21 @@ +package miner + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/beacon/engine" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// SealBlockWith mines and seals a block without changing the canonical chain. +func (miner *Miner) SealBlockWith( + parent common.Hash, + timestamp uint64, + blkMeta *engine.BlockMetadata, + baseFeePerGas *big.Int, + withdrawals types.Withdrawals, + withdrawalsHash common.Hash, +) (*types.Block, error) { + return miner.worker.sealBlockWith(parent, timestamp, blkMeta, baseFeePerGas, withdrawals, withdrawalsHash) +}

diff --git ethereum/go-ethereum/miner/payload_building.go taikoxyz/taiko-geth/miner/payload_building.go index f84d908e86d68dbb132e2cd75ba5e21887fc018c..ccfb462539d2fff747e5f1b1757e444f1ef6b159 100644 --- ethereum/go-ethereum/miner/payload_building.go +++ taikoxyz/taiko-geth/miner/payload_building.go @@ -179,6 +179,10 @@ for { select { case <-timer.C: + // CHANGE(taiko): do not update payload. + if w.chainConfig.Taiko { + continue + } start := time.Now() block, fees, err := w.getSealingBlock(args.Parent, args.Timestamp, args.FeeRecipient, args.Random, args.Withdrawals, false) if err == nil {

diff --git ethereum/go-ethereum/miner/taiko_worker.go taikoxyz/taiko-geth/miner/taiko_worker.go new file mode 100644 index 0000000000000000000000000000000000000000..888f8f75a48f100f4b1ed3733c7882558af0b739 --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_worker.go @@ -0,0 +1,102 @@ +package miner + +import ( + "fmt" + "math/big" + + "github.com/ethereum/go-ethereum/beacon/engine" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" +) + +// sealBlockWith mines and seals a block with the given block metadata. +func (w *worker) sealBlockWith( + parent common.Hash, + timestamp uint64, + blkMeta *engine.BlockMetadata, + baseFeePerGas *big.Int, + withdrawals types.Withdrawals, + withdrawalsHash common.Hash, +) (*types.Block, error) { + // Decode transactions bytes. + var txs types.Transactions + if err := rlp.DecodeBytes(blkMeta.TxList, &txs); err != nil { + return nil, fmt.Errorf("failed to decode txList: %w", err) + } + + if len(txs) == 0 { + // A L2 block needs to have have at least one `V1TaikoL2.anchor` or + // `V1TaikoL2.invalidateBlock` transaction. + return nil, fmt.Errorf("too less transactions in the block") + } + + params := &generateParams{ + timestamp: timestamp, + forceTime: true, + parentHash: parent, + coinbase: blkMeta.Beneficiary, + random: blkMeta.MixHash, + withdrawals: withdrawals, + noUncle: true, + noTxs: false, + baseFeePerGas: baseFeePerGas, + } + + env, err := w.prepareWork(params) + if err != nil { + return nil, err + } + defer env.discard() + + // Set the block fields using the given block metadata: + // 1. gas limit + // 2. extra data + // 3. withdrawals hash + env.header.GasLimit = blkMeta.GasLimit + env.header.Extra = blkMeta.ExtraData + env.header.WithdrawalsHash = &withdrawalsHash + + // Commit transactions. + commitErrs := make([]error, 0, len(txs)) + gasLimit := env.header.GasLimit + rules := w.chain.Config().Rules(env.header.Number, true, timestamp) + + env.gasPool = new(core.GasPool).AddGas(gasLimit) + + for i, tx := range txs { + sender, err := types.LatestSignerForChainID(tx.ChainId()).Sender(tx) + if err != nil { + log.Info("Skip an invalid proposed transaction", "hash", tx.Hash(), "reason", err) + commitErrs = append(commitErrs, err) + continue + } + + env.state.Prepare(rules, sender, blkMeta.Beneficiary, tx.To(), vm.ActivePrecompiles(rules), tx.AccessList()) + env.state.SetTxContext(tx.Hash(), env.tcount) + if _, err := w.commitTransaction(env, tx, i == 0); err != nil { + log.Info("Skip an invalid proposed transaction", "hash", tx.Hash(), "reason", err) + commitErrs = append(commitErrs, err) + continue + } + env.tcount++ + } + // TODO: save the commit transactions errors for generating witness. + _ = commitErrs + + block, err := w.engine.FinalizeAndAssemble(w.chain, env.header, env.state, env.txs, nil, env.receipts, withdrawals) + if err != nil { + return nil, err + } + + results := make(chan *types.Block, 1) + if err := w.engine.Seal(w.chain, block, results, nil); err != nil { + return nil, err + } + block = <-results + + return block, nil +}

diff --git ethereum/go-ethereum/miner/taiko_payload_building.go taikoxyz/taiko-geth/miner/taiko_payload_building.go new file mode 100644 index 0000000000000000000000000000000000000000..8b086e45472f4d2228e4c5eb6c4a2df433e2efdf --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_payload_building.go @@ -0,0 +1,35 @@ +package miner + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" +) + +// SetFullBlock updates the full-block to the given block. +func (payload *Payload) SetFullBlock(block *types.Block, fees *big.Int) { + payload.lock.Lock() + defer payload.lock.Unlock() + + go func() { + payload.lock.Lock() + defer payload.lock.Unlock() + + select { + case payload.stop <- struct{}{}: + default: + } + }() + + payload.full = block + payload.fullFees = fees + + feesInEther := new(big.Float).Quo(new(big.Float).SetInt(fees), big.NewFloat(params.Ether)) + log.Info("Updated payload", "id", payload.id, "number", block.NumberU64(), "hash", block.Hash(), + "txs", len(block.Transactions()), "gas", block.GasUsed(), "fees", feesInEther, + "root", block.Root()) + + payload.cond.Broadcast() // fire signal for notifying full block +}

diff --git ethereum/go-ethereum/miner/worker.go taikoxyz/taiko-geth/miner/worker.go index 67a5842d23e0ddecfd019821081032a01ae69ea9..3855e95bd6ff19bba49cb42291bc13000ad1f2d9 100644 --- ethereum/go-ethereum/miner/worker.go +++ taikoxyz/taiko-geth/miner/worker.go @@ -860,12 +860,12 @@ w.snapshotReceipts = copyReceipts(env.receipts) w.snapshotState = env.state.Copy() }   -func (w *worker) commitTransaction(env *environment, tx *types.Transaction) ([]*types.Log, error) { +func (w *worker) commitTransaction(env *environment, tx *types.Transaction, isAnchor bool) ([]*types.Log, error) { var ( snap = env.state.Snapshot() gp = env.gasPool.Gas() ) - receipt, err := core.ApplyTransaction(w.chainConfig, w.chain, &env.coinbase, env.gasPool, env.state, env.header, tx, &env.header.GasUsed, *w.chain.GetVMConfig()) + receipt, err := core.ApplyTransaction(w.chainConfig, w.chain, &env.coinbase, env.gasPool, env.state, env.header, tx, &env.header.GasUsed, *w.chain.GetVMConfig(), isAnchor) if err != nil { env.state.RevertToSnapshot(snap) env.gasPool.SetGas(gp) @@ -916,7 +916,7 @@ } // Start executing the transaction env.state.SetTxContext(tx.Hash(), env.tcount)   - logs, err := w.commitTransaction(env, tx) + logs, err := w.commitTransaction(env, tx, false) switch { case errors.Is(err, core.ErrGasLimitReached): // Pop the current out-of-gas transaction without shifting in the next from the account @@ -971,14 +971,15 @@ }   // generateParams wraps various of settings for generating sealing task. type generateParams struct { - timestamp uint64 // The timstamp for sealing task - forceTime bool // Flag whether the given timestamp is immutable or not - parentHash common.Hash // Parent block hash, empty means the latest chain head - coinbase common.Address // The fee recipient address for including transaction - random common.Hash // The randomness generated by beacon chain, empty before the merge - withdrawals types.Withdrawals // List of withdrawals to include in block. - noUncle bool // Flag whether the uncle block inclusion is allowed - noTxs bool // Flag whether an empty block without any transaction is expected + timestamp uint64 // The timstamp for sealing task + forceTime bool // Flag whether the given timestamp is immutable or not + parentHash common.Hash // Parent block hash, empty means the latest chain head + coinbase common.Address // The fee recipient address for including transaction + random common.Hash // The randomness generated by beacon chain, empty before the merge + withdrawals types.Withdrawals // List of withdrawals to include in block. + noUncle bool // Flag whether the uncle block inclusion is allowed + noTxs bool // Flag whether an empty block without any transaction is expected + baseFeePerGas *big.Int // CHANGE(taiko): The base fee per gas for the next block }   // prepareWork constructs the sealing task according to the given parameters, @@ -1001,10 +1002,17 @@ // Sanity check the timestamp correctness, recap the timestamp // to parent+1 if the mutation is allowed. timestamp := genParams.timestamp if parent.Time >= timestamp { - if genParams.forceTime { - return nil, fmt.Errorf("invalid timestamp, parent %d given %d", parent.Time, timestamp) + // CHANGE(taiko): block.timestamp == parent.timestamp is allowed in Taiko protocol. + if !w.chainConfig.Taiko { + if genParams.forceTime { + return nil, fmt.Errorf("invalid timestamp, parent %d given %d", parent.Time, timestamp) + } + timestamp = parent.Time + 1 + } else { + if parent.Time > timestamp { + return nil, fmt.Errorf("invalid timestamp, parent %d given %d", parent.Time, timestamp) + } } - timestamp = parent.Time + 1 } // Construct the sealing block header. header := &types.Header{ @@ -1024,10 +1032,14 @@ header.MixDigest = genParams.random } // Set baseFee and GasLimit if we are on an EIP-1559 chain if w.chainConfig.IsLondon(header.Number) { - header.BaseFee = misc.CalcBaseFee(w.chainConfig, parent) - if !w.chainConfig.IsLondon(parent.Number) { - parentGasLimit := parent.GasLimit * w.chainConfig.ElasticityMultiplier() - header.GasLimit = core.CalcGasLimit(parentGasLimit, w.config.GasCeil) + if w.chainConfig.Taiko && genParams.baseFeePerGas != nil { + header.BaseFee = genParams.baseFeePerGas + } else { + header.BaseFee = misc.CalcBaseFee(w.chainConfig, parent) + if !w.chainConfig.IsLondon(parent.Number) { + parentGasLimit := parent.GasLimit * w.chainConfig.ElasticityMultiplier() + header.GasLimit = core.CalcGasLimit(parentGasLimit, w.config.GasCeil) + } } } // Run the consensus preparation with the default or customized consensus engine.

diff --git ethereum/go-ethereum/params/taiko_config.go taikoxyz/taiko-geth/params/taiko_config.go new file mode 100644 index 0000000000000000000000000000000000000000..fdefe66da8b32fd37bfbe1c211af6fce8f0e9ad3 --- /dev/null +++ taikoxyz/taiko-geth/params/taiko_config.go @@ -0,0 +1,39 @@ +package params + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" +) + +func u64(val uint64) *uint64 { return &val } + +// Network IDs +var ( + TaikoMainnetNetworkID = big.NewInt(167) + TaikoInternal1NetworkID = big.NewInt(167001) + TaikoInternal2NetworkID = big.NewInt(167002) + SnæfellsjökullNetworkID = big.NewInt(167003) + AskjaNetworkID = big.NewInt(167004) + GrimsvotnNetworkID = big.NewInt(167005) +) + +var TaikoChainConfig = &ChainConfig{ + ChainID: TaikoMainnetNetworkID, // Use mainnet network ID by default. + HomesteadBlock: common.Big0, + EIP150Block: common.Big0, + EIP155Block: common.Big0, + EIP158Block: common.Big0, + ByzantiumBlock: common.Big0, + ConstantinopleBlock: common.Big0, + PetersburgBlock: common.Big0, + IstanbulBlock: common.Big0, + BerlinBlock: common.Big0, + LondonBlock: common.Big0, + ShanghaiTime: u64(0), + MergeNetsplitBlock: nil, + TerminalTotalDifficulty: common.Big0, + TerminalTotalDifficultyPassed: true, + Taiko: true, + Treasury: common.HexToAddress("0xdf09A0afD09a63fb04ab3573922437e1e637dE8b"), +}

diff --git ethereum/go-ethereum/params/config.go taikoxyz/taiko-geth/params/config.go index e04b16673c6b8a360ad9d20e97ff5ddf8e0e07ec..617a661adb918e5768379e2d88d5636c7f8cf7b8 100644 --- ethereum/go-ethereum/params/config.go +++ taikoxyz/taiko-geth/params/config.go @@ -351,6 +351,13 @@ MainnetChainConfig.ChainID.String(): "mainnet", RinkebyChainConfig.ChainID.String(): "rinkeby", GoerliChainConfig.ChainID.String(): "goerli", SepoliaChainConfig.ChainID.String(): "sepolia", + // CHANGE(taiko): add Taiko network name. + TaikoMainnetNetworkID.String(): "Taiko", + TaikoInternal1NetworkID.String(): "Taiko Internal 1", + TaikoInternal2NetworkID.String(): "Taiko Internal 2", + SnæfellsjökullNetworkID.String(): "Taiko Alpha-1 (Snæfellsjökull)", + AskjaNetworkID.String(): "Taiko Alpha-2 (Askja)", + GrimsvotnNetworkID.String(): "Taiko Alpha-3 L2 (Grímsvötn)", }   // TrustedCheckpoint represents a set of post-processed trie roots (CHT and @@ -450,6 +457,10 @@ // Various consensus engines Ethash *EthashConfig `json:"ethash,omitempty"` Clique *CliqueConfig `json:"clique,omitempty"` + + // CHANGE(taiko): Taiko network flag. + Taiko bool `json:"taiko"` + Treasury common.Address `json:"treasury"` }   // EthashConfig is the consensus engine configs for proof-of-work based sealing. @@ -482,6 +493,9 @@ network = "unknown" } banner += fmt.Sprintf("Chain ID: %v (%s)\n", c.ChainID, network) switch { + // CHANGE(taiko): print Taiko consensus engine in banner. + case c.Taiko: + banner += "Consensus: Taiko\n" case c.Ethash != nil: if c.TerminalTotalDifficulty == nil { banner += "Consensus: Ethash (proof-of-work)\n"