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..a981fe4033566b02a9920228e1aeaf632485fac0 --- /dev/null +++ taikoxyz/taiko-geth/beacon/engine/gen_blockmetadata.go @@ -0,0 +1,74 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package engine + +import ( + "encoding/json" + "errors" + + "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"` + 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.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"` + 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.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 0ae5a3b8f1f1e90acfb3742679218d8bd1e844fb..71ad0e2c623f79bbd9f5e259ba941c3ddddd458b 100644 --- ethereum/go-ethereum/beacon/engine/gen_ed.go +++ taikoxyz/taiko-geth/beacon/engine/gen_ed.go @@ -30,11 +30,14 @@ 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"` + Transactions []hexutil.Bytes `json:"transactions"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` ExecutionWitness *types.ExecutionWitness `json:"executionWitness,omitempty"` + TxHash common.Hash `json:"txHash"` + WithdrawalsHash common.Hash `json:"withdrawalsHash"` + TaikoBlock bool } var enc ExecutableData enc.ParentHash = e.ParentHash @@ -60,6 +63,9 @@ enc.Withdrawals = e.Withdrawals enc.BlobGasUsed = (*hexutil.Uint64)(e.BlobGasUsed) enc.ExcessBlobGas = (*hexutil.Uint64)(e.ExcessBlobGas) enc.ExecutionWitness = e.ExecutionWitness + enc.TxHash = e.TxHash + enc.WithdrawalsHash = e.WithdrawalsHash + enc.TaikoBlock = e.TaikoBlock return json.Marshal(&enc) }   @@ -79,11 +85,14 @@ 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"` + Transactions []hexutil.Bytes `json:"transactions"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` ExecutionWitness *types.ExecutionWitness `json:"executionWitness,omitempty"` + TxHash *common.Hash `json:"txHash"` + WithdrawalsHash *common.Hash `json:"withdrawalsHash"` + TaikoBlock *bool } var dec ExecutableData if err := json.Unmarshal(input, &dec); err != nil { @@ -141,12 +150,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 @@ -159,6 +167,15 @@ e.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas) } if dec.ExecutionWitness != nil { e.ExecutionWitness = dec.ExecutionWitness + } + 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 984090ef89b1a342994737980722ea95bdb08b6e..0defa48278389ba48211be2a7f1456b11df54c0f 100644 --- ethereum/go-ethereum/beacon/engine/types.go +++ taikoxyz/taiko-geth/beacon/engine/types.go @@ -23,6 +23,7 @@ "slices"   "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/params" "github.com/ethereum/go-ethereum/trie" @@ -48,6 +49,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. @@ -55,6 +61,27 @@ 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 { + 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"` + 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. @@ -72,11 +99,15 @@ 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"` ExecutionWitness *types.ExecutionWitness `json:"executionWitness,omitempty"` + + 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 ecee2bfd805be9ab217a8b1dbf4c9e189660836f..7048174e457d3d287643305447d130b437a2ed97 100644 --- ethereum/go-ethereum/cmd/geth/config.go +++ taikoxyz/taiko-geth/cmd/geth/config.go @@ -197,6 +197,9 @@ utils.SetupMetrics(&cfg.Metrics)   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 9d9256862b632b1a4d0371024a2ca7ddb4391e1e..d9082038ef4c79080aa66f2fa00135323c0d5108 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): add `--gpo.defaultprice` flag + utils.GpoDefaultGasPriceFlag, configFileFlag, utils.LogDebugFlag, utils.LogBacktraceAtFlag, @@ -256,6 +258,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 728ec2d667c17c821a53a95555de82bf48a8ad8e..705362fe24e86736193aefffa866af79e649247b 100644 --- ethereum/go-ethereum/cmd/utils/flags.go +++ taikoxyz/taiko-geth/cmd/utils/flags.go @@ -839,6 +839,12 @@ Usage: "Gas price below which gpo will ignore transactions", Value: ethconfig.Defaults.GPO.IgnorePrice.Int64(), Category: flags.GasPriceCategory, } + // CHANGE(taiko): add `--gpo.defaultprice` flag. + GpoDefaultGasPriceFlag = &cli.Int64Flag{ + Name: "gpo.defaultprice", + Usage: "Default gas price", + Category: flags.GasPriceCategory, + }   // Metrics flags MetricsEnabledFlag = &cli.BoolFlag{ @@ -1679,6 +1685,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..fe9cd9ebd19c511951b5e53788068357d24797aa --- /dev/null +++ taikoxyz/taiko-geth/cmd/utils/taiko_flags.go @@ -0,0 +1,38 @@ +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/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", + Service: eth.NewTaikoAPIBackend(backend), + Public: true, + }, + { + Namespace: "taikoAuth", + 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..6b27f2d14fa5716fa2417e3ec0e14bb7cdc7b276 --- /dev/null +++ taikoxyz/taiko-geth/consensus/taiko/consensus.go @@ -0,0 +1,350 @@ +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/rawdb" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/tracing" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethdb" + "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] + AnchorV2Selector = crypto.Keccak256( + []byte("anchorV2(uint64,bytes32,uint32,(uint8,uint8,uint32,uint64,uint32))"), + )[:4] + AnchorV3Selector = crypto.Keccak256( + []byte("anchorV3(uint64,bytes32,uint32,(uint8,uint8,uint32,uint64,uint32),bytes32[])"), + )[:4] + AnchorGasLimit = uint64(250_000) + AnchorV3GasLimit = uint64(1_000_000) +) + +// Taiko is a consensus engine used by L2 rollup. +type Taiko struct { + chainConfig *params.ChainConfig + taikoL2Address common.Address + chainDB ethdb.Database +} + +var _ = new(Taiko) + +func New(chainConfig *params.ChainConfig, chainDB ethdb.Database) *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, + ), + chainDB: chainDB, + } +} + +// 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(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(header, parent, unixNow) + } + select { + case <-abort: + return + case results <- err: + } + } + }() + return abort, results +} + +func (t *Taiko) verifyHeader(header, parent *types.Header, unixNow int64) error { + // 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 + } + + l1Origin, err := rawdb.ReadL1Origin(t.chainDB, header.Number) + if err != nil { + return err + } + + // If the current block is not a preconfirmation block, then check the timestamp. + if l1Origin != nil && !l1Origin.IsPreconfBlock() && header.Time > uint64(unixNow) { + return consensus.ErrFutureBlock + } + + 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 vm.StateDB, body *types.Body) { + // no block rewards in l2 + header.UncleHash = types.CalcUncleHash(nil) + header.Difficulty = common.Big0 + // Withdrawals processing. + for _, w := range body.Withdrawals { + state.AddBalance( + w.Address, + uint256.MustFromBig(new(big.Int).SetUint64(w.Amount)), + tracing.BalanceIncreaseWithdrawal, + ) + } +} + +// 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, body *types.Body, receipts []*types.Receipt) (*types.Block, error) { + if body.Withdrawals == nil { + body.Withdrawals = make([]*types.Withdrawal, 0) + } + + // Verify anchor transaction + if len(body.Transactions) != 0 { // Transactions list might be empty when building empty payload. + isAnchor, err := t.ValidateAnchorTx(body.Transactions[0], header) + if err != nil { + return nil, err + } + if !isAnchor { + return nil, ErrAnchorTxNotFound + } + } + + // Finalize block + t.Finalize(chain, header, state, body) + header.Root = state.IntermediateRoot(true) + return types.NewBlock(header, body, receipts, 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 or TaikoL2.anchorV2 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) && + !bytes.HasPrefix(tx.Data(), AnchorV2Selector) && + !bytes.HasPrefix(tx.Data(), AnchorV3Selector) { + return false, nil + } + + if tx.Value().Cmp(common.Big0) != 0 { + return false, nil + } + + if t.chainConfig.IsPacaya(header.Number) { + if tx.Gas() != AnchorV3GasLimit { + return false, nil + } + } else { + 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..7f3c8e562330cd5d4fdbf8ea46d87e3a08af3474 --- /dev/null +++ taikoxyz/taiko-geth/consensus/taiko/consensus_test.go @@ -0,0 +1,232 @@ +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/ethash" + "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/eth/filters" + "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rpc" + "github.com/stretchr/testify/assert" +) + +var ( + testL2RollupAddress = common.HexToAddress("0x79fcdef22feed20eddacbb2587640e45491b757f") + goldenTouchKey, _ = crypto.HexToECDSA("92954368afd3caa1f3ce3ead0069c1af414054aefe1ef9aeacc1bf426222ce38") + testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + testAddr = crypto.PubkeyToAddress(testKey.PublicKey) + testContract = common.HexToAddress("0xbeef") + testEmpty = common.HexToAddress("0xeeee") + testSlot = common.HexToHash("0xdeadbeef") + testValue = crypto.Keccak256Hash(testSlot[:]) + testBalance = big.NewInt(2e15) + + 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, rawdb.NewMemoryDatabase()) + + 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. + genesis, 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, RPCGasCap: 1000000} + ethservice, err := eth.New(n, config) + if err != nil { + t.Fatalf("can't create new ethereum service: %v", err) + } + filterSystem := filters.NewFilterSystem(ethservice.APIBackend, filters.Config{}) + n.RegisterAPIs([]rpc.API{{ + Namespace: "eth", + Service: filters.NewFilterAPI(filterSystem), + }}) + + // 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) + } + return ethservice, blocks +} + +func generateTestChain() (*core.Genesis, []*types.Block) { + genesis := &core.Genesis{ + Config: params.AllEthashProtocolChanges, + Alloc: types.GenesisAlloc{ + testAddr: {Balance: testBalance, Storage: map[common.Hash]common.Hash{testSlot: testValue}}, + testContract: {Nonce: 1, Code: []byte{0x13, 0x37}}, + testEmpty: {Balance: big.NewInt(1)}, + }, + ExtraData: []byte("test genesis"), + Timestamp: 9000, + } + generate := func(i int, g *core.BlockGen) { + g.OffsetTime(5) + g.SetExtra([]byte("test_taiko")) + } + _, blocks, _ := core.GenerateChainWithGenesis(genesis, ethash.NewFaker(), 1, generate) + blocks = append([]*types.Block{genesis.ToBlock()}, blocks...) + return genesis, 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 9241d091ad40ee7bcafb1d66c64be0d6feccdd84..ca72a54d8fd0011007f157ffe5f5b7b2f3f3835d 100644 --- ethereum/go-ethereum/core/state_processor.go +++ taikoxyz/taiko-geth/core/state_processor.go @@ -91,9 +91,18 @@ }   // 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, err + } + } msg, err := TransactionToMessage(tx, signer, header.BaseFee) if err != nil { return nil, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err) + } + if p.config.IsOntake(block.Number()) { + msg.BasefeeSharingPctg = DecodeOntakeExtraData(header.Extra) } statedb.SetTxContext(tx.Hash(), i)   @@ -204,6 +213,11 @@ func ApplyTransaction(evm *vm.EVM, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64) (*types.Receipt, error) { msg, err := TransactionToMessage(tx, types.MakeSigner(evm.ChainConfig(), header.Number, header.Time), header.BaseFee) if err != nil { return nil, err + } + // CHANGE(taiko): decode the basefeeSharingPctg config from the extradata, and + // add it to the Message, if its an ontake block. + if evm.ChainConfig().IsOntake(header.Number) { + msg.BasefeeSharingPctg = DecodeOntakeExtraData(header.Extra) } // Create a new context to be used in the EVM environment return ApplyTransactionWithEVM(msg, gp, statedb, header.Number, header.Hash(), tx, usedGas, evm)

diff --git ethereum/go-ethereum/core/state_transition.go taikoxyz/taiko-geth/core/state_transition.go index 0f9ee9eea51ddbc14fdcf647df127a4567f9e663..d7f540e45fda6e879cff8704a76644f070b231cf 100644 --- ethereum/go-ethereum/core/state_transition.go +++ taikoxyz/taiko-geth/core/state_transition.go @@ -21,6 +21,7 @@ "bytes" "fmt" "math" "math/big" + "strings"   "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/tracing" @@ -164,6 +165,12 @@ SkipNonceChecks bool   // When SkipFromEOACheck is true, the message sender is not checked to be an EOA. SkipFromEOACheck bool + + // CHANGE(taiko): whether the current transaction is the first TaikoL2.anchor transaction in a block. + IsAnchor bool + // CHANGE(taiko): basefeeSharingPctg of the basefee will be sent to the block.coinbase, + // the remaining will be sent to the treasury address. + BasefeeSharingPctg uint8 }   // TransactionToMessage converts a transaction into a Message. @@ -183,6 +190,7 @@ SkipNonceChecks: false, SkipFromEOACheck: false, BlobHashes: tx.BlobHashes(), BlobGasFeeCap: tx.BlobGasFeeCap(), + IsAnchor: tx.IsAnchor(), } // If baseFee provided, set gasPrice to effectiveGasPrice. if baseFee != nil { @@ -283,6 +291,11 @@ balanceCheckU256, overflow := uint256.FromBig(balanceCheck) if overflow { return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) } + // CHANGE(taiko): if the transaction is an anchor transaction, the balance check is skipped. + 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) } @@ -329,7 +342,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, @@ -542,6 +556,20 @@ fee := new(uint256.Int).SetUint64(st.gasUsed()) fee.Mul(fee, effectiveTipU256) st.state.AddBalance(st.evm.Context.Coinbase, fee, tracing.BalanceIncreaseRewardTransactionFee)   + // CHANGE(taiko): basefee is not burnt, but sent to a treasury and block.coinbase instead. + if st.evm.ChainConfig().Taiko && st.evm.Context.BaseFee != nil && !st.msg.IsAnchor { + totalFee := new(uint256.Int).Mul( + new(uint256.Int).SetUint64(st.gasUsed()), + new(uint256.Int).SetUint64(st.evm.Context.BaseFee.Uint64()), + ) + feeCoinbase := new(uint256.Int).Div( + new(uint256.Int).Mul(totalFee, new(uint256.Int).SetUint64(uint64(st.msg.BasefeeSharingPctg))), + new(uint256.Int).SetUint64(100), + ) + feeTreasury := new(uint256.Int).Sub(totalFee, feeCoinbase) + st.state.AddBalance(st.getTreasuryAddress(), feeTreasury, tracing.BalanceIncreaseTreasury) + st.state.AddBalance(st.evm.Context.Coinbase, feeCoinbase, tracing.BalanceIncreaseBaseFeeSharing) + } // add the coinbase to the witness iff the fee is greater than 0 if rules.IsEIP4762 && fee.Sign() != 0 { st.evm.AccessEvents.AddAccount(st.evm.Context.Coinbase, true) @@ -636,12 +664,14 @@ // returnGas returns ETH for remaining gas, // exchanged at the original rate. func (st *stateTransition) returnGas() { - remaining := uint256.NewInt(st.gasRemaining) - remaining.Mul(remaining, uint256.MustFromBig(st.msg.GasPrice)) - st.state.AddBalance(st.msg.From, remaining, tracing.BalanceIncreaseGasReturn) + if !st.msg.IsAnchor { + remaining := uint256.NewInt(st.gasRemaining) + remaining.Mul(remaining, uint256.MustFromBig(st.msg.GasPrice)) + st.state.AddBalance(st.msg.From, remaining, tracing.BalanceIncreaseGasReturn)   - if st.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil && st.gasRemaining > 0 { - st.evm.Config.Tracer.OnGasChange(st.gasRemaining, 0, tracing.GasChangeTxLeftOverReturned) + if st.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil && st.gasRemaining > 0 { + st.evm.Config.Tracer.OnGasChange(st.gasRemaining, 0, tracing.GasChangeTxLeftOverReturned) + } }   // Also return remaining gas to the block gas counter so it is @@ -658,3 +688,23 @@ // 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, + ) +} + +// CHANGE(taiko): decodes an ontake block's extradata, returns basefeeSharingPctg configurations, +// the corresponding enocding function in protocol is `LibProposing._encodeGasConfigs`. +func DecodeOntakeExtraData(extradata []byte) uint8 { + return uint8(new(big.Int).SetBytes(extradata).Uint64()) +}

diff --git ethereum/go-ethereum/core/taiko_genesis.go taikoxyz/taiko-geth/core/taiko_genesis.go new file mode 100644 index 0000000000000000000000000000000000000000..fdbc7b3351f5df21e063a86c8a62dc6930fd1d23 --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_genesis.go @@ -0,0 +1,92 @@ +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" +) + +var ( + InternalDevnetOntakeBlock = new(big.Int).SetUint64(0) + PreconfDevnetOntakeBlock = common.Big0 + HeklaOntakeBlock = new(big.Int).SetUint64(840_512) + MainnetOntakeBlock = new(big.Int).SetUint64(538_304) + + InternalDevnetPacayaBlock = new(big.Int).SetUint64(10) + PreconfDevnetPacayaBlock = common.Big0 + HeklaPacayaBlock = new(big.Int).SetUint64(999_999_999_999) + MainnetPacayaBlock = new(big.Int).SetUint64(999_999_999_999) +) + +// 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 + chainConfig.OntakeBlock = MainnetOntakeBlock + chainConfig.PacayaBlock = MainnetPacayaBlock + allocJSON = taikoGenesis.MainnetGenesisAllocJSON + case params.TaikoInternalL2ANetworkID.Uint64(): + chainConfig.ChainID = params.TaikoInternalL2ANetworkID + chainConfig.OntakeBlock = InternalDevnetOntakeBlock + chainConfig.PacayaBlock = InternalDevnetPacayaBlock + 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 + chainConfig.OntakeBlock = HeklaOntakeBlock + chainConfig.PacayaBlock = HeklaPacayaBlock + allocJSON = taikoGenesis.HeklaGenesisAllocJSON + case params.PreconfDevnetNetworkID.Uint64(): + chainConfig.ChainID = params.PreconfDevnetNetworkID + chainConfig.OntakeBlock = PreconfDevnetOntakeBlock + chainConfig.PacayaBlock = PreconfDevnetPacayaBlock + allocJSON = taikoGenesis.PreconfDevnetGenesisAllocJSON + default: + chainConfig.ChainID = params.TaikoInternalL2ANetworkID + chainConfig.OntakeBlock = InternalDevnetOntakeBlock + chainConfig.PacayaBlock = InternalDevnetPacayaBlock + 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..24659f7d4ccba39beb65889fb483d75c1d958570 --- /dev/null +++ taikoxyz/taiko-geth/core/rawdb/gen_taiko_l1_origin.go @@ -0,0 +1,58 @@ +// 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" rlp:"optional"` + L1BlockHash common.Hash `json:"l1BlockHash" rlp:"optional"` + } + 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" rlp:"optional"` + L1BlockHash *common.Hash `json:"l1BlockHash" rlp:"optional"` + } + 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 { + l.L1BlockHeight = (*big.Int)(dec.L1BlockHeight) + } + if dec.L1BlockHash != nil { + 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..7204643a9fe30bafc2fbc810f87dee1ad1d25b24 --- /dev/null +++ taikoxyz/taiko-geth/core/rawdb/taiko_l1_origin.go @@ -0,0 +1,97 @@ +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" rlp:"optional"` + L1BlockHash common.Hash `json:"l1BlockHash" rlp:"optional"` +} + +type l1OriginMarshaling struct { + BlockID *math.HexOrDecimal256 + L1BlockHeight *math.HexOrDecimal256 +} + +// IsPreconfBlock returns true if the L1Origin is for a preconfirmation block. +func (l *L1Origin) IsPreconfBlock() bool { + return l.L1BlockHeight == nil +} + +// 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..ca96346352036f9b5858bc7ebd3d1e107cba59b9 --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_genesis/genesis_alloc.go @@ -0,0 +1,38 @@ +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 + +//go:embed preconf_devnet.json +var PreconfDevnetGenesisAllocJSON []byte

diff --git ethereum/go-ethereum/core/tracing/gen_balance_change_reason_stringer.go taikoxyz/taiko-geth/core/tracing/gen_balance_change_reason_stringer.go index 250b5211939d372a496d3b4c6bdbae01049b0bd2..60b6ebdd869aea468065210e16b9e5ef3496a14c 100644 --- ethereum/go-ethereum/core/tracing/gen_balance_change_reason_stringer.go +++ taikoxyz/taiko-geth/core/tracing/gen_balance_change_reason_stringer.go @@ -24,15 +24,28 @@ _ = x[BalanceIncreaseSelfdestruct-12] _ = x[BalanceDecreaseSelfdestruct-13] _ = x[BalanceDecreaseSelfdestructBurn-14] _ = x[BalanceChangeRevert-15] + _ = x[BalanceIncreaseTreasury-99] + _ = x[BalanceIncreaseBaseFeeSharing-100] }   -const _BalanceChangeReason_name = "UnspecifiedBalanceIncreaseRewardMineUncleBalanceIncreaseRewardMineBlockBalanceIncreaseWithdrawalBalanceIncreaseGenesisBalanceBalanceIncreaseRewardTransactionFeeBalanceDecreaseGasBuyBalanceIncreaseGasReturnBalanceIncreaseDaoContractBalanceDecreaseDaoAccountTransferTouchAccountBalanceIncreaseSelfdestructBalanceDecreaseSelfdestructBalanceDecreaseSelfdestructBurnRevert" +const ( + _BalanceChangeReason_name_0 = "UnspecifiedBalanceIncreaseRewardMineUncleBalanceIncreaseRewardMineBlockBalanceIncreaseWithdrawalBalanceIncreaseGenesisBalanceBalanceIncreaseRewardTransactionFeeBalanceDecreaseGasBuyBalanceIncreaseGasReturnBalanceIncreaseDaoContractBalanceDecreaseDaoAccountTransferTouchAccountBalanceIncreaseSelfdestructBalanceDecreaseSelfdestructBalanceDecreaseSelfdestructBurnRevert" + _BalanceChangeReason_name_1 = "BalanceIncreaseTreasuryBalanceIncreaseBaseFeeSharing" +)   -var _BalanceChangeReason_index = [...]uint16{0, 11, 41, 71, 96, 125, 160, 181, 205, 231, 256, 264, 276, 303, 330, 361, 367} +var ( + _BalanceChangeReason_index_0 = [...]uint16{0, 11, 41, 71, 96, 125, 160, 181, 205, 231, 256, 264, 276, 303, 330, 361, 367} + _BalanceChangeReason_index_1 = [...]uint8{0, 23, 52} +)   func (i BalanceChangeReason) String() string { - if i >= BalanceChangeReason(len(_BalanceChangeReason_index)-1) { + switch { + case i <= 15: + return _BalanceChangeReason_name_0[_BalanceChangeReason_index_0[i]:_BalanceChangeReason_index_0[i+1]] + case 99 <= i && i <= 100: + i -= 99 + return _BalanceChangeReason_name_1[_BalanceChangeReason_index_1[i]:_BalanceChangeReason_index_1[i+1]] + default: return "BalanceChangeReason(" + strconv.FormatInt(int64(i), 10) + ")" } - return _BalanceChangeReason_name[_BalanceChangeReason_index[i]:_BalanceChangeReason_index[i+1]] }

diff --git ethereum/go-ethereum/core/tracing/hooks.go taikoxyz/taiko-geth/core/tracing/hooks.go index 0485f7a3eb293733c3954d48bb35e8e48aefebaf..e1eac46e0139446e9e900e2774de43415ae97cfe 100644 --- ethereum/go-ethereum/core/tracing/hooks.go +++ taikoxyz/taiko-geth/core/tracing/hooks.go @@ -270,6 +270,10 @@ // BalanceChangeRevert is emitted when the balance is reverted back to a previous value due to call failure. // It is only emitted when the tracer has opted in to use the journaling wrapper (WrapWithJournal). BalanceChangeRevert BalanceChangeReason = 15 + + // CHANGE(taiko): Add new balance change reasons + BalanceIncreaseTreasury BalanceChangeReason = 99 + BalanceIncreaseBaseFeeSharing BalanceChangeReason = 100 )   // GasChangeReason is used to indicate the reason for a gas change, useful

diff --git ethereum/go-ethereum/core/txpool/validation.go taikoxyz/taiko-geth/core/txpool/validation.go index 8747724247f97a30cd1f8323cf1172cc502157d6..a5b8db276cf3e8302cee7c737a2b11d92ebf87a2 100644 --- ethereum/go-ethereum/core/txpool/validation.go +++ taikoxyz/taiko-geth/core/txpool/validation.go @@ -20,6 +20,7 @@ import ( "errors" "fmt" "math/big" + "os"   "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus/misc/eip4844" @@ -35,6 +36,8 @@ var ( // blobTxMinBlobGasPrice is the big.Int version of the configured protocol // parameter to avoid constructing a new big integer for every transaction. blobTxMinBlobGasPrice = big.NewInt(params.BlobTxMinBlobGasprice) + // CHANGE(taiko): the miniumum baseFee defined in TaikoL2 (0.008847185 GWei). + minL2BaseFee = new(big.Int).SetUint64(8847185) )   // ValidationOptions define certain differences between transaction validation @@ -105,6 +108,14 @@ } // 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") == "" { + if opts.Config.IsOntake(head.Number) && tx.GasFeeCap().Cmp(minL2BaseFee) < 0 { + return errors.New("max fee per gas is less than the minimum base fee (0.008847185 GWei)") + } else if tx.GasFeeCap().Cmp(common.Big0) == 0 { + return errors.New("max fee per gas is zero") + } } // Make sure the transaction is signed properly if _, err := types.Sender(signer, tx); err != nil {

diff --git ethereum/go-ethereum/core/types/op_deposit_tx.go taikoxyz/taiko-geth/core/types/op_deposit_tx.go new file mode 100644 index 0000000000000000000000000000000000000000..ac917c0ad22415fb9031873229f26edd1732eaa6 --- /dev/null +++ taikoxyz/taiko-geth/core/types/op_deposit_tx.go @@ -0,0 +1,74 @@ +package types + +import ( + "bytes" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/rlp" +) + +// CHANGES(taiko): make taiko-geth compatible with the op-service library. +const DepositTxType = 0x7E + +type DepositTx struct { + // SourceHash uniquely identifies the source of the deposit + SourceHash common.Hash + // From is exposed through the types.Signer, not through TxData + From common.Address + // nil means contract creation + To *common.Address `rlp:"nil"` + // Mint is minted on L2, locked on L1, nil if no minting. + Mint *big.Int `rlp:"nil"` + // Value is transferred from L2 balance, executed after Mint (if any) + Value *big.Int + // gas limit + Gas uint64 + // Field indicating if this transaction is exempt from the L2 gas limit. + IsSystemTransaction bool + // Normal Tx data + Data []byte +} + +// copy creates a deep copy of the transaction data and initializes all fields. +func (tx *DepositTx) copy() TxData { + return nil +} + +// accessors for innerTx. +func (tx *DepositTx) txType() byte { return DepositTxType } +func (tx *DepositTx) chainID() *big.Int { return common.Big0 } +func (tx *DepositTx) accessList() AccessList { return nil } +func (tx *DepositTx) data() []byte { return tx.Data } +func (tx *DepositTx) gas() uint64 { return tx.Gas } +func (tx *DepositTx) gasFeeCap() *big.Int { return new(big.Int) } +func (tx *DepositTx) gasTipCap() *big.Int { return new(big.Int) } +func (tx *DepositTx) gasPrice() *big.Int { return new(big.Int) } +func (tx *DepositTx) value() *big.Int { return tx.Value } +func (tx *DepositTx) nonce() uint64 { return 0 } +func (tx *DepositTx) to() *common.Address { return tx.To } +func (tx *DepositTx) isSystemTx() bool { return tx.IsSystemTransaction } // nolint:unused +func (tx *DepositTx) isAnchor() bool { return false } +func (tx *DepositTx) markAsAnchor() error { return ErrInvalidTxType } + +func (tx *DepositTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int { + return dst.Set(new(big.Int)) +} + +func (tx *DepositTx) effectiveNonce() *uint64 { return nil } // nolint:unused + +func (tx *DepositTx) rawSignatureValues() (v, r, s *big.Int) { + return common.Big0, common.Big0, common.Big0 +} + +func (tx *DepositTx) setSignatureValues(chainID, v, r, s *big.Int) { + // this is a noop for deposit transactions +} + +func (tx *DepositTx) encode(b *bytes.Buffer) error { + return rlp.Encode(b, tx) +} + +func (tx *DepositTx) decode(input []byte) error { + return rlp.DecodeBytes(input, tx) +}

diff --git ethereum/go-ethereum/core/types/taiko_transaction.go taikoxyz/taiko-geth/core/types/taiko_transaction.go new file mode 100644 index 0000000000000000000000000000000000000000..6356a4bea22fb1c108cf64a0ac3913438e8dda6f --- /dev/null +++ taikoxyz/taiko-geth/core/types/taiko_transaction.go @@ -0,0 +1,50 @@ +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 *SetCodeTx) 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 +} + +func (tx *SetCodeTx) markAsAnchor() error { + return ErrInvalidTxType +}

diff --git ethereum/go-ethereum/core/types/transaction.go taikoxyz/taiko-geth/core/types/transaction.go index 4e48248b4a8bf9aaad44046de600956891cde992..9df83ea5e04933905e1a914fed6ba58438df8e2d 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)   @@ -649,3 +653,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 981755cf7007882a6c5703e7a2d728bb25310d45..9ed84c3d12349cc93316b26ca25f5dc9774e0c65 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 R *big.Int S *big.Int + + // 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 99ed28d96afc437e2294bd38ed2b7c1477d6bd92..9c79f603d10a334a9401ab1098b6e0ed346b7b92 100644 --- ethereum/go-ethereum/eth/state_accessor.go +++ taikoxyz/taiko-geth/eth/state_accessor.go @@ -250,12 +250,22 @@ } // 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 + } + } if idx == txIndex { return tx, context, statedb, release, nil } // Assemble the transaction call message and return if the requested offset msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())   + // CHANGE(taiko): decode the basefeeSharingPctg config from the extradata, and + // add it to the Message, if its an ontake block. + if eth.blockchain.Config().IsOntake(block.Number()) { + msg.BasefeeSharingPctg = core.DecodeOntakeExtraData(block.Header().Extra) + } // Not yet the searched for transaction, execute on top of the current state statedb.SetTxContext(tx.Hash(), idx) if _, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil {

diff --git ethereum/go-ethereum/eth/taiko_api_backend.go taikoxyz/taiko-geth/eth/taiko_api_backend.go new file mode 100644 index 0000000000000000000000000000000000000000..cc6ca6bed63027f984ba1a4f58af1b88365f0a0e --- /dev/null +++ taikoxyz/taiko-geth/eth/taiko_api_backend.go @@ -0,0 +1,147 @@ +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} +} + +// SetHeadL1Origin sets the latest L2 block's corresponding L1 origin. +func (a *TaikoAuthAPIBackend) SetHeadL1Origin(blockID *math.HexOrDecimal256) *big.Int { + rawdb.WriteHeadL1Origin(a.eth.ChainDb(), (*big.Int)(blockID)) + return (*big.Int)(blockID) +} + +// UpdateL1Origin updates the L2 block's corresponding L1 origin. +func (a *TaikoAuthAPIBackend) UpdateL1Origin(l1Origin *rawdb.L1Origin) *rawdb.L1Origin { + rawdb.WriteL1Origin(a.eth.ChainDb(), l1Origin.BlockID, l1Origin) + return l1Origin +} + +// 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 e6f29c970b5bc4472aeec6fb9badb0430599eec9..44e00debea24eaf79858f190f5887823e429e922 100644 --- ethereum/go-ethereum/eth/catalyst/api.go +++ taikoxyz/taiko-geth/eth/catalyst/api.go @@ -20,6 +20,7 @@ import ( "errors" "fmt" + "math/big" "strconv" "sync" "time" @@ -32,6 +33,7 @@ "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/stateless" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/eth/ethconfig" "github.com/ethereum/go-ethereum/internal/version" @@ -377,6 +379,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 { @@ -386,6 +392,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. @@ -427,6 +437,67 @@ // 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) + } + + // Use the tx list hash as the beacon root. + txListHash := crypto.Keccak256Hash(payloadAttributes.BlockMetadata.TxList[:]) + // 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, + TxListHash: &txListHash, + } + id := args.Id() + // If we already are busy generating this work, then we do not need + // to start a second process. + if api.localBlocks.has(id) { + return valid(&id), nil + } + payload, err := api.eth.Miner().BuildPayload(args, false) + 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, only when it's not a preconfirmation block. + if !l1Origin.IsPreconfBlock() { + rawdb.WriteHeadL1Origin(api.eth.ChainDb(), l1Origin.BlockID) + } + + return valid(&id), nil + } + args := &miner.BuildPayloadArgs{ Parent: update.HeadBlockHash, Timestamp: payloadAttributes.Timestamp, @@ -561,7 +632,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 { @@ -834,38 +906,66 @@ 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, requests) - if err != nil { - bgu := "nil" - if params.BlobGasUsed != nil { - bgu = strconv.Itoa(int(*params.BlobGasUsed)) - } - ebg := "nil" - if params.ExcessBlobGas != nil { - ebg = strconv.Itoa(int(*params.ExcessBlobGas)) + // 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, requests) + if err != nil { + bgu := "nil" + if params.BlobGasUsed != nil { + bgu = strconv.Itoa(int(*params.BlobGasUsed)) + } + ebg := "nil" + if params.ExcessBlobGas != nil { + ebg = strconv.Itoa(int(*params.ExcessBlobGas)) + } + log.Warn("Invalid NewPayload params", + "params.Number", params.Number, + "params.ParentHash", params.ParentHash, + "params.BlockHash", params.BlockHash, + "params.StateRoot", params.StateRoot, + "params.FeeRecipient", params.FeeRecipient, + "params.LogsBloom", common.PrettyBytes(params.LogsBloom), + "params.Random", params.Random, + "params.GasLimit", params.GasLimit, + "params.GasUsed", params.GasUsed, + "params.Timestamp", params.Timestamp, + "params.ExtraData", common.PrettyBytes(params.ExtraData), + "params.BaseFeePerGas", params.BaseFeePerGas, + "params.BlobGasUsed", bgu, + "params.ExcessBlobGas", ebg, + "len(params.Transactions)", len(params.Transactions), + "len(params.Withdrawals)", len(params.Withdrawals), + "beaconRoot", beaconRoot, + "len(requests)", len(requests), + "error", err) + return api.invalid(err, nil), nil } - log.Warn("Invalid NewPayload params", - "params.Number", params.Number, - "params.ParentHash", params.ParentHash, - "params.BlockHash", params.BlockHash, - "params.StateRoot", params.StateRoot, - "params.FeeRecipient", params.FeeRecipient, - "params.LogsBloom", common.PrettyBytes(params.LogsBloom), - "params.Random", params.Random, - "params.GasLimit", params.GasLimit, - "params.GasUsed", params.GasUsed, - "params.Timestamp", params.Timestamp, - "params.ExtraData", common.PrettyBytes(params.ExtraData), - "params.BaseFeePerGas", params.BaseFeePerGas, - "params.BlobGasUsed", bgu, - "params.ExcessBlobGas", ebg, - "len(params.Transactions)", len(params.Transactions), - "len(params.Withdrawals)", len(params.Withdrawals), - "beaconRoot", beaconRoot, - "len(requests)", len(requests), - "error", err) - return api.invalid(err, nil), nil } + // Stash away the last update to warn the user if the beacon client goes offline api.lastNewPayloadLock.Lock() api.lastNewPayloadUpdate = time.Now() @@ -892,9 +992,18 @@ parent := api.eth.BlockChain().GetBlock(block.ParentHash(), block.NumberU64()-1) if parent == nil { return api.delayPayloadImport(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 6b75ab816fa6fcf3ae817e389200b4260751b7c6..8497916e3de2ec86723d9307f87ac12685b1dd96 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" @@ -159,6 +160,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, db), nil + } if config.TerminalTotalDifficulty == nil { log.Error("Geth only supports PoS networks. Please transition legacy networks using Geth v1.13.x.") return nil, fmt.Errorf("'terminalTotalDifficulty' is not set in genesis block")

diff --git ethereum/go-ethereum/eth/tracers/api.go taikoxyz/taiko-geth/eth/tracers/api.go index d13aee555f468baaec7ef9c6cb414a9ea8eb939d..43534d67777f8b90f9770fdc2872214008dcfe1e 100644 --- ethereum/go-ethereum/eth/tracers/api.go +++ taikoxyz/taiko-geth/eth/tracers/api.go @@ -272,7 +272,19 @@ 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()) + // CHANGE(taiko): decode the basefeeSharingPctg config from the extradata, and + // add it to the Message, if its an ontake block. + if api.backend.ChainConfig().IsOntake(task.block.Number()) { + msg.BasefeeSharingPctg = core.DecodeOntakeExtraData(task.block.Header().Extra) + } txctx := &Context{ BlockHash: task.block.Hash(), BlockNumber: task.block.Number(), @@ -544,6 +556,11 @@ if chainConfig.IsPrague(block.Number(), block.Time()) { core.ProcessParentBlockHash(block.ParentHash(), evm) } 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 } @@ -624,8 +641,18 @@ 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()) + // CHANGE(taiko): decode the basefeeSharingPctg config from the extradata, and + // add it to the Message, if its an ontake block. + if api.backend.ChainConfig().IsOntake(block.Number()) { + msg.BasefeeSharingPctg = core.DecodeOntakeExtraData(block.Header().Extra) + } txctx := &Context{ BlockHash: blockHash, BlockNumber: block.Number(), @@ -657,6 +684,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) @@ -665,6 +700,11 @@ defer pend.Done() // Fetch and execute the next transaction trace tasks for task := range jobs { msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee()) + // CHANGE(taiko): decode the basefeeSharingPctg config from the extradata, and + // add it to the Message, if its an ontake block. + if api.backend.ChainConfig().IsOntake(block.Number()) { + msg.BasefeeSharingPctg = core.DecodeOntakeExtraData(block.Header().Extra) + } txctx := &Context{ BlockHash: blockHash, BlockNumber: block.Number(), @@ -701,9 +741,13 @@ failed = ctx.Err() break txloop case jobs <- task: } - // Generate the next state snapshot fast without tracing msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) + // CHANGE(taiko): decode the basefeeSharingPctg config from the extradata, and + // add it to the Message, if its an ontake block. + if api.backend.ChainConfig().IsOntake(block.Number()) { + msg.BasefeeSharingPctg = core.DecodeOntakeExtraData(block.Header().Extra) + } statedb.SetTxContext(tx.Hash(), i) if _, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(msg.GasLimit)); err != nil { failed = err @@ -785,6 +829,11 @@ if chainConfig.IsPrague(block.Number(), block.Time()) { core.ProcessParentBlockHash(block.ParentHash(), evm) } 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()) @@ -793,6 +842,11 @@ dump *os.File writer *bufio.Writer err error ) + // CHANGE(taiko): decode the basefeeSharingPctg config from the extradata, and + // add it to the Message, if its an ontake block. + if api.backend.ChainConfig().IsOntake(block.Number()) { + msg.BasefeeSharingPctg = core.DecodeOntakeExtraData(block.Header().Extra) + } // If the transaction needs tracing, swap out the configs if tx.Hash() == txHash || txHash == (common.Hash{}) { // Generate a unique temporary file to dump it into

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..1666349c6cb49abbeb56714c8d878f4f09afabb4 --- /dev/null +++ taikoxyz/taiko-geth/ethclient/taiko_api_test.go @@ -0,0 +1,156 @@ +package ethclient + +import ( + "context" + "crypto/rand" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/ethash" + "github.com/ethereum/go-ethereum/core" + "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/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" +) + +var ( + testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + testAddr = crypto.PubkeyToAddress(testKey.PublicKey) + testContract = common.HexToAddress("0xbeef") + testEmpty = common.HexToAddress("0xeeee") + testSlot = common.HexToHash("0xdeadbeef") + testValue = crypto.Keccak256Hash(testSlot[:]) + testBalance = big.NewInt(2e15) +) + +func generateTestChain() (*core.Genesis, []*types.Block) { + genesis := &core.Genesis{ + Config: params.AllEthashProtocolChanges, + Alloc: types.GenesisAlloc{ + testAddr: {Balance: testBalance, Storage: map[common.Hash]common.Hash{testSlot: testValue}}, + testContract: {Nonce: 1, Code: []byte{0x13, 0x37}}, + testEmpty: {Balance: big.NewInt(1)}, + }, + ExtraData: []byte("test genesis"), + Timestamp: 9000, + } + generate := func(i int, g *core.BlockGen) { + g.OffsetTime(5) + g.SetExtra([]byte("test")) + } + _, blocks, _ := core.GenerateChainWithGenesis(genesis, ethash.NewFaker(), 1, generate) + blocks = append([]*types.Block{genesis.ToBlock()}, blocks...) + return genesis, blocks +} + +func newTaikoAPITestClient(t *testing.T) (*Client, []*types.Block, ethdb.Database) { + // Generate test chain. + genesis, 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", + 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 6b010186bf99c7a74b916a1c6e5d967028c84b94..ee4970b719e7f76fdba9a558b925690b010408c2 100644 --- ethereum/go-ethereum/miner/payload_building.go +++ taikoxyz/taiko-geth/miner/payload_building.go @@ -44,6 +44,7 @@ Random common.Hash // The provided randomness value Withdrawals types.Withdrawals // The provided withdrawals BeaconRoot *common.Hash // The provided beaconRoot (Cancun) Version engine.PayloadVersion // Versioning byte for payload id calculation. + TxListHash *common.Hash // CHANGE(taiko): The hash of the transaction list }   // Id computes an 8-byte identifier by hashing the components of the payload arguments. @@ -56,6 +57,10 @@ hasher.Write(args.FeeRecipient[:]) rlp.Encode(hasher, args.Withdrawals) if args.BeaconRoot != nil { hasher.Write(args.BeaconRoot[:]) + } + // CHANGE(taiko): include the transaction list hash in the payload id calculation + if args.TxListHash != nil { + hasher.Write(args.TxListHash[:]) } var out engine.PayloadID copy(out[:], hasher.Sum(nil)[:8]) @@ -81,6 +86,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. @@ -91,6 +98,8 @@ empty: empty, emptyRequests: emptyRequests, emptyWitness: witness, 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) @@ -142,6 +151,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 { @@ -195,6 +209,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) } envelope := engine.BlockToExecutableData(payload.full, payload.fullFees, payload.sidecars, payload.requests) @@ -254,6 +273,10 @@ for { select { case <-timer.C: + // CHANGE(taiko): do not update payload. + if miner.chainConfig.Taiko { + continue + } start := time.Now() r := miner.generateWork(fullParams, witness) 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..4bc09792a2dace2ee1daebf496ec5d0ac9726fcb --- /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.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.buildTransactionsLists( + 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.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..d61df949f03cf25073399e67253db6b7143c13d3 --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_payload_building_test.go @@ -0,0 +1,136 @@ +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)}, &types.Body{Transactions: txs}, 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) + + timestamp := uint64(time.Now().Unix()) + args := &BuildPayloadArgs{ + Parent: b.chain.CurrentBlock().Hash(), + Timestamp: timestamp, + Random: common.Hash{}, + FeeRecipient: recipient, + } + payload, err := w.buildPayload(args, false) + 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) + + timestamp := uint64(time.Now().Unix()) + args := &BuildPayloadArgs{ + Parent: b.chain.CurrentBlock().Hash(), + Timestamp: timestamp, + Random: common.Hash{}, + FeeRecipient: recipient, + } + payload, err := w.buildPayload(args, false) + 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 TestAfterSetFullBlockAvoidPanicDoneChannelSent(t *testing.T) { + var ( + db = rawdb.NewMemoryDatabase() + recipient = common.HexToAddress("0xdeadbeef") + ) + w, b := newTestWorker(t, params.TestChainConfig, ethash.NewFaker(), db, 0) + + timestamp := uint64(time.Now().Unix()) + args := &BuildPayloadArgs{ + Parent: b.chain.CurrentBlock().Hash(), + Timestamp: timestamp, + Random: common.Hash{}, + FeeRecipient: recipient, + } + payload, err := w.buildPayload(args, false) + 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) + + timestamp := uint64(time.Now().Unix()) + args := &BuildPayloadArgs{ + Parent: b.chain.CurrentBlock().Hash(), + Timestamp: timestamp, + Random: common.Hash{}, + FeeRecipient: recipient, + } + payload, err := w.buildPayload(args, false) + 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..bdf766cba31ba11116e9d3b66f11a9e1dbd9c3f5 --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_worker.go @@ -0,0 +1,366 @@ +package miner + +import ( + "bytes" + "compress/zlib" + "errors" + "fmt" + "maps" + "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 *Miner) 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.txpool.Pending(txpool.PendingFilter{MinTip: uint256.NewInt(minTip), 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, false) + if err != nil { + return nil, err + } + + 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 + + lastTransaction := w.commitL2Transactions( + env, + firstTransaction, + newTransactionsByPriceAndNonce(signer, maps.Clone(localTxs), baseFee), + newTransactionsByPriceAndNonce(signer, maps.Clone(remoteTxs), baseFee), + maxBytesPerTxList, + minTip, + ) + + b, err := encodeAndCompressTxList(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 *Miner) 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 `TaikoL2.anchor` / `TaikoL2.anchorV2`. + 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.SetExtra(blkMeta.ExtraData) + + env, err := w.prepareWork(params, false) + if err != nil { + return nil, err + } + + 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, + &types.Body{Transactions: env.txs, Withdrawals: withdrawals}, + env.receipts, + ) + 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 *Miner) getPendingTxs(localAccounts []string, baseFee *big.Int) ( + map[common.Address][]*txpool.LazyTransaction, + map[common.Address][]*txpool.LazyTransaction, +) { + pending := w.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 *Miner) 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 + txs.Shift() + + data, err := rlp.EncodeToBytes(env.txs) + if err != nil { + log.Trace("Failed to rlp encode the pending transaction %s: %w", tx.Hash(), err) + txs.Pop() + continue + } + if len(data) >= int(maxBytesPerTxList) { + // Encode and compress the txList, if the byte length is > maxBytesPerTxList, remove the latest tx and break. + b, err := compress(data) + 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 +} + +// encodeAndCompressTxList encodes and compresses the given transactions list. +func encodeAndCompressTxList(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/taiko_worker_test.go taikoxyz/taiko-geth/miner/taiko_worker_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0d741ff8f767dcc777c52df9430e720aee59a316 --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_worker_test.go @@ -0,0 +1,71 @@ +package miner + +import ( + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/clique" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/txpool" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/params" + "github.com/stretchr/testify/assert" +) + +const ( + // testCode is the testing contract binary code which will initialises some + // variables in constructor + testCode = "0x60806040527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0060005534801561003457600080fd5b5060fc806100436000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c80630c4dae8814603757806398a213cf146053575b600080fd5b603d607e565b6040518082815260200191505060405180910390f35b607c60048036036020811015606757600080fd5b81019080803590602001909291905050506084565b005b60005481565b806000819055507fe9e44f9f7da8c559de847a3232b57364adc0354f15a2cd8dc636d54396f9587a6000546040518082815260200191505060405180910390a15056fea265627a7a723058208ae31d9424f2d0bc2a3da1a5dd659db2d71ec322a17db8f87e19e209e3a1ff4a64736f6c634300050a0032" + + // testGas is the gas required for contract deployment. + testGas = 144109 +) + +func newRandomTx(txPool *txpool.TxPool, creation bool) *types.Transaction { + var tx *types.Transaction + gasPrice := big.NewInt(10 * params.InitialBaseFee) + if creation { + tx, _ = types.SignTx(types.NewContractCreation(txPool.Nonce(testBankAddress), big.NewInt(0), testGas, gasPrice, common.FromHex(testCode)), types.HomesteadSigner{}, testBankKey) + } else { + tx, _ = types.SignTx(types.NewTransaction(txPool.Nonce(testBankAddress), testUserAddress, big.NewInt(1000), params.TxGas, gasPrice, nil), types.HomesteadSigner{}, testBankKey) + } + return tx +} + +func testGenerateWorker(t *testing.T, txCount int) *Miner { + t.Parallel() + var ( + db = rawdb.NewMemoryDatabase() + config = *params.AllCliqueProtocolChanges + ) + config.Taiko = true + config.Clique = &params.CliqueConfig{Period: 1, Epoch: 30000} + engine := clique.New(config.Clique, db) + + w, b := newTestWorker(t, &config, engine, db, 0) + + for i := 0; i < txCount; i++ { + b.txPool.Add([]*types.Transaction{newRandomTx(b.txPool, true)}, true) + b.txPool.Add([]*types.Transaction{newRandomTx(b.txPool, false)}, true) + } + + return w +} + +func TestBuildTransactionsLists(t *testing.T) { + w := testGenerateWorker(t, 2000) + + maxBytesPerTxList := (params.BlobTxBytesPerFieldElement - 1) * params.BlobTxFieldElementsPerBlob + txList, err := w.BuildTransactionsLists( + testBankAddress, + nil, + 240_000_000, + uint64(maxBytesPerTxList)/10, + nil, + 1, + ) + assert.NoError(t, err) + assert.LessOrEqual(t, 1, len(txList)) + assert.LessOrEqual(t, txList[0].BytesLength, uint64(maxBytesPerTxList)) +}

diff --git ethereum/go-ethereum/miner/worker.go taikoxyz/taiko-geth/miner/worker.go index 2c544211966782f81ab18f7cf7429c307ce73371..6403c2b2129ebf68abbc7c38ab8240cb2b9fe28e 100644 --- ethereum/go-ethereum/miner/worker.go +++ taikoxyz/taiko-geth/miner/worker.go @@ -91,6 +91,8 @@ random common.Hash // The randomness generated by beacon chain, empty before the merge withdrawals types.Withdrawals // List of withdrawals to include in block (shanghai field) 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, used by the legacy Taiko blocks. + baseFeePerGas *big.Int }   // generateWork generates a sealing block based on the given parameters. @@ -171,10 +173,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 !miner.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{ @@ -194,10 +203,14 @@ header.MixDigest = genParams.random } // Set baseFee and GasLimit if we are on an EIP-1559 chain if miner.chainConfig.IsLondon(header.Number) { - header.BaseFee = eip1559.CalcBaseFee(miner.chainConfig, parent) - if !miner.chainConfig.IsLondon(parent.Number) { - parentGasLimit := parent.GasLimit * miner.chainConfig.ElasticityMultiplier() - header.GasLimit = core.CalcGasLimit(parentGasLimit, miner.config.GasCeil) + if miner.chainConfig.Taiko && genParams.baseFeePerGas != nil { + header.BaseFee = genParams.baseFeePerGas + } else { + header.BaseFee = eip1559.CalcBaseFee(miner.chainConfig, parent) + if !miner.chainConfig.IsLondon(parent.Number) { + parentGasLimit := parent.GasLimit * miner.chainConfig.ElasticityMultiplier() + header.GasLimit = core.CalcGasLimit(parentGasLimit, miner.config.GasCeil) + } } } // Run the consensus preparation with the default or customized consensus engine.

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 593c70b1390d3b199e737bf40745c9003b4b63bb..dfc9f7c5cf643d29c034b9ed05e69590dfee3a26 100644 --- ethereum/go-ethereum/params/config.go +++ taikoxyz/taiko-geth/params/config.go @@ -338,6 +338,18 @@ var NetworkNames = map[string]string{ MainnetChainConfig.ChainID.String(): "mainnet", 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)", + PreconfDevnetNetworkID.String(): "Taiko Preconfirmation Devnet", }   // ChainConfig is the core config which determines the blockchain settings. @@ -400,6 +412,11 @@ // Various consensus engines Ethash *EthashConfig `json:"ethash,omitempty"` Clique *CliqueConfig `json:"clique,omitempty"` BlobScheduleConfig *BlobScheduleConfig `json:"blobSchedule,omitempty"` + + // CHANGE(taiko): Taiko network flag. + Taiko bool `json:"taiko"` + OntakeBlock *big.Int `json:"ontakeBlock,omitempty"` // Ontake switch block (nil = no fork, 0 = already activated) + PacayaBlock *big.Int `json:"pacayaBlock,omitempty"` // Ontake switch block (nil = no fork, 0 = already activated) }   // EthashConfig is the consensus engine configs for proof-of-work based sealing. @@ -432,6 +449,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: banner += "Consensus: Beacon (proof-of-stake), merged from Ethash (proof-of-work)\n" case c.Clique != nil: @@ -617,6 +637,16 @@ // IsVerkle returns whether time is either equal to the Verkle fork time or greater. func (c *ChainConfig) IsVerkle(num *big.Int, time uint64) bool { return c.IsLondon(num) && isTimestampForked(c.VerkleTime, time) +} + +// CHANGE(taiko): IsOntake returns whether num is either equal to the Ontake fork block or greater. +func (c *ChainConfig) IsOntake(num *big.Int) bool { + return isBlockForked(c.OntakeBlock, num) +} + +// CHANGE(taiko): IsPacaya returns whether num is either equal to the pacaya fork block or greater. +func (c *ChainConfig) IsPacaya(num *big.Int) bool { + return isBlockForked(c.PacayaBlock, num) }   // IsVerkleGenesis checks whether the verkle fork is activated at the genesis block.

diff --git ethereum/go-ethereum/params/taiko_config.go taikoxyz/taiko-geth/params/taiko_config.go new file mode 100644 index 0000000000000000000000000000000000000000..1868396398c6dfa5e0cf7752ef6722eef9ac0820 --- /dev/null +++ taikoxyz/taiko-geth/params/taiko_config.go @@ -0,0 +1,95 @@ +package params + +import ( + "encoding/binary" + "math/big" + + "github.com/ethereum/go-ethereum/common" +) + +// To make taiko-geth compatible with the op-service library, we need to define the following constants and functions. +type ProtocolVersion [32]byte +type ProtocolVersionComparison int + +func (p ProtocolVersion) String() string { + return "" +} + +func (p ProtocolVersion) Compare(other ProtocolVersion) (cmp ProtocolVersionComparison) { + return 0 +} + +type ProtocolVersionV0 struct { + Build [8]byte + Major, Minor, Patch, PreRelease uint32 +} + +func (v ProtocolVersionV0) Encode() (out ProtocolVersion) { + copy(out[8:16], v.Build[:]) + binary.BigEndian.PutUint32(out[16:20], v.Major) + binary.BigEndian.PutUint32(out[20:24], v.Minor) + binary.BigEndian.PutUint32(out[24:28], v.Patch) + binary.BigEndian.PutUint32(out[28:32], v.PreRelease) + return +} + +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) + PreconfDevnetNetworkID = big.NewInt(167010) +) + +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, + PreconfDevnetNetworkID: TaikoChainConfig, + MainnetChainConfig.ChainID: MainnetChainConfig, + SepoliaChainConfig.ChainID: SepoliaChainConfig, + 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, + 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..21a1cc0575644ee36cb390a119a66d9a46e2e550 --- /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, + }, + { + "preconfDevnetNetworkID", + PreconfDevnetNetworkID, + TaikoChainConfig, + }, + { + "mainnet", + MainnetChainConfig.ChainID, + MainnetChainConfig, + }, + { + "sepolia", + SepoliaChainConfig.ChainID, + SepoliaChainConfig, + }, + { + "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/json.go taikoxyz/taiko-geth/rpc/json.go index e932389d17c7bc63aecbe2deebdcb40073a797ec..15649c2e17a80c4d9e3ca934de73de3b1545125d 100644 --- ethereum/go-ethereum/rpc/json.go +++ taikoxyz/taiko-geth/rpc/json.go @@ -41,6 +41,9 @@ )   var null = json.RawMessage("null")   +// CHANGE(taiko): make taiko-geth compatible with op-service +type JsonError = jsonError + type subscriptionResult struct { ID string `json:"subscription"` Result json.RawMessage `json:"result,omitempty"`

diff --git ethereum/go-ethereum/rpc/server.go taikoxyz/taiko-geth/rpc/server.go index 42b59f8f6f7f91216dbdbdd837ab02a54b1fb20f..a2edb9be952e44d902905700ccc5e5ba26db0a93 100644 --- ethereum/go-ethereum/rpc/server.go +++ taikoxyz/taiko-geth/rpc/server.go @@ -30,6 +30,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.