taiko-geth

diff --git ethereum/go-ethereum/beacon/engine/gen_blockmetadata.go taikoxyz/taiko-geth/beacon/engine/gen_blockmetadata.go new file mode 100644 index 0000000000000000000000000000000000000000..3b0edb54939aa6fc11ea8462a53c971c83cd8c46 --- /dev/null +++ taikoxyz/taiko-geth/beacon/engine/gen_blockmetadata.go @@ -0,0 +1,82 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package engine + +import ( + "encoding/json" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" +) + +var _ = (*blockMetadataMarshaling)(nil) + +// MarshalJSON marshals as JSON. +func (b BlockMetadata) MarshalJSON() ([]byte, error) { + type BlockMetadata struct { + Beneficiary common.Address `json:"beneficiary" gencodec:"required"` + GasLimit uint64 `json:"gasLimit" gencodec:"required"` + Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"` + MixHash common.Hash `json:"mixHash" gencodec:"required"` + TxList hexutil.Bytes `json:"txList" gencodec:"required"` + HighestBlockID *big.Int `json:"highestBlockID" gencodec:"required"` + ExtraData []byte `json:"extraData" gencodec:"required"` + } + var enc BlockMetadata + enc.Beneficiary = b.Beneficiary + enc.GasLimit = b.GasLimit + enc.Timestamp = hexutil.Uint64(b.Timestamp) + enc.MixHash = b.MixHash + enc.TxList = b.TxList + enc.HighestBlockID = b.HighestBlockID + enc.ExtraData = b.ExtraData + return json.Marshal(&enc) +} + +// UnmarshalJSON unmarshals from JSON. +func (b *BlockMetadata) UnmarshalJSON(input []byte) error { + type BlockMetadata struct { + Beneficiary *common.Address `json:"beneficiary" gencodec:"required"` + GasLimit *uint64 `json:"gasLimit" gencodec:"required"` + Timestamp *hexutil.Uint64 `json:"timestamp" gencodec:"required"` + MixHash *common.Hash `json:"mixHash" gencodec:"required"` + TxList *hexutil.Bytes `json:"txList" gencodec:"required"` + HighestBlockID *big.Int `json:"highestBlockID" gencodec:"required"` + ExtraData []byte `json:"extraData" gencodec:"required"` + } + var dec BlockMetadata + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Beneficiary == nil { + return errors.New("missing required field 'beneficiary' for BlockMetadata") + } + b.Beneficiary = *dec.Beneficiary + if dec.GasLimit == nil { + return errors.New("missing required field 'gasLimit' for BlockMetadata") + } + b.GasLimit = *dec.GasLimit + if dec.Timestamp == nil { + return errors.New("missing required field 'timestamp' for BlockMetadata") + } + b.Timestamp = uint64(*dec.Timestamp) + if dec.MixHash == nil { + return errors.New("missing required field 'mixHash' for BlockMetadata") + } + b.MixHash = *dec.MixHash + if dec.TxList == nil { + return errors.New("missing required field 'txList' for BlockMetadata") + } + b.TxList = *dec.TxList + if dec.HighestBlockID == nil { + return errors.New("missing required field 'highestBlockID' for BlockMetadata") + } + b.HighestBlockID = dec.HighestBlockID + if dec.ExtraData == nil { + return errors.New("missing required field 'extraData' for BlockMetadata") + } + b.ExtraData = dec.ExtraData + return nil +}

diff --git ethereum/go-ethereum/beacon/engine/gen_blockparams.go taikoxyz/taiko-geth/beacon/engine/gen_blockparams.go index b1f01b50ff8e3b1adf0454ff989356a6f612a337..e2ac09feef9b6ad8385b974c784377d565bef381 100644 --- ethereum/go-ethereum/beacon/engine/gen_blockparams.go +++ taikoxyz/taiko-geth/beacon/engine/gen_blockparams.go @@ -5,9 +5,11 @@ import ( "encoding/json" "errors" + "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" )   @@ -21,6 +23,9 @@ Random common.Hash `json:"prevRandao" gencodec:"required"` SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"` + BaseFeePerGas *big.Int `json:"baseFeePerGas" gencodec:"required"` + BlockMetadata *BlockMetadata `json:"blockMetadata" gencodec:"required"` + L1Origin *rawdb.L1Origin `json:"l1Origin" gencodec:"required"` } var enc PayloadAttributes enc.Timestamp = hexutil.Uint64(p.Timestamp) @@ -28,6 +33,9 @@ enc.Random = p.Random enc.SuggestedFeeRecipient = p.SuggestedFeeRecipient enc.Withdrawals = p.Withdrawals enc.BeaconRoot = p.BeaconRoot + enc.BaseFeePerGas = p.BaseFeePerGas + enc.BlockMetadata = p.BlockMetadata + enc.L1Origin = p.L1Origin return json.Marshal(&enc) }   @@ -39,6 +47,9 @@ Random *common.Hash `json:"prevRandao" gencodec:"required"` SuggestedFeeRecipient *common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"` + BaseFeePerGas *big.Int `json:"baseFeePerGas" gencodec:"required"` + BlockMetadata *BlockMetadata `json:"blockMetadata" gencodec:"required"` + L1Origin *rawdb.L1Origin `json:"l1Origin" gencodec:"required"` } var dec PayloadAttributes if err := json.Unmarshal(input, &dec); err != nil { @@ -62,5 +73,17 @@ } if dec.BeaconRoot != nil { p.BeaconRoot = dec.BeaconRoot } + if dec.BaseFeePerGas == nil { + return errors.New("missing required field 'baseFeePerGas' for PayloadAttributes") + } + p.BaseFeePerGas = dec.BaseFeePerGas + if dec.BlockMetadata == nil { + return errors.New("missing required field 'blockMetadata' for PayloadAttributes") + } + p.BlockMetadata = dec.BlockMetadata + if dec.L1Origin == nil { + return errors.New("missing required field 'l1Origin' for PayloadAttributes") + } + p.L1Origin = dec.L1Origin return nil }

diff --git ethereum/go-ethereum/beacon/engine/gen_ed.go taikoxyz/taiko-geth/beacon/engine/gen_ed.go index 6893d64a1626a8e172a80865a5ccec6e4e0f53f6..b3ea4ad2a70d53938b551c2efd01fddb032a9e9d 100644 --- ethereum/go-ethereum/beacon/engine/gen_ed.go +++ taikoxyz/taiko-geth/beacon/engine/gen_ed.go @@ -17,23 +17,26 @@ // MarshalJSON marshals as JSON. func (e ExecutableData) MarshalJSON() ([]byte, error) { 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 hexutil.Bytes `json:"logsBloom" gencodec:"required"` - Random common.Hash `json:"prevRandao" gencodec:"required"` - Number hexutil.Uint64 `json:"blockNumber" gencodec:"required"` - GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"` - GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` - Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"` - ExtraData hexutil.Bytes `json:"extraData" gencodec:"required"` - BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` - BlockHash common.Hash `json:"blockHash" gencodec:"required"` - Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` - Withdrawals []*types.Withdrawal `json:"withdrawals"` - BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` - ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` + 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 hexutil.Bytes `json:"logsBloom" gencodec:"required"` + Random common.Hash `json:"prevRandao" gencodec:"required"` + Number hexutil.Uint64 `json:"blockNumber" gencodec:"required"` + GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` + Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"` + ExtraData hexutil.Bytes `json:"extraData" gencodec:"required"` + BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` + BlockHash common.Hash `json:"blockHash" gencodec:"required"` + Transactions []hexutil.Bytes `json:"transactions"` + Withdrawals []*types.Withdrawal `json:"withdrawals"` + BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` + ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` + TxHash common.Hash `json:"txHash"` + WithdrawalsHash common.Hash `json:"withdrawalsHash"` + TaikoBlock bool } var enc ExecutableData enc.ParentHash = e.ParentHash @@ -58,29 +61,35 @@ } enc.Withdrawals = e.Withdrawals enc.BlobGasUsed = (*hexutil.Uint64)(e.BlobGasUsed) enc.ExcessBlobGas = (*hexutil.Uint64)(e.ExcessBlobGas) + enc.TxHash = e.TxHash + enc.WithdrawalsHash = e.WithdrawalsHash + enc.TaikoBlock = e.TaikoBlock return json.Marshal(&enc) }   // UnmarshalJSON unmarshals from JSON. func (e *ExecutableData) UnmarshalJSON(input []byte) error { 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 *hexutil.Bytes `json:"logsBloom" gencodec:"required"` - Random *common.Hash `json:"prevRandao" gencodec:"required"` - Number *hexutil.Uint64 `json:"blockNumber" gencodec:"required"` - GasLimit *hexutil.Uint64 `json:"gasLimit" gencodec:"required"` - GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` - Timestamp *hexutil.Uint64 `json:"timestamp" gencodec:"required"` - ExtraData *hexutil.Bytes `json:"extraData" gencodec:"required"` - BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` - BlockHash *common.Hash `json:"blockHash" gencodec:"required"` - Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` - Withdrawals []*types.Withdrawal `json:"withdrawals"` - BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` - ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` + 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 *hexutil.Bytes `json:"logsBloom" gencodec:"required"` + Random *common.Hash `json:"prevRandao" gencodec:"required"` + Number *hexutil.Uint64 `json:"blockNumber" gencodec:"required"` + GasLimit *hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` + Timestamp *hexutil.Uint64 `json:"timestamp" gencodec:"required"` + ExtraData *hexutil.Bytes `json:"extraData" gencodec:"required"` + BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` + BlockHash *common.Hash `json:"blockHash" gencodec:"required"` + Transactions []hexutil.Bytes `json:"transactions"` + Withdrawals []*types.Withdrawal `json:"withdrawals"` + BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` + ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` + TxHash *common.Hash `json:"txHash"` + WithdrawalsHash *common.Hash `json:"withdrawalsHash"` + TaikoBlock *bool } var dec ExecutableData if err := json.Unmarshal(input, &dec); err != nil { @@ -138,12 +147,11 @@ if dec.BlockHash == nil { return errors.New("missing required field 'blockHash' for ExecutableData") } e.BlockHash = *dec.BlockHash - if dec.Transactions == nil { - return errors.New("missing required field 'transactions' for ExecutableData") - } - e.Transactions = make([][]byte, len(dec.Transactions)) - for k, v := range dec.Transactions { - e.Transactions[k] = v + if dec.Transactions != nil { + e.Transactions = make([][]byte, len(dec.Transactions)) + for k, v := range dec.Transactions { + e.Transactions[k] = v + } } if dec.Withdrawals != nil { e.Withdrawals = dec.Withdrawals @@ -153,6 +161,15 @@ e.BlobGasUsed = (*uint64)(dec.BlobGasUsed) } if dec.ExcessBlobGas != nil { e.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas) + } + if dec.TxHash != nil { + e.TxHash = *dec.TxHash + } + if dec.WithdrawalsHash != nil { + e.WithdrawalsHash = *dec.WithdrawalsHash + } + if dec.TaikoBlock != nil { + e.TaikoBlock = *dec.TaikoBlock } return nil }

diff --git ethereum/go-ethereum/beacon/engine/types.go taikoxyz/taiko-geth/beacon/engine/types.go index 60accc3c7917cd162b6212e8932259c640fa1c0b..b246c77515004615df5137e169d7d1aaa16201d0 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" ) @@ -46,6 +47,11 @@ Random common.Hash `json:"prevRandao" gencodec:"required"` SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"` + + // 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. @@ -53,6 +59,29 @@ type payloadAttributesMarshaling struct { Timestamp hexutil.Uint64 }   +//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. +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"` + + // Extra fields required in taiko-geth. + TxList []byte `json:"txList" gencodec:"required"` + HighestBlockID *big.Int `json:"highestBlockID" gencodec:"required"` + ExtraData []byte `json:"extraData" gencodec:"required"` +} + +// CHANGE(taiko): JSON type overrides for BlockMetadata. +type blockMetadataMarshaling struct { + Timestamp hexutil.Uint64 + TxList hexutil.Bytes +} + //go:generate go run github.com/fjl/gencodec -type ExecutableData -field-override executableDataMarshaling -out gen_ed.go   // ExecutableData is the data necessary to execute an EL payload. @@ -70,10 +99,14 @@ 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"` + Transactions [][]byte `json:"transactions"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BlobGasUsed *uint64 `json:"blobGasUsed"` ExcessBlobGas *uint64 `json:"excessBlobGas"` + + 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.

diff --git ethereum/go-ethereum/cmd/geth/config.go taikoxyz/taiko-geth/cmd/geth/config.go index 5f52f1df54423289b352083d1fcd672296d79571..2f4b684f3ca1c63c9df895312c02ef5c8c366d89 100644 --- ethereum/go-ethereum/cmd/geth/config.go +++ taikoxyz/taiko-geth/cmd/geth/config.go @@ -179,6 +179,9 @@ cfg.Eth.OverrideVerkle = &v } backend, eth := utils.RegisterEthService(stack, &cfg.Eth)   + // CHANGE(TAIKO): register Taiko RPC APIs. + utils.RegisterTaikoAPIs(stack, &cfg.Eth, eth) + // Create gauge with geth system and build information if eth != nil { // The 'eth' backend may be nil in light mode var protos []string

diff --git ethereum/go-ethereum/cmd/geth/main.go taikoxyz/taiko-geth/cmd/geth/main.go index 2f7d37fdd7e7b7a8d69f2a7be749bdd9d34a21bb..1d9c439ff8cbf611811620dbf9dfc7983e0fc3e3 100644 --- ethereum/go-ethereum/cmd/geth/main.go +++ taikoxyz/taiko-geth/cmd/geth/main.go @@ -143,6 +143,8 @@ utils.GpoBlocksFlag, utils.GpoPercentileFlag, utils.GpoMaxGasPriceFlag, utils.GpoIgnoreGasPriceFlag, + // CHANGE(taiko): use default gas price flag + utils.GpoDefaultGasPriceFlag, configFileFlag, utils.LogDebugFlag, utils.LogBacktraceAtFlag, @@ -248,6 +250,9 @@ consoleFlags, debug.Flags, metricsFlags, ) + // CHANGE(taiko): append Taiko flags into the original GETH flags + app.Flags = append(app.Flags, &utils.TaikoFlag) + flags.AutoEnvVars(app.Flags, "GETH")   app.Before = func(ctx *cli.Context) error {

diff --git ethereum/go-ethereum/cmd/utils/flags.go taikoxyz/taiko-geth/cmd/utils/flags.go index b813e52970d82a99205240866c8d291044b18161..0ff166a1f938acf65c0b816f526abce24bbd38e9 100644 --- ethereum/go-ethereum/cmd/utils/flags.go +++ taikoxyz/taiko-geth/cmd/utils/flags.go @@ -813,6 +813,12 @@ Usage: "Gas price below which gpo will ignore transactions", Value: ethconfig.Defaults.GPO.IgnorePrice.Int64(), Category: flags.GasPriceCategory, } + // CHANGE(taiko): use default gas price flag + GpoDefaultGasPriceFlag = &cli.Int64Flag{ + Name: "gpo.defaultprice", + Usage: "Default gas price", + Category: flags.GasPriceCategory, + }   // Metrics flags MetricsEnabledFlag = &cli.BoolFlag{ @@ -1450,6 +1456,10 @@ } if ctx.IsSet(GpoIgnoreGasPriceFlag.Name) { cfg.IgnorePrice = big.NewInt(ctx.Int64(GpoIgnoreGasPriceFlag.Name)) } + // CHANGE(taiko): use flag + if ctx.IsSet(GpoDefaultGasPriceFlag.Name) { + cfg.Default = big.NewInt(ctx.Int64(GpoDefaultGasPriceFlag.Name)) + } }   func setTxPool(ctx *cli.Context, cfg *legacypool.Config) { @@ -1730,6 +1740,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

diff --git ethereum/go-ethereum/cmd/utils/taiko_flags.go taikoxyz/taiko-geth/cmd/utils/taiko_flags.go new file mode 100644 index 0000000000000000000000000000000000000000..54279f3fedc1eb82e5cb5b3dfb1d76e59bb79dca --- /dev/null +++ taikoxyz/taiko-geth/cmd/utils/taiko_flags.go @@ -0,0 +1,41 @@ +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, + }, + { + Namespace: "taikoAuth", + Version: params.VersionWithMeta, + Service: eth.NewTaikoAuthAPIBackend(backend), + Authenticated: true, + }, + }) +}

diff --git ethereum/go-ethereum/consensus/taiko/consensus.go taikoxyz/taiko-geth/consensus/taiko/consensus.go new file mode 100644 index 0000000000000000000000000000000000000000..04e64ca47df8c22dad5b905abbf871d3b45c1796 --- /dev/null +++ taikoxyz/taiko-geth/consensus/taiko/consensus.go @@ -0,0 +1,321 @@ +package taiko + +import ( + "bytes" + "errors" + "fmt" + "math/big" + "strings" + "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/crypto" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rpc" + "github.com/ethereum/go-ethereum/trie" + "github.com/holiman/uint256" +) + +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") + ErrAnchorTxNotFound = errors.New("anchor transaction not found") + + GoldenTouchAccount = common.HexToAddress("0x0000777735367b36bC9B61C50022d9D0700dB4Ec") + TaikoL2AddressSuffix = "10001" + AnchorSelector = crypto.Keccak256([]byte("anchor(bytes32,bytes32,uint64,uint32)"))[:4] + AnchorGasLimit = uint64(250_000) +) + +// Taiko is a consensus engine used by L2 rollup. +type Taiko struct { + chainConfig *params.ChainConfig + taikoL2Address common.Address +} + +var _ = new(Taiko) + +func New(chainConfig *params.ChainConfig) *Taiko { + taikoL2AddressPrefix := strings.TrimPrefix(chainConfig.ChainID.String(), "0") + + return &Taiko{ + chainConfig: chainConfig, + taikoL2Address: common.HexToAddress( + "0x" + + taikoL2AddressPrefix + + strings.Repeat("0", common.AddressLength*2-len(taikoL2AddressPrefix)-len(TaikoL2AddressSuffix)) + + TaikoL2AddressSuffix, + ), + } +} + +// 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) 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, 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) (chan<- struct{}, <-chan error) { + if len(headers) == 0 { + return make(chan struct{}), make(chan error, len(headers)) + } + abort := make(chan struct{}) + results := make(chan error, len(headers)) + unixNow := time.Now().Unix() + + go func() { + for i, header := range headers { + var parent *types.Header + if i == 0 { + parent = chain.GetHeader(headers[0].ParentHash, headers[0].Number.Uint64()-1) + } else if headers[i-1].Hash() == headers[i].ParentHash { + parent = headers[i-1] + } + var err error + if parent == nil { + err = consensus.ErrUnknownAncestor + } else { + err = t.verifyHeader(chain, header, parent, unixNow) + } + select { + case <-abort: + return + case results <- err: + } + } + }() + return abort, results +} + +func (t *Taiko) verifyHeader(chain consensus.ChainHeaderReader, header, parent *types.Header, 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 +} + +// 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, uint256.MustFromBig(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) + } + + // Verify anchor transaction + if len(txs) != 0 { // Transactions list might be empty when building empty payload. + isAnchor, err := t.ValidateAnchorTx(txs[0], header) + if err != nil { + return nil, err + } + if !isAnchor { + return nil, ErrAnchorTxNotFound + } + } + + // Finalize block + t.Finalize(chain, header, state, txs, uncles, withdrawals) + return types.NewBlockWithWithdrawals( + 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 +} + +// ValidateAnchorTx checks if the given transaction is a valid TaikoL2.anchor transaction. +func (t *Taiko) ValidateAnchorTx(tx *types.Transaction, header *types.Header) (bool, error) { + if tx.Type() != types.DynamicFeeTxType { + return false, nil + } + + if tx.To() == nil || *tx.To() != t.taikoL2Address { + return false, nil + } + + if !bytes.HasPrefix(tx.Data(), AnchorSelector) { + return false, nil + } + + if tx.Value().Cmp(common.Big0) != 0 { + return false, nil + } + + if tx.Gas() != AnchorGasLimit { + return false, nil + } + + if tx.GasFeeCap().Cmp(header.BaseFee) != 0 { + return false, nil + } + + s := types.MakeSigner(t.chainConfig, header.Number, header.Time) + + addr, err := s.Sender(tx) + if err != nil { + return false, err + } + + return strings.EqualFold(addr.String(), GoldenTouchAccount.String()), nil +} + +// 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/consensus/taiko/consensus_test.go taikoxyz/taiko-geth/consensus/taiko/consensus_test.go new file mode 100644 index 0000000000000000000000000000000000000000..3e06ac658129b6763fe68417eab9d5ce99191179 --- /dev/null +++ taikoxyz/taiko-geth/consensus/taiko/consensus_test.go @@ -0,0 +1,237 @@ +package taiko_test + +import ( + "bytes" + "math/big" + "strings" + "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/ethereum/go-ethereum/triedb" + "github.com/stretchr/testify/assert" +) + +var ( + testL2RollupAddress = common.HexToAddress("0x79fcdef22feed20eddacbb2587640e45491b757f") + testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + goldenTouchKey, _ = crypto.HexToECDSA("92954368afd3caa1f3ce3ead0069c1af414054aefe1ef9aeacc1bf426222ce38") + 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(config) + + taikoL2AddressPrefix := strings.TrimPrefix(config.ChainID.String(), "0") + + taikoL2Address := common.HexToAddress( + "0x" + + taikoL2AddressPrefix + + strings.Repeat("0", common.AddressLength*2-len(taikoL2AddressPrefix)-len(taiko.TaikoL2AddressSuffix)) + + taiko.TaikoL2AddressSuffix, + ) + + genesis = &core.Genesis{ + Config: config, + Alloc: types.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(goldenTouchKey, types.LatestSigner(genesis.Config), &types.DynamicFeeTx{ + Nonce: 0, + GasTipCap: common.Big0, + GasFeeCap: new(big.Int).SetUint64(875_000_000), + Data: taiko.AnchorSelector, + Gas: taiko.AnchorGasLimit, + To: &taikoL2Address, + }), + 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 i, tx := range txs { + if i == 0 { + if err := tx.MarkAsAnchor(); err != nil { + panic(err) + } + } + g.AddTx(tx) + } + } + + gblock := genesis.MustCommit(db, triedb.NewDatabase(db, triedb.HashDefaults)) + + 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()) + 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, + }) + 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, + }) + 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, + }) + 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, + }) + 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, + }) + 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, + }) + 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, + }) + assert.ErrorContains(t, err, "uncles not empty", "VerifyHeader should throw ErrUnclesNotEmpty if uncles is not the empty hash") +}

diff --git ethereum/go-ethereum/core/state_processor.go taikoxyz/taiko-geth/core/state_processor.go index 9e32ab4e569600636e88bd8c6579771bfdb18733..f953b1098680a9a2efd334f36d27c32d3ccb5206 100644 --- ethereum/go-ethereum/core/state_processor.go +++ taikoxyz/taiko-geth/core/state_processor.go @@ -81,6 +81,12 @@ ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } // Iterate over and process the individual transactions for i, tx := range block.Transactions() { + // CHANGE(taiko): mark the first transaction as anchor transaction. + if i == 0 && p.config.Taiko { + if err := tx.MarkAsAnchor(); err != nil { + return nil, nil, 0, err + } + } msg, err := TransactionToMessage(tx, signer, header.BaseFee) if err != nil { return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)

diff --git ethereum/go-ethereum/core/state_transition.go taikoxyz/taiko-geth/core/state_transition.go index 9c4f76d1c58538b9fe8ead870c989f27bfbd70b6..031979784f9b00f12ab7e078f59f6bd6cb202cbf 100644 --- ethereum/go-ethereum/core/state_transition.go +++ taikoxyz/taiko-geth/core/state_transition.go @@ -20,6 +20,7 @@ import ( "fmt" "math" "math/big" + "strings"   "github.com/ethereum/go-ethereum/common" cmath "github.com/ethereum/go-ethereum/common/math" @@ -145,6 +146,9 @@ // When SkipAccountChecks 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): whether the current transaction is the first TaikoL2.anchor transaction in a block. + IsAnchor bool }   // TransactionToMessage converts a transaction into a Message. @@ -162,6 +166,7 @@ AccessList: tx.AccessList(), SkipAccountChecks: false, BlobHashes: tx.BlobHashes(), BlobGasFeeCap: tx.BlobGasFeeCap(), + IsAnchor: tx.IsAnchor(), } // If baseFee provided, set gasPrice to effectiveGasPrice. if baseFee != nil { @@ -257,6 +262,10 @@ balanceCheckU256, overflow := uint256.FromBig(balanceCheck) if overflow { return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) } + if st.msg.IsAnchor { + balanceCheckU256 = common.U2560 + mgval = common.Big0 + } if have, want := st.state.GetBalance(st.msg.From), balanceCheckU256; have.Cmp(want) < 0 { return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From.Hex(), have, want) } @@ -297,7 +306,8 @@ } // 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) - skipCheck := st.evm.Config.NoBaseFee && msg.GasFeeCap.BitLen() == 0 && msg.GasTipCap.BitLen() == 0 + skipCheck := (st.evm.Config.NoBaseFee && msg.GasFeeCap.BitLen() == 0 && msg.GasTipCap.BitLen() == 0) || + st.msg.IsAnchor if !skipCheck { if l := msg.GasFeeCap.BitLen(); l > 256 { return fmt.Errorf("%w: address %v, maxFeePerGas bit length: %d", ErrFeeCapVeryHigh, @@ -457,6 +467,13 @@ } else { fee := new(uint256.Int).SetUint64(st.gasUsed()) fee.Mul(fee, effectiveTipU256) 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.msg.IsAnchor { + st.state.AddBalance( + st.getTreasuryAddress(), + uint256.MustFromBig(new(big.Int).Mul(st.evm.Context.BaseFee, new(big.Int).SetUint64(st.gasUsed()))), + ) + } }   return &ExecutionResult{ @@ -475,10 +492,13 @@ refund = st.state.GetRefund() } st.gasRemaining += refund   - // Return ETH for remaining gas, exchanged at the original rate. - remaining := uint256.NewInt(st.gasRemaining) - remaining = remaining.Mul(remaining, uint256.MustFromBig(st.msg.GasPrice)) - st.state.AddBalance(st.msg.From, remaining) + // Do not change the balance in anchor transactions. + if !st.msg.IsAnchor { + // Return ETH for remaining gas, exchanged at the original rate. + remaining := uint256.NewInt(st.gasRemaining) + remaining = remaining.Mul(remaining, uint256.MustFromBig(st.msg.GasPrice)) + st.state.AddBalance(st.msg.From, remaining) + }   // Also return remaining gas to the block gas counter so it is // available for the next transaction. @@ -496,3 +516,17 @@ // blobGasUsed returns the amount of blob gas used by the message. func (st *StateTransition) blobGasUsed() uint64 { return uint64(len(st.msg.BlobHashes) * params.BlobTxBlobGasPerBlob) } + +// CHANGE(taiko): returns the treasury address based on chain ID. +func (st *StateTransition) getTreasuryAddress() common.Address { + var ( + prefix = st.evm.ChainConfig().ChainID.String() + suffix = "10001" + ) + return common.HexToAddress( + "0x" + + prefix + + strings.Repeat("0", common.AddressLength*2-len(prefix)-len(suffix)) + + suffix, + ) +}

diff --git ethereum/go-ethereum/core/taiko_genesis.go taikoxyz/taiko-geth/core/taiko_genesis.go new file mode 100644 index 0000000000000000000000000000000000000000..80a06c72db7a99b1ab44f6bc9b0ba9bf4f6d4fc4 --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_genesis.go @@ -0,0 +1,67 @@ +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.TaikoMainnetNetworkID.Uint64(): + chainConfig.ChainID = params.TaikoMainnetNetworkID + allocJSON = taikoGenesis.MainnetGenesisAllocJSON + case params.TaikoInternalL2ANetworkID.Uint64(): + chainConfig.ChainID = params.TaikoInternalL2ANetworkID + allocJSON = taikoGenesis.InternalL2AGenesisAllocJSON + case params.TaikoInternalL2BNetworkID.Uint64(): + chainConfig.ChainID = params.TaikoInternalL2BNetworkID + allocJSON = taikoGenesis.InternalL2BGenesisAllocJSON + case params.SnaefellsjokullNetworkID.Uint64(): + chainConfig.ChainID = params.SnaefellsjokullNetworkID + allocJSON = taikoGenesis.SnaefellsjokullGenesisAllocJSON + case params.AskjaNetworkID.Uint64(): + chainConfig.ChainID = params.AskjaNetworkID + allocJSON = taikoGenesis.AskjaGenesisAllocJSON + case params.GrimsvotnNetworkID.Uint64(): + chainConfig.ChainID = params.GrimsvotnNetworkID + allocJSON = taikoGenesis.GrimsvotnGenesisAllocJSON + case params.EldfellNetworkID.Uint64(): + chainConfig.ChainID = params.EldfellNetworkID + allocJSON = taikoGenesis.EldfellGenesisAllocJSON + case params.JolnirNetworkID.Uint64(): + chainConfig.ChainID = params.JolnirNetworkID + allocJSON = taikoGenesis.JolnirGenesisAllocJSON + case params.KatlaNetworkID.Uint64(): + chainConfig.ChainID = params.KatlaNetworkID + allocJSON = taikoGenesis.KatlaGenesisAllocJSON + case params.HeklaNetworkID.Uint64(): + chainConfig.ChainID = params.HeklaNetworkID + allocJSON = taikoGenesis.HeklaGenesisAllocJSON + default: + chainConfig.ChainID = params.TaikoInternalL2ANetworkID + allocJSON = taikoGenesis.InternalL2AGenesisAllocJSON + } + + 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(15_000_000), + Difficulty: common.Big0, + Alloc: alloc, + GasUsed: 0, + BaseFee: new(big.Int).SetUint64(10_000_000), + } +}

diff --git ethereum/go-ethereum/core/rawdb/gen_taiko_l1_origin.go taikoxyz/taiko-geth/core/rawdb/gen_taiko_l1_origin.go new file mode 100644 index 0000000000000000000000000000000000000000..6cbd6c3cdbc0a1f87d5e816e6103b2a2d082354b --- /dev/null +++ taikoxyz/taiko-geth/core/rawdb/gen_taiko_l1_origin.go @@ -0,0 +1,60 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package rawdb + +import ( + "encoding/json" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" +) + +var _ = (*l1OriginMarshaling)(nil) + +// MarshalJSON marshals as JSON. +func (l L1Origin) MarshalJSON() ([]byte, error) { + type L1Origin struct { + BlockID *math.HexOrDecimal256 `json:"blockID" gencodec:"required"` + L2BlockHash common.Hash `json:"l2BlockHash"` + L1BlockHeight *math.HexOrDecimal256 `json:"l1BlockHeight" gencodec:"required"` + L1BlockHash common.Hash `json:"l1BlockHash" gencodec:"required"` + } + var enc L1Origin + enc.BlockID = (*math.HexOrDecimal256)(l.BlockID) + enc.L2BlockHash = l.L2BlockHash + enc.L1BlockHeight = (*math.HexOrDecimal256)(l.L1BlockHeight) + enc.L1BlockHash = l.L1BlockHash + return json.Marshal(&enc) +} + +// UnmarshalJSON unmarshals from JSON. +func (l *L1Origin) UnmarshalJSON(input []byte) error { + type L1Origin struct { + BlockID *math.HexOrDecimal256 `json:"blockID" gencodec:"required"` + L2BlockHash *common.Hash `json:"l2BlockHash"` + L1BlockHeight *math.HexOrDecimal256 `json:"l1BlockHeight" gencodec:"required"` + L1BlockHash *common.Hash `json:"l1BlockHash" gencodec:"required"` + } + var dec L1Origin + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.BlockID == nil { + return errors.New("missing required field 'blockID' for L1Origin") + } + l.BlockID = (*big.Int)(dec.BlockID) + if dec.L2BlockHash != nil { + l.L2BlockHash = *dec.L2BlockHash + } + if dec.L1BlockHeight == nil { + return errors.New("missing required field 'l1BlockHeight' for L1Origin") + } + l.L1BlockHeight = (*big.Int)(dec.L1BlockHeight) + if dec.L1BlockHash == nil { + return errors.New("missing required field 'l1BlockHash' for L1Origin") + } + l.L1BlockHash = *dec.L1BlockHash + return nil +}

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/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/taiko_genesis/genesis_alloc.go taikoxyz/taiko-geth/core/taiko_genesis/genesis_alloc.go new file mode 100644 index 0000000000000000000000000000000000000000..dbaf56f8dc6e805f8b2eef3bd628a72521cb1156 --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_genesis/genesis_alloc.go @@ -0,0 +1,35 @@ +package taiko_genesis + +import ( + _ "embed" +) + +//go:embed internal_l2a.json +var InternalL2AGenesisAllocJSON []byte + +//go:embed internal_l2b.json +var InternalL2BGenesisAllocJSON []byte + +//go:embed snaefellsjokull.json +var SnaefellsjokullGenesisAllocJSON []byte + +//go:embed askja.json +var AskjaGenesisAllocJSON []byte + +//go:embed grimsvotn.json +var GrimsvotnGenesisAllocJSON []byte + +//go:embed eldfell.json +var EldfellGenesisAllocJSON []byte + +//go:embed jolnir.json +var JolnirGenesisAllocJSON []byte + +//go:embed katla.json +var KatlaGenesisAllocJSON []byte + +//go:embed hekla.json +var HeklaGenesisAllocJSON []byte + +//go:embed mainnet.json +var MainnetGenesisAllocJSON []byte

diff --git ethereum/go-ethereum/core/txpool/validation.go taikoxyz/taiko-geth/core/txpool/validation.go index 8913859e846e73c032120dd9110791e6a1954d9d..8afc57e0a3d9e5b3c0a9530e87995c62f8b00049 100644 --- ethereum/go-ethereum/core/txpool/validation.go +++ taikoxyz/taiko-geth/core/txpool/validation.go @@ -18,8 +18,10 @@ package txpool   import ( "crypto/sha256" + "errors" "fmt" "math/big" + "os"   "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" @@ -95,6 +97,10 @@ } // Ensure gasFeeCap is greater than or equal to gasTipCap if tx.GasFeeCapIntCmp(tx.GasTipCap()) < 0 { return core.ErrTipAboveFeeCap + } + // CHANGE(taiko): check gasFeeCap. + if os.Getenv("TAIKO_TEST") == "" && tx.GasFeeCap().Cmp(common.Big0) == 0 { + return errors.New("max fee per gas is 0") } // Make sure the transaction is signed properly if _, err := types.Sender(signer, tx); err != nil {

diff --git ethereum/go-ethereum/core/types/taiko_transaction.go taikoxyz/taiko-geth/core/types/taiko_transaction.go new file mode 100644 index 0000000000000000000000000000000000000000..d9cd9fb4a42d96124b3a338a18cf7280db17e420 --- /dev/null +++ taikoxyz/taiko-geth/core/types/taiko_transaction.go @@ -0,0 +1,42 @@ +package types + +func (tx *Transaction) MarkAsAnchor() error { + return tx.inner.markAsAnchor() +} + +func (tx *Transaction) IsAnchor() bool { + return tx.inner.isAnchor() +} + +func (tx *DynamicFeeTx) isAnchor() bool { + return tx.isAnhcor +} + +func (tx *LegacyTx) isAnchor() bool { + return false +} + +func (tx *AccessListTx) isAnchor() bool { + return false +} + +func (tx *BlobTx) isAnchor() bool { + return false +} + +func (tx *DynamicFeeTx) markAsAnchor() error { + tx.isAnhcor = true + return nil +} + +func (tx *LegacyTx) markAsAnchor() error { + return ErrInvalidTxType +} + +func (tx *AccessListTx) markAsAnchor() error { + return ErrInvalidTxType +} + +func (tx *BlobTx) markAsAnchor() error { + return ErrInvalidTxType +}

diff --git ethereum/go-ethereum/core/types/transaction.go taikoxyz/taiko-geth/core/types/transaction.go index 7d2e9d5325a642ea87fe388f59f592a264e287f8..ae5fe9ee7e797a39621fd5a4a1896c2ed86fbaeb 100644 --- ethereum/go-ethereum/core/types/transaction.go +++ taikoxyz/taiko-geth/core/types/transaction.go @@ -87,6 +87,10 @@ value() *big.Int nonce() uint64 to() *common.Address   + // CHANGE(taiko): anchor transaction related. + isAnchor() bool + markAsAnchor() error + rawSignatureValues() (v, r, s *big.Int) setSignatureValues(chainID, v, r, s *big.Int)   @@ -589,3 +593,15 @@ } cpy := *a return &cpy } + +// CHANGE(taiko): SetBlobTxSidecar sets the sidecar of a transaction. +// The sidecar should match the blob-tx versioned hashes, or the transaction will be invalid. +// This allows tools to easily re-attach blob sidecars to signed transactions that omit the sidecar. +func (tx *Transaction) SetBlobTxSidecar(sidecar *BlobTxSidecar) error { + blobtx, ok := tx.inner.(*BlobTx) + if !ok { + return fmt.Errorf("not a blob tx, type = %d", tx.Type()) + } + blobtx.Sidecar = sidecar + return nil +}

diff --git ethereum/go-ethereum/core/types/tx_dynamic_fee.go taikoxyz/taiko-geth/core/types/tx_dynamic_fee.go index 8b5b514fdec5b58fc8058e582a0a7c355e0ccba8..96a3f105d58c060121e99d12d1b6b63e3dbf5c93 100644 --- ethereum/go-ethereum/core/types/tx_dynamic_fee.go +++ taikoxyz/taiko-geth/core/types/tx_dynamic_fee.go @@ -40,6 +40,9 @@ // Signature values V *big.Int `json:"v" gencodec:"required"` R *big.Int `json:"r" gencodec:"required"` S *big.Int `json:"s" gencodec:"required"` + + // CHANGE(taiko): if this transaction is the first TaikoL2.anchor transaction in a block + isAnhcor bool }   // copy creates a deep copy of the transaction data and initializes all fields. @@ -58,6 +61,7 @@ GasFeeCap: new(big.Int), V: new(big.Int), R: new(big.Int), S: new(big.Int), + isAnhcor: tx.isAnhcor, } copy(cpy.AccessList, tx.AccessList) if tx.Value != nil {

diff --git ethereum/go-ethereum/eth/state_accessor.go taikoxyz/taiko-geth/eth/state_accessor.go index 526361a2b8a6da8d3a5c7a0e56a37238f500cd1c..8b2bb6bb1ad93ab1ff9fa2a76ff1e3c422948e1a 100644 --- ethereum/go-ethereum/eth/state_accessor.go +++ taikoxyz/taiko-geth/eth/state_accessor.go @@ -239,6 +239,11 @@ } // Recompute transactions up to the target index. signer := types.MakeSigner(eth.blockchain.Config(), block.Number(), block.Time()) for idx, tx := range block.Transactions() { + if idx == 0 && eth.config.Genesis.Config.Taiko { + if err := tx.MarkAsAnchor(); err != nil { + return nil, vm.BlockContext{}, nil, nil, err + } + } // Assemble the transaction call message and return if the requested offset msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) txContext := core.NewEVMTxContext(msg)

diff --git ethereum/go-ethereum/eth/taiko_api_backend.go taikoxyz/taiko-geth/eth/taiko_api_backend.go new file mode 100644 index 0000000000000000000000000000000000000000..aa506d40b9ccbdd55500b3467677fa532d2e8545 --- /dev/null +++ taikoxyz/taiko-geth/eth/taiko_api_backend.go @@ -0,0 +1,135 @@ +package eth + +import ( + "math/big" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/miner" +) + +// 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 +} + +// GetSyncMode returns the node sync mode. +func (s *TaikoAPIBackend) GetSyncMode() (string, error) { + return s.eth.config.SyncMode.String(), nil +} + +// TaikoAuthAPIBackend handles L2 node related authorized RPC calls. +type TaikoAuthAPIBackend struct { + eth *Ethereum +} + +// NewTaikoAuthAPIBackend creates a new TaikoAuthAPIBackend instance. +func NewTaikoAuthAPIBackend(eth *Ethereum) *TaikoAuthAPIBackend { + return &TaikoAuthAPIBackend{eth} +} + +// TxPoolContent retrieves the transaction pool content with the given upper limits. +func (a *TaikoAuthAPIBackend) TxPoolContent( + beneficiary common.Address, + baseFee *big.Int, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + locals []string, + maxTransactionsLists uint64, +) ([]*miner.PreBuiltTxList, error) { + log.Debug( + "Fetching L2 pending transactions finished", + "baseFee", baseFee, + "blockMaxGasLimit", blockMaxGasLimit, + "maxBytesPerTxList", maxBytesPerTxList, + "maxTransactions", maxTransactionsLists, + "locals", locals, + ) + + return a.eth.Miner().BuildTransactionsLists( + beneficiary, + baseFee, + blockMaxGasLimit, + maxBytesPerTxList, + locals, + maxTransactionsLists, + ) +} + +// TxPoolContentWithMinTip retrieves the transaction pool content with the given upper limits and minimum tip. +func (a *TaikoAuthAPIBackend) TxPoolContentWithMinTip( + beneficiary common.Address, + baseFee *big.Int, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + locals []string, + maxTransactionsLists uint64, + minTip uint64, +) ([]*miner.PreBuiltTxList, error) { + log.Debug( + "Fetching L2 pending transactions finished", + "baseFee", baseFee, + "blockMaxGasLimit", blockMaxGasLimit, + "maxBytesPerTxList", maxBytesPerTxList, + "maxTransactions", maxTransactionsLists, + "locals", locals, + "minTip", minTip, + ) + + return a.eth.Miner().BuildTransactionsListsWithMinTip( + beneficiary, + baseFee, + blockMaxGasLimit, + maxBytesPerTxList, + locals, + maxTransactionsLists, + minTip, + ) +}

diff --git ethereum/go-ethereum/eth/catalyst/api.go taikoxyz/taiko-geth/eth/catalyst/api.go index 58566a47fc6c36d3eca9f2dcb1f52c5de8010fa5..c37cee4e02ebb4512af9c9933e3dffd0b3f35957 100644 --- ethereum/go-ethereum/eth/catalyst/api.go +++ taikoxyz/taiko-geth/eth/catalyst/api.go @@ -20,6 +20,7 @@ import ( "errors" "fmt" + "math/big" "sync" "time"   @@ -318,6 +319,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 { @@ -327,6 +332,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. @@ -371,6 +380,56 @@ // 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, + ) + 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(), + Version: payloadVersion, + } + 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, @@ -491,7 +550,8 @@ if api.eth.BlockChain().Config().IsCancun(api.eth.BlockChain().Config().LondonBlock, params.Timestamp) { return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("can't use newPayloadV2 post-cancun")) } if api.eth.BlockChain().Config().LatestFork(params.Timestamp) == forks.Shanghai { - if params.Withdrawals == nil { + if params.Withdrawals == nil && + (api.eth.BlockChain().Config().Taiko && params.WithdrawalsHash == (common.Hash{})) { return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("nil withdrawals post-shanghai")) } } else { @@ -551,10 +611,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, versionedHashes, beaconRoot) - if err != nil { - log.Warn("Invalid NewPayload params", "params", params, "error", err) - return api.invalid(err, nil), 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, versionedHashes, beaconRoot) + 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() @@ -597,9 +684,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 corner case: 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/eth/ethconfig/config.go taikoxyz/taiko-geth/eth/ethconfig/config.go index ad664afb5bd1fa68165f23bfd30ef5c82eb0a7e0..a26d5adedaf45a6df36ebc4014f9f53a4af5956f 100644 --- ethereum/go-ethereum/eth/ethconfig/config.go +++ taikoxyz/taiko-geth/eth/ethconfig/config.go @@ -26,6 +26,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/blobpool" "github.com/ethereum/go-ethereum/core/txpool/legacypool" @@ -165,6 +166,10 @@ // CreateConsensusEngine creates a consensus engine for the given chain config. // Clique is allowed for now to live standalone, but ethash is forbidden and can // only exist on already merged networks. func CreateConsensusEngine(config *params.ChainConfig, db ethdb.Database) (consensus.Engine, error) { + // CHANGE(taiko): use Taiko consensus engine when the --taiko flag is set. + if config.Taiko { + return taiko.New(config), nil + } // If proof-of-authority is requested, set it up if config.Clique != nil { return beacon.New(clique.New(config.Clique, db)), nil

diff --git ethereum/go-ethereum/eth/tracers/api.go taikoxyz/taiko-geth/eth/tracers/api.go index 68331082052648ad30e8f70a20aee0488ec7b7eb..eca53ba5f2acd6a32e64ef2b67b386fee752cc8c 100644 --- ethereum/go-ethereum/eth/tracers/api.go +++ taikoxyz/taiko-geth/eth/tracers/api.go @@ -270,6 +270,13 @@ blockCtx = core.NewEVMBlockContext(task.block.Header(), api.chainContext(ctx), nil) ) // Trace all the transactions contained within for i, tx := range task.block.Transactions() { + if i == 0 && api.backend.ChainConfig().Taiko { + if err := tx.MarkAsAnchor(); err != nil { + log.Warn("Mark anchor transaction error", "error", err) + task.results[i] = &txTraceResult{TxHash: tx.Hash(), Error: err.Error()} + break + } + } msg, _ := core.TransactionToMessage(tx, signer, task.block.BaseFee()) txctx := &Context{ BlockHash: task.block.Hash(), @@ -527,6 +534,11 @@ vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil) deleteEmptyObjects = chainConfig.IsEIP158(block.Number()) ) for i, tx := range block.Transactions() { + if i == 0 && chainConfig.Taiko { + if err := tx.MarkAsAnchor(); err != nil { + return nil, err + } + } if err := ctx.Err(); err != nil { return nil, err } @@ -604,6 +616,11 @@ signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time()) results = make([]*txTraceResult, len(txs)) ) for i, tx := range txs { + if i == 0 && api.backend.ChainConfig().Taiko { + if err := tx.MarkAsAnchor(); err != nil { + return nil, err + } + } // Generate the next state snapshot fast without tracing msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) txctx := &Context{ @@ -641,6 +658,14 @@ threads := runtime.NumCPU() if threads > len(txs) { threads = len(txs) } + + // CHANGE(taiko): mark the first transaction as anchor transaction. + if len(txs) > 0 && api.backend.ChainConfig().Taiko { + if err := txs[0].MarkAsAnchor(); err != nil { + return nil, err + } + } + jobs := make(chan *txTraceTask, threads) for th := 0; th < threads; th++ { pend.Add(1) @@ -757,6 +782,11 @@ // Note: This copies the config, to not screw up the main config chainConfig, canon = overrideConfig(chainConfig, config.Overrides) } for i, tx := range block.Transactions() { + if i == 0 && chainConfig.Taiko { + if err := tx.MarkAsAnchor(); err != nil { + return nil, err + } + } // Prepare the transaction for un-traced execution var ( msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee())

diff --git ethereum/go-ethereum/ethclient/taiko_api.go taikoxyz/taiko-geth/ethclient/taiko_api.go new file mode 100644 index 0000000000000000000000000000000000000000..597dcb96f54978fe58bcb0e624a71ae6267d644c --- /dev/null +++ taikoxyz/taiko-geth/ethclient/taiko_api.go @@ -0,0 +1,42 @@ +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 +} + +// GetSyncMode returns the current sync mode of the L2 node. +func (ec *Client) GetSyncMode(ctx context.Context) (string, error) { + var res string + + if err := ec.c.CallContext(ctx, &res, "taiko_getSyncMode"); err != nil { + return "", err + } + + return res, nil +}

diff --git ethereum/go-ethereum/ethclient/taiko_api_test.go taikoxyz/taiko-geth/ethclient/taiko_api_test.go new file mode 100644 index 0000000000000000000000000000000000000000..7a7cfc7dcd4c61b12dda671fe45d2a078e290b70 --- /dev/null +++ taikoxyz/taiko-geth/ethclient/taiko_api_test.go @@ -0,0 +1,124 @@ +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/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} + 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) + + return NewClient(n.Attach()), 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/miner/payload_building.go taikoxyz/taiko-geth/miner/payload_building.go index 719736c4795c03b461a3a8b0fdde6b1cd9495670..33dbae6f0eacb56774220f9148b2486c85457612 100644 --- ethereum/go-ethereum/miner/payload_building.go +++ taikoxyz/taiko-geth/miner/payload_building.go @@ -76,6 +76,8 @@ fullFees *big.Int stop chan struct{} lock sync.Mutex cond *sync.Cond + // CHANGE(taiko): done channel to communicate we shouldnt write to `stop` channel. + done chan struct{} }   // newPayload initializes the payload object. @@ -84,6 +86,8 @@ payload := &Payload{ id: id, empty: empty, stop: make(chan struct{}), + // CHANGE(taiko): buffered channel to communicate done to taiko payload builder + done: make(chan struct{}, 1), } log.Info("Starting work on payload", "id", payload.id) payload.cond = sync.NewCond(&payload.lock) @@ -133,6 +137,11 @@ select { case <-payload.stop: default: + // CHANGE(taiko): signal to taiko payload builder to not write to `payload.stop` channel + select { + case payload.done <- struct{}{}: + default: + } close(payload.stop) } if payload.full != nil { @@ -171,6 +180,11 @@ // Terminate the background payload construction select { case <-payload.stop: default: + // CHANGE(taiko): signal to taiko payload builder to not write to `payload.stop` channel + select { + case payload.done <- struct{}{}: + default: + } close(payload.stop) } return engine.BlockToExecutableData(payload.full, payload.fullFees, payload.sidecars) @@ -226,6 +240,10 @@ for { select { case <-timer.C: + // CHANGE(taiko): do not update payload. + if w.chainConfig.Taiko { + continue + } start := time.Now() r := w.getSealingBlock(fullParams) if r.err == nil {

diff --git ethereum/go-ethereum/miner/taiko_miner.go taikoxyz/taiko-geth/miner/taiko_miner.go new file mode 100644 index 0000000000000000000000000000000000000000..9b9a246c94fdba26f82c5c5f14289c62fbc5a462 --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_miner.go @@ -0,0 +1,70 @@ +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" +) + +// PreBuiltTxList is a pre-built transaction list based on the latest chain state, +// with estimated gas used / bytes. +type PreBuiltTxList struct { + TxList types.Transactions + EstimatedGasUsed uint64 + BytesLength uint64 +} + +// 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, +) (*types.Block, error) { + return miner.worker.sealBlockWith(parent, timestamp, blkMeta, baseFeePerGas, withdrawals) +} + +// BuildTransactionsLists builds multiple transactions lists which satisfy all the given limits. +func (miner *Miner) BuildTransactionsLists( + beneficiary common.Address, + baseFee *big.Int, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + locals []string, + maxTransactionsLists uint64, +) ([]*PreBuiltTxList, error) { + return miner.BuildTransactionsListsWithMinTip( + beneficiary, + baseFee, + blockMaxGasLimit, + maxBytesPerTxList, + locals, + maxTransactionsLists, + 0, + ) +} + +// BuildTransactionsListsWithMinTip builds multiple transactions lists which satisfy all +// the given limits and minimum tip. +func (miner *Miner) BuildTransactionsListsWithMinTip( + beneficiary common.Address, + baseFee *big.Int, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + locals []string, + maxTransactionsLists uint64, + minTip uint64, +) ([]*PreBuiltTxList, error) { + return miner.worker.BuildTransactionsLists( + beneficiary, + baseFee, + blockMaxGasLimit, + maxBytesPerTxList, + locals, + maxTransactionsLists, + minTip, + ) +}

diff --git ethereum/go-ethereum/miner/taiko_payload_building.go taikoxyz/taiko-geth/miner/taiko_payload_building.go new file mode 100644 index 0000000000000000000000000000000000000000..04d6cd595dfa65ab8068e4f72b56d478147e114b --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_payload_building.go @@ -0,0 +1,53 @@ +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 payload.afterSetFullBlock() + + 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 +} + +func (payload *Payload) afterSetFullBlock() { + payload.lock.Lock() + defer payload.lock.Unlock() + + select { + case <-payload.done: + log.Info("SetFullBlock payload.done received", "id", payload.id) + return + default: + } + + select { + case _, ok := <-payload.stop: + if ok { + log.Info("SetFullBlock payload.stop received", "id", payload.id) + return + } + default: + } + + select { + case payload.stop <- struct{}{}: + default: + } +}

diff --git ethereum/go-ethereum/miner/taiko_payload_building_test.go taikoxyz/taiko-geth/miner/taiko_payload_building_test.go new file mode 100644 index 0000000000000000000000000000000000000000..6b7118c3a86045c2f5a089a0bd169642ce85d5d1 --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_payload_building_test.go @@ -0,0 +1,140 @@ +package miner + +import ( + "math/big" + "testing" + "time" + + "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/params" + "github.com/ethereum/go-ethereum/trie" + "github.com/stretchr/testify/assert" +) + +func newTestBlock() *types.Block { + tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), big.NewInt(111), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11}) + txs := []*types.Transaction{tx1} + + block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, nil, trie.NewStackTrie(nil)) + return block +} + +func TestSetFullBlock_AvoidPanic(t *testing.T) { + var ( + db = rawdb.NewMemoryDatabase() + recipient = common.HexToAddress("0xdeadbeef") + ) + w, b := newTestWorker(t, params.TestChainConfig, ethash.NewFaker(), db, 0) + defer w.close() + + timestamp := uint64(time.Now().Unix()) + args := &BuildPayloadArgs{ + Parent: b.chain.CurrentBlock().Hash(), + Timestamp: timestamp, + Random: common.Hash{}, + FeeRecipient: recipient, + } + payload, err := w.buildPayload(args) + if err != nil { + t.Fatalf("Failed to build payload %v", err) + } + + fees := big.NewInt(1) + + payload.done <- struct{}{} + close(payload.stop) + + block := newTestBlock() + // expect not to panic sending to payload.stop + // now that done is closed + payload.SetFullBlock(block, fees) +} + +func TestAfterSetFullBlock_Panic_DoneChannelNotSent(t *testing.T) { + var ( + db = rawdb.NewMemoryDatabase() + recipient = common.HexToAddress("0xdeadbeef") + ) + w, b := newTestWorker(t, params.TestChainConfig, ethash.NewFaker(), db, 0) + defer w.close() + + timestamp := uint64(time.Now().Unix()) + args := &BuildPayloadArgs{ + Parent: b.chain.CurrentBlock().Hash(), + Timestamp: timestamp, + Random: common.Hash{}, + FeeRecipient: recipient, + } + payload, err := w.buildPayload(args) + if err != nil { + t.Fatalf("Failed to build payload %v", err) + } + + // dont send on done channel, but close stop channel. + // should panic when sent on. + close(payload.stop) + + assert.Panics(t, func() { + payload.afterSetFullBlock() + }) +} + +func TestAfterSetFullBlock_AvoidPanic_DoneChannelSent(t *testing.T) { + var ( + db = rawdb.NewMemoryDatabase() + recipient = common.HexToAddress("0xdeadbeef") + ) + w, b := newTestWorker(t, params.TestChainConfig, ethash.NewFaker(), db, 0) + defer w.close() + + timestamp := uint64(time.Now().Unix()) + args := &BuildPayloadArgs{ + Parent: b.chain.CurrentBlock().Hash(), + Timestamp: timestamp, + Random: common.Hash{}, + FeeRecipient: recipient, + } + payload, err := w.buildPayload(args) + if err != nil { + t.Fatalf("Failed to build payload %v", err) + } + + payload.done <- struct{}{} + close(payload.stop) + + assert.NotPanics(t, func() { + payload.afterSetFullBlock() + }) +} + +func TestSetFullBlock(t *testing.T) { + var ( + db = rawdb.NewMemoryDatabase() + recipient = common.HexToAddress("0xdeadbeef") + ) + w, b := newTestWorker(t, params.TestChainConfig, ethash.NewFaker(), db, 0) + defer w.close() + + timestamp := uint64(time.Now().Unix()) + args := &BuildPayloadArgs{ + Parent: b.chain.CurrentBlock().Hash(), + Timestamp: timestamp, + Random: common.Hash{}, + FeeRecipient: recipient, + } + payload, err := w.buildPayload(args) + if err != nil { + t.Fatalf("Failed to build payload %v", err) + } + + fees := big.NewInt(1) + + block := newTestBlock() + payload.SetFullBlock(block, fees) + + assert.Equal(t, block, payload.full) + assert.Equal(t, fees, payload.fullFees) +}

diff --git ethereum/go-ethereum/miner/taiko_worker.go taikoxyz/taiko-geth/miner/taiko_worker.go new file mode 100644 index 0000000000000000000000000000000000000000..3f02d21d174a8d5dff8365be0987169032b225dc --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_worker.go @@ -0,0 +1,365 @@ +package miner + +import ( + "bytes" + "compress/zlib" + "errors" + "fmt" + "math/big" + "time" + + "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/txpool" + "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/params" + "github.com/ethereum/go-ethereum/rlp" + "github.com/holiman/uint256" +) + +// BuildTransactionsLists builds multiple transactions lists which satisfy all the given conditions +// 1. All transactions should all be able to pay the given base fee. +// 2. The total gas used should not exceed the given blockMaxGasLimit +// 3. The total bytes used should not exceed the given maxBytesPerTxList +// 4. The total number of transactions lists should not exceed the given maxTransactionsLists +func (w *worker) BuildTransactionsLists( + beneficiary common.Address, + baseFee *big.Int, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + localAccounts []string, + maxTransactionsLists uint64, + minTip uint64, +) ([]*PreBuiltTxList, error) { + var ( + txsLists []*PreBuiltTxList + currentHead = w.chain.CurrentBlock() + ) + + if currentHead == nil { + return nil, fmt.Errorf("failed to find current head") + } + + // Check if tx pool is empty at first. + if len(w.eth.TxPool().Pending(txpool.PendingFilter{BaseFee: uint256.MustFromBig(baseFee), OnlyPlainTxs: true})) == 0 { + return txsLists, nil + } + + params := &generateParams{ + timestamp: uint64(time.Now().Unix()), + forceTime: true, + parentHash: currentHead.Hash(), + coinbase: beneficiary, + random: currentHead.MixDigest, + noTxs: false, + baseFeePerGas: baseFee, + } + + env, err := w.prepareWork(params) + if err != nil { + return nil, err + } + defer env.discard() + + var ( + signer = types.MakeSigner(w.chainConfig, new(big.Int).Add(currentHead.Number, common.Big1), currentHead.Time) + // Split the pending transactions into locals and remotes, then + // fill the block with all available pending transactions. + localTxs, remoteTxs = w.getPendingTxs(localAccounts, baseFee) + ) + + commitTxs := func(firstTransaction *types.Transaction) (*types.Transaction, *PreBuiltTxList, error) { + env.tcount = 0 + env.txs = []*types.Transaction{} + env.gasPool = new(core.GasPool).AddGas(blockMaxGasLimit) + env.header.GasLimit = blockMaxGasLimit + + var ( + locals = make(map[common.Address][]*txpool.LazyTransaction) + remotes = make(map[common.Address][]*txpool.LazyTransaction) + ) + + for address, txs := range localTxs { + locals[address] = txs + } + for address, txs := range remoteTxs { + remotes[address] = txs + } + + lastTransaction := w.commitL2Transactions( + env, + firstTransaction, + newTransactionsByPriceAndNonce(signer, locals, baseFee), + newTransactionsByPriceAndNonce(signer, remotes, baseFee), + maxBytesPerTxList, + minTip, + ) + + b, err := encodeAndComporeessTxList(env.txs) + if err != nil { + return nil, nil, err + } + + return lastTransaction, &PreBuiltTxList{ + TxList: env.txs, + EstimatedGasUsed: env.header.GasLimit - env.gasPool.Gas(), + BytesLength: uint64(len(b)), + }, nil + } + + var ( + lastTx *types.Transaction + res *PreBuiltTxList + ) + for i := 0; i < int(maxTransactionsLists); i++ { + if lastTx, res, err = commitTxs(lastTx); err != nil { + return nil, err + } + + if len(res.TxList) == 0 { + break + } + + txsLists = append(txsLists, res) + } + + return txsLists, nil +} + +// 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, +) (*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, + noTxs: false, + baseFeePerGas: baseFeePerGas, + } + + // Set extraData + w.extra = blkMeta.ExtraData + + env, err := w.prepareWork(params) + if err != nil { + return nil, err + } + defer env.discard() + + env.header.GasLimit = blkMeta.GasLimit + + // Commit transactions. + 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 { + if i == 0 { + if err := tx.MarkAsAnchor(); err != nil { + return nil, err + } + } + // Skip blob transactions + if tx.Type() == types.BlobTxType { + log.Debug("Skip a blob transaction", "hash", tx.Hash()) + continue + } + sender, err := types.LatestSignerForChainID(w.chainConfig.ChainID).Sender(tx) + if err != nil { + log.Debug("Skip an invalid proposed transaction", "hash", tx.Hash(), "reason", 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); err != nil { + log.Debug("Skip an invalid proposed transaction", "hash", tx.Hash(), "reason", err) + continue + } + env.tcount++ + } + + 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 +} + +// getPendingTxs fetches the pending transactions from tx pool. +func (w *worker) getPendingTxs(localAccounts []string, baseFee *big.Int) ( + map[common.Address][]*txpool.LazyTransaction, + map[common.Address][]*txpool.LazyTransaction, +) { + pending := w.eth.TxPool().Pending(txpool.PendingFilter{OnlyPlainTxs: true, BaseFee: uint256.MustFromBig(baseFee)}) + localTxs, remoteTxs := make(map[common.Address][]*txpool.LazyTransaction), pending + + for _, local := range localAccounts { + account := common.HexToAddress(local) + if txs := remoteTxs[account]; len(txs) > 0 { + delete(remoteTxs, account) + localTxs[account] = txs + } + } + + return localTxs, remoteTxs +} + +// commitL2Transactions tries to commit the transactions into the given state. +func (w *worker) commitL2Transactions( + env *environment, + firstTransaction *types.Transaction, + txsLocal *transactionsByPriceAndNonce, + txsRemote *transactionsByPriceAndNonce, + maxBytesPerTxList uint64, + minTip uint64, +) *types.Transaction { + var ( + txs = txsLocal + isLocal = true + lastTransaction *types.Transaction + ) + + if firstTransaction != nil { + env.txs = append(env.txs, firstTransaction) + } + +loop: + for { + // If we don't have enough gas for any further transactions then we're done. + if env.gasPool.Gas() < params.TxGas { + log.Trace("Not enough gas for further transactions", "have", env.gasPool, "want", params.TxGas) + break + } + + // Retrieve the next transaction and abort if all done. + ltx, _ := txs.Peek() + if ltx == nil { + if isLocal { + txs = txsRemote + isLocal = false + continue + } + break + } + tx := ltx.Resolve() + if tx == nil { + log.Trace("Ignoring evicted transaction") + + txs.Pop() + continue + } + + if tx.GasTipCapIntCmp(new(big.Int).SetUint64(minTip)) < 0 { + log.Trace("Ignoring transaction with low tip", "hash", tx.Hash(), "tip", tx.GasTipCap(), "minTip", minTip) + txs.Pop() + continue + } + + // Error may be ignored here. The error has already been checked + // during transaction acceptance is the transaction pool. + from, _ := types.Sender(env.signer, tx) + + // Check whether the tx is replay protected. If we're not in the EIP155 hf + // phase, start ignoring the sender until we do. + if tx.Protected() && !w.chainConfig.IsEIP155(env.header.Number) { + log.Trace("Ignoring reply protected transaction", "hash", tx.Hash(), "eip155", w.chainConfig.EIP155Block) + + txs.Pop() + continue + } + // Start executing the transaction + env.state.SetTxContext(tx.Hash(), env.tcount) + + _, err := w.commitTransaction(env, tx) + switch { + case errors.Is(err, core.ErrNonceTooLow): + // New head notification data race between the transaction pool and miner, shift + log.Trace("Skipping transaction with low nonce", "hash", ltx.Hash, "sender", from, "nonce", tx.Nonce()) + txs.Shift() + + case errors.Is(err, nil): + // Everything ok, collect the logs and shift in the next transaction from the same account + env.tcount++ + txs.Shift() + + // Encode and compress the txList, if the byte length is > maxBytesPerTxList, remove the latest tx and break. + b, err := encodeAndComporeessTxList(env.txs) + if err != nil { + log.Trace("Failed to rlp encode and compress the pending transaction %s: %w", tx.Hash(), err) + txs.Pop() + continue + } + if len(b) > int(maxBytesPerTxList) { + lastTransaction = env.txs[env.tcount-1] + env.txs = env.txs[0 : env.tcount-1] + break loop + } + default: + // Transaction is regarded as invalid, drop all consecutive transactions from + // the same sender because of `nonce-too-high` clause. + log.Trace("Transaction failed, account skipped", "hash", ltx.Hash, "err", err) + txs.Pop() + } + } + + return lastTransaction +} + +// encodeAndComporeessTxList encodes and compresses the given transactions list. +func encodeAndComporeessTxList(txs types.Transactions) ([]byte, error) { + b, err := rlp.EncodeToBytes(txs) + if err != nil { + return nil, err + } + + return compress(b) +} + +// compress compresses the given txList bytes using zlib. +func compress(txListBytes []byte) ([]byte, error) { + var b bytes.Buffer + w := zlib.NewWriter(&b) + defer w.Close() + + if _, err := w.Write(txListBytes); err != nil { + return nil, err + } + + if err := w.Flush(); err != nil { + return nil, err + } + + return b.Bytes(), nil +}

diff --git ethereum/go-ethereum/miner/worker.go taikoxyz/taiko-geth/miner/worker.go index 9a36106231e9828713c628fb33f9cbaf1003c491..5952c8ee2e98b5c456ca3d14053c6caca3d2a5b2 100644 --- ethereum/go-ethereum/miner/worker.go +++ taikoxyz/taiko-geth/miner/worker.go @@ -933,6 +933,8 @@ random common.Hash // The randomness generated by beacon chain, empty before the merge withdrawals types.Withdrawals // List of withdrawals to include in block. beaconRoot *common.Hash // The beacon root (cancun field). noTxs bool // Flag whether an empty block without any transaction is expected + // CHANGE(taiko): The base fee per gas for the next block + baseFeePerGas *big.Int }   // prepareWork constructs the sealing task according to the given parameters, @@ -955,10 +957,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{ @@ -978,10 +987,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 = eip1559.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 = eip1559.CalcBaseFee(w.chainConfig, parent) + if !w.chainConfig.IsLondon(parent.Number) { + parentGasLimit := parent.GasLimit * w.chainConfig.ElasticityMultiplier() + header.GasLimit = core.CalcGasLimit(parentGasLimit, w.config.GasCeil) + } } } // Apply EIP-4844, EIP-4788.

diff --git ethereum/go-ethereum/node/defaults.go taikoxyz/taiko-geth/node/defaults.go index 307d9e186a251b7963b5fbb4266249fbfbcc6fa4..59c37a88dd4385903863058bb5b68b2f40297e25 100644 --- ethereum/go-ethereum/node/defaults.go +++ taikoxyz/taiko-geth/node/defaults.go @@ -49,7 +49,8 @@ DefaultAuthCors = []string{"localhost"} // Default cors domain for the authenticated apis DefaultAuthVhosts = []string{"localhost"} // Default virtual hosts for the authenticated apis DefaultAuthOrigins = []string{"localhost"} // Default origins for the authenticated apis DefaultAuthPrefix = "" // Default prefix for the authenticated apis - DefaultAuthModules = []string{"eth", "engine"} + // CHANGE(taiko): add `taikoAuth` namespace for authenticated APIs. + DefaultAuthModules = []string{"eth", "engine", rpc.TaikoAuth} )   // DefaultConfig contains reasonable default settings.

diff --git ethereum/go-ethereum/node/endpoints.go taikoxyz/taiko-geth/node/endpoints.go index 14c12fd1f175b6c0ebf4c14b0bfd999a7eb970a8..ff64af71aa204bd27e3018f2f1d85f29fd329b43 100644 --- ethereum/go-ethereum/node/endpoints.go +++ taikoxyz/taiko-geth/node/endpoints.go @@ -62,7 +62,8 @@ } } for _, name := range modules { if _, ok := availableSet[name]; !ok { - if name != rpc.MetadataApi && name != rpc.EngineApi { + // CHANGE(taiko): add `taikoAuth` namespace for authenticated APIs. + if name != rpc.MetadataApi && name != rpc.EngineApi && name != rpc.TaikoAuth { bad = append(bad, name) } }

diff --git ethereum/go-ethereum/params/config.go taikoxyz/taiko-geth/params/config.go index 21ede457fd6820869a935c8b195473519073a58d..491878d4f7989defe73ff2958278c12e26b16c17 100644 --- ethereum/go-ethereum/params/config.go +++ taikoxyz/taiko-geth/params/config.go @@ -315,6 +315,17 @@ MainnetChainConfig.ChainID.String(): "mainnet", GoerliChainConfig.ChainID.String(): "goerli", SepoliaChainConfig.ChainID.String(): "sepolia", HoleskyChainConfig.ChainID.String(): "holesky", + // CHANGE(taiko): add Taiko network name. + TaikoMainnetNetworkID.String(): "Taiko", + TaikoInternalL2ANetworkID.String(): "Taiko Internal L2A Devnet", + TaikoInternalL2BNetworkID.String(): "Taiko Internal L2B Devnet", + SnaefellsjokullNetworkID.String(): "Taiko Alpha-1 (Snæfellsjökull)", + AskjaNetworkID.String(): "Taiko Alpha-2 (Askja)", + GrimsvotnNetworkID.String(): "Taiko Alpha-3 L2 (Grimsvotn)", + EldfellNetworkID.String(): "Taiko Alpha-4 L3 (Eldfell)", + JolnirNetworkID.String(): "Taiko Alpha-5 L2 (Jolnir)", + KatlaNetworkID.String(): "Taiko Alpha-6 L2 (Katla)", + HeklaNetworkID.String(): "Taiko Alpha-7 L2 (Hekla)", }   // ChainConfig is the core config which determines the blockchain settings. @@ -365,6 +376,9 @@ // Various consensus engines Ethash *EthashConfig `json:"ethash,omitempty"` Clique *CliqueConfig `json:"clique,omitempty"` + + // CHANGE(taiko): Taiko network flag. + Taiko bool `json:"taiko"` }   // EthashConfig is the consensus engine configs for proof-of-work based sealing. @@ -397,6 +411,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"

diff --git ethereum/go-ethereum/params/protocol_params.go taikoxyz/taiko-geth/params/protocol_params.go index 7eb63e89ac619c28b9f96bdf7617aa0a2d0fe504..43849077fdc2d2413a243c6645727a998e99f4f1 100644 --- ethereum/go-ethereum/params/protocol_params.go +++ taikoxyz/taiko-geth/params/protocol_params.go @@ -173,6 +173,8 @@ BlobTxPointEvaluationPrecompileGas = 50000 // Gas price for the point evaluation precompile.   BlobTxTargetBlobGasPerBlock = 3 * BlobTxBlobGasPerBlob // Target consumable blob gas for data blobs per block (for 1559-like pricing) MaxBlobGasPerBlock = 6 * BlobTxBlobGasPerBlob // Maximum consumable blob gas for data blobs per block + + BlobTxHashVersion = 0x01 // CHANGE(taiko): Version byte of the commitment hash )   // Gas discount table for BLS12-381 G1 and G2 multi exponentiation operations

diff --git ethereum/go-ethereum/params/taiko_config.go taikoxyz/taiko-geth/params/taiko_config.go new file mode 100644 index 0000000000000000000000000000000000000000..b94a9c786cccca09462a4119a23ef5f65814f0ef --- /dev/null +++ taikoxyz/taiko-geth/params/taiko_config.go @@ -0,0 +1,68 @@ +package params + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" +) + +func u64(val uint64) *uint64 { return &val } + +// Network IDs +var ( + TaikoMainnetNetworkID = big.NewInt(167000) + TaikoInternalL2ANetworkID = big.NewInt(167001) + TaikoInternalL2BNetworkID = big.NewInt(167002) + SnaefellsjokullNetworkID = big.NewInt(167003) + AskjaNetworkID = big.NewInt(167004) + GrimsvotnNetworkID = big.NewInt(167005) + EldfellNetworkID = big.NewInt(167006) + JolnirNetworkID = big.NewInt(167007) + KatlaNetworkID = big.NewInt(167008) + HeklaNetworkID = big.NewInt(167009) +) + +var networkIDToChainConfig = map[*big.Int]*ChainConfig{ + TaikoMainnetNetworkID: TaikoChainConfig, + TaikoInternalL2ANetworkID: TaikoChainConfig, + TaikoInternalL2BNetworkID: TaikoChainConfig, + SnaefellsjokullNetworkID: TaikoChainConfig, + AskjaNetworkID: TaikoChainConfig, + GrimsvotnNetworkID: TaikoChainConfig, + EldfellNetworkID: TaikoChainConfig, + JolnirNetworkID: TaikoChainConfig, + KatlaNetworkID: TaikoChainConfig, + HeklaNetworkID: TaikoChainConfig, + MainnetChainConfig.ChainID: MainnetChainConfig, + SepoliaChainConfig.ChainID: SepoliaChainConfig, + GoerliChainConfig.ChainID: GoerliChainConfig, + TestChainConfig.ChainID: TestChainConfig, + NonActivatedConfig.ChainID: NonActivatedConfig, +} + +func NetworkIDToChainConfigOrDefault(networkID *big.Int) *ChainConfig { + if config, ok := networkIDToChainConfig[networkID]; ok { + return config + } + + return AllEthashProtocolChanges +} + +var TaikoChainConfig = &ChainConfig{ + ChainID: TaikoInternalL2ANetworkID, // Use Internal Devnet 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, +}

diff --git ethereum/go-ethereum/params/taiko_config_test.go taikoxyz/taiko-geth/params/taiko_config_test.go new file mode 100644 index 0000000000000000000000000000000000000000..713cb1e4ee43daa360088c5b1f7bf46c9631d93d --- /dev/null +++ taikoxyz/taiko-geth/params/taiko_config_test.go @@ -0,0 +1,93 @@ +package params + +import ( + "math/big" + "testing" +) + +func TestNetworkIDToChainConfigOrDefault(t *testing.T) { + tests := []struct { + name string + networkID *big.Int + wantChainConfig *ChainConfig + }{ + { + "taikoMainnetNetworkID", + TaikoMainnetNetworkID, + TaikoChainConfig, + }, + { + "taikoInternalL2ANetworkId", + TaikoInternalL2ANetworkID, + TaikoChainConfig, + }, + { + "taikoInternalL2BNetworkId", + TaikoInternalL2BNetworkID, + TaikoChainConfig, + }, + { + "snaefoll", + SnaefellsjokullNetworkID, + TaikoChainConfig, + }, + { + "askja", + AskjaNetworkID, + TaikoChainConfig, + }, + { + "grimsvotn", + GrimsvotnNetworkID, + TaikoChainConfig, + }, + { + "eldfellNetworkID", + EldfellNetworkID, + TaikoChainConfig, + }, + { + "jolnirNetworkID", + JolnirNetworkID, + TaikoChainConfig, + }, + { + "katlaNetworkID", + KatlaNetworkID, + TaikoChainConfig, + }, + { + "heklaNetworkID", + HeklaNetworkID, + TaikoChainConfig, + }, + { + "mainnet", + MainnetChainConfig.ChainID, + MainnetChainConfig, + }, + { + "sepolia", + SepoliaChainConfig.ChainID, + SepoliaChainConfig, + }, + { + "goerli", + GoerliChainConfig.ChainID, + GoerliChainConfig, + }, + { + "doesntExist", + big.NewInt(89390218390), + AllEthashProtocolChanges, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if config := NetworkIDToChainConfigOrDefault(tt.networkID); config != tt.wantChainConfig { + t.Fatalf("expected %v, got %v", config, tt.wantChainConfig) + } + }) + } +}

diff --git ethereum/go-ethereum/rpc/server.go taikoxyz/taiko-geth/rpc/server.go index e2f9120aa2bcec35680346286d454579e6fa37a7..53abe421ba5f0957cf3b2a1de41117f9a4c95fc8 100644 --- ethereum/go-ethereum/rpc/server.go +++ taikoxyz/taiko-geth/rpc/server.go @@ -28,6 +28,9 @@ const MetadataApi = "rpc" const EngineApi = "engine"   +// CHANGE(taiko): add `taikoAuth` namespace for authenticated APIs +const TaikoAuth = "taikoAuth" + // CodecOption specifies which type of messages a codec supports. // // Deprecated: this option is no longer honored by Server.