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

diff --git ethereum/go-ethereum/beacon/engine/gen_ed.go taikoxyz/taiko-geth/beacon/engine/gen_ed.go index 6893d64a1626a8e172a80865a5ccec6e4e0f53f6..adf754f65b81adc3fce30d8d209eff9c0bfe49e5 100644 --- ethereum/go-ethereum/beacon/engine/gen_ed.go +++ taikoxyz/taiko-geth/beacon/engine/gen_ed.go @@ -17,23 +17,24 @@ // MarshalJSON marshals as JSON. func (e ExecutableData) MarshalJSON() ([]byte, error) { type ExecutableData struct { - ParentHash common.Hash `json:"parentHash" gencodec:"required"` - FeeRecipient common.Address `json:"feeRecipient" gencodec:"required"` - StateRoot common.Hash `json:"stateRoot" gencodec:"required"` - ReceiptsRoot common.Hash `json:"receiptsRoot" gencodec:"required"` - LogsBloom hexutil.Bytes `json:"logsBloom" gencodec:"required"` - Random common.Hash `json:"prevRandao" gencodec:"required"` - Number hexutil.Uint64 `json:"blockNumber" gencodec:"required"` - GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"` - GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` - Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"` - ExtraData hexutil.Bytes `json:"extraData" gencodec:"required"` - BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` - BlockHash common.Hash `json:"blockHash" gencodec:"required"` - Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` - Withdrawals []*types.Withdrawal `json:"withdrawals"` - BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` - ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` + ParentHash common.Hash `json:"parentHash" gencodec:"required"` + FeeRecipient common.Address `json:"feeRecipient" gencodec:"required"` + StateRoot common.Hash `json:"stateRoot" gencodec:"required"` + ReceiptsRoot common.Hash `json:"receiptsRoot" gencodec:"required"` + LogsBloom hexutil.Bytes `json:"logsBloom" gencodec:"required"` + Random common.Hash `json:"prevRandao" gencodec:"required"` + Number hexutil.Uint64 `json:"blockNumber" gencodec:"required"` + GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` + Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"` + ExtraData hexutil.Bytes `json:"extraData" gencodec:"required"` + BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` + BlockHash common.Hash `json:"blockHash" gencodec:"required"` + Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` + Withdrawals []*types.Withdrawal `json:"withdrawals"` + TxHash common.Hash `json:"txHash"` + WithdrawalsHash common.Hash `json:"withdrawalsHash"` + TaikoBlock bool } var enc ExecutableData enc.ParentHash = e.ParentHash @@ -56,31 +57,33 @@ enc.Transactions[k] = v } } enc.Withdrawals = e.Withdrawals - enc.BlobGasUsed = (*hexutil.Uint64)(e.BlobGasUsed) - enc.ExcessBlobGas = (*hexutil.Uint64)(e.ExcessBlobGas) + enc.TxHash = e.TxHash + enc.WithdrawalsHash = e.WithdrawalsHash + enc.TaikoBlock = e.TaikoBlock return json.Marshal(&enc) }   // UnmarshalJSON unmarshals from JSON. func (e *ExecutableData) UnmarshalJSON(input []byte) error { type ExecutableData struct { - ParentHash *common.Hash `json:"parentHash" gencodec:"required"` - FeeRecipient *common.Address `json:"feeRecipient" gencodec:"required"` - StateRoot *common.Hash `json:"stateRoot" gencodec:"required"` - ReceiptsRoot *common.Hash `json:"receiptsRoot" gencodec:"required"` - LogsBloom *hexutil.Bytes `json:"logsBloom" gencodec:"required"` - Random *common.Hash `json:"prevRandao" gencodec:"required"` - Number *hexutil.Uint64 `json:"blockNumber" gencodec:"required"` - GasLimit *hexutil.Uint64 `json:"gasLimit" gencodec:"required"` - GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` - Timestamp *hexutil.Uint64 `json:"timestamp" gencodec:"required"` - ExtraData *hexutil.Bytes `json:"extraData" gencodec:"required"` - BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` - BlockHash *common.Hash `json:"blockHash" gencodec:"required"` - Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` - Withdrawals []*types.Withdrawal `json:"withdrawals"` - BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` - ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` + ParentHash *common.Hash `json:"parentHash" gencodec:"required"` + FeeRecipient *common.Address `json:"feeRecipient" gencodec:"required"` + StateRoot *common.Hash `json:"stateRoot" gencodec:"required"` + ReceiptsRoot *common.Hash `json:"receiptsRoot" gencodec:"required"` + LogsBloom *hexutil.Bytes `json:"logsBloom" gencodec:"required"` + Random *common.Hash `json:"prevRandao" gencodec:"required"` + Number *hexutil.Uint64 `json:"blockNumber" gencodec:"required"` + GasLimit *hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` + Timestamp *hexutil.Uint64 `json:"timestamp" gencodec:"required"` + ExtraData *hexutil.Bytes `json:"extraData" gencodec:"required"` + BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` + BlockHash *common.Hash `json:"blockHash" gencodec:"required"` + Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` + Withdrawals []*types.Withdrawal `json:"withdrawals"` + TxHash *common.Hash `json:"txHash"` + WithdrawalsHash *common.Hash `json:"withdrawalsHash"` + TaikoBlock *bool } var dec ExecutableData if err := json.Unmarshal(input, &dec); err != nil { @@ -148,11 +151,14 @@ } if dec.Withdrawals != nil { e.Withdrawals = dec.Withdrawals } - if dec.BlobGasUsed != nil { - e.BlobGasUsed = (*uint64)(dec.BlobGasUsed) + if dec.TxHash != nil { + e.TxHash = *dec.TxHash + } + if dec.WithdrawalsHash != nil { + e.WithdrawalsHash = *dec.WithdrawalsHash } - if dec.ExcessBlobGas != nil { - e.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas) + if dec.TaikoBlock != nil { + e.TaikoBlock = *dec.TaikoBlock } return nil }

diff --git ethereum/go-ethereum/beacon/engine/gen_blockparams.go taikoxyz/taiko-geth/beacon/engine/gen_blockparams.go index 0dd2b52597ad5ddc7fc46d97c6c8878edf29d471..1e339ba893cdd219360a423c2da5aeaf006e8de9 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" )   @@ -20,12 +22,18 @@ Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"` Random common.Hash `json:"prevRandao" gencodec:"required"` SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` + 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) enc.Random = p.Random enc.SuggestedFeeRecipient = p.SuggestedFeeRecipient enc.Withdrawals = p.Withdrawals + enc.BaseFeePerGas = p.BaseFeePerGas + enc.BlockMetadata = p.BlockMetadata + enc.L1Origin = p.L1Origin return json.Marshal(&enc) }   @@ -36,6 +44,9 @@ Timestamp *hexutil.Uint64 `json:"timestamp" gencodec:"required"` Random *common.Hash `json:"prevRandao" gencodec:"required"` SuggestedFeeRecipient *common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` + 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 { @@ -56,5 +67,17 @@ p.SuggestedFeeRecipient = *dec.SuggestedFeeRecipient if dec.Withdrawals != nil { p.Withdrawals = dec.Withdrawals } + 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/types.go taikoxyz/taiko-geth/beacon/engine/types.go index f1801edd1a93c548936c7db378e0905db9b155cd..d1c0a8e7b1101c3c46795935f9399432de3d4b4e 100644 --- ethereum/go-ethereum/beacon/engine/types.go +++ taikoxyz/taiko-geth/beacon/engine/types.go @@ -22,6 +22,7 @@ "math/big"   "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto/kzg4844" "github.com/ethereum/go-ethereum/trie" @@ -36,6 +37,10 @@ Timestamp uint64 `json:"timestamp" gencodec:"required"` Random common.Hash `json:"prevRandao" gencodec:"required"` SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` + // CHANGE(taiko): extra fields. + BaseFeePerGas *big.Int `json:"baseFeePerGas" gencodec:"required"` + BlockMetadata *BlockMetadata `json:"blockMetadata" gencodec:"required"` + L1Origin *rawdb.L1Origin `json:"l1Origin" gencodec:"required"` }   // JSON type overrides for PayloadAttributes. @@ -43,6 +48,28 @@ type payloadAttributesMarshaling struct { Timestamp hexutil.Uint64 }   +//go:generate go run github.com/fjl/gencodec -type BlockMetadata -field-override blockMetadataMarshaling -out gen_blockmetadata.go + +// CHANGE(taiko): BlockMetadata represents a `BlockMetadata` struct defined in +// protocol. +type BlockMetadata struct { + // Fields defined in `LibData.blockMetadata`. + Beneficiary common.Address `json:"beneficiary" gencodec:"required"` + GasLimit uint64 `json:"gasLimit" gencodec:"required"` + Timestamp uint64 `json:"timestamp" gencodec:"required"` + MixHash common.Hash `json:"mixHash" gencodec:"required"` + + // Extra fields required in go-taiko. + TxList []byte `json:"txList" gencodec:"required"` + HighestBlockID *big.Int `json:"highestBlockID" gencodec:"required"` +} + +// CHANGE(taiko): JSON type overrides for BlockMetadata. +type blockMetadataMarshaling struct { + Timestamp hexutil.Uint64 + TxList hexutil.Bytes +} + //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. @@ -64,6 +91,10 @@ Transactions [][]byte `json:"transactions" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BlobGasUsed *uint64 `json:"blobGasUsed"` ExcessBlobGas *uint64 `json:"excessBlobGas"` + + TxHash common.Hash `json:"txHash"` // CHANGE(taiko): allow passing txHash directly instead of transactions list + WithdrawalsHash common.Hash `json:"withdrawalsHash"` // CHANGE(taiko): allow passing WithdrawalsHash directly instead of withdrawals + TaikoBlock bool // CHANGE(taiko): whether this is a Taiko L2 block, only used by ExecutableDataToBlock }   // JSON type overrides for executableData.

diff --git ethereum/go-ethereum/cmd/geth/main.go taikoxyz/taiko-geth/cmd/geth/main.go index 568aec4b8b7a8204ea0e49be3b123b51f39b7d66..08d9a2a876269b8d70f3023d3bd3697e94a9f8ad 100644 --- ethereum/go-ethereum/cmd/geth/main.go +++ taikoxyz/taiko-geth/cmd/geth/main.go @@ -242,6 +242,9 @@ debug.Flags, metricsFlags, )   + // CHANGE(taiko): append Taiko flags into the original GETH flags + app.Flags = append(app.Flags, &utils.TaikoFlag) + app.Before = func(ctx *cli.Context) error { maxprocs.Set() // Automatically set GOMAXPROCS to match Linux container CPU quota. flags.MigrateGlobalFlags(ctx)

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

diff --git ethereum/go-ethereum/cmd/utils/flags.go taikoxyz/taiko-geth/cmd/utils/flags.go index e0c7a42670e1549224ce8df8fadd6ee80eefb2de..8c70eb10b0583177a00d45ba9c649b6d1f6a55d0 100644 --- ethereum/go-ethereum/cmd/utils/flags.go +++ taikoxyz/taiko-geth/cmd/utils/flags.go @@ -1745,6 +1745,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/geth/config.go taikoxyz/taiko-geth/cmd/geth/config.go index 1a3de04bd4d2ad68682ee3495c08c3f7357cb7ea..9901ee919ebea87743bac36f7ae8395520ba7692 100644 --- ethereum/go-ethereum/cmd/geth/config.go +++ taikoxyz/taiko-geth/cmd/geth/config.go @@ -177,6 +177,9 @@ cfg.Eth.OverrideVerkle = &v } backend, eth := utils.RegisterEthService(stack, &cfg.Eth)   + // CHANGE(TAIKO): register Taiko RPC APIs. + utils.RegisterTaikoAPIs(stack, &cfg.Eth, eth) + // Configure log filter RPC API. filterSystem := utils.RegisterFilterAPI(stack, backend, &cfg.Eth)

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

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

diff --git ethereum/go-ethereum/core/state_processor.go taikoxyz/taiko-geth/core/state_processor.go index fcaf5a8ff3c9bd36cd741f5a3d413521ff8ab2d2..828f841145929c2abb6f758b94aaccc8fbcd164e 100644 --- ethereum/go-ethereum/core/state_processor.go +++ taikoxyz/taiko-geth/core/state_processor.go @@ -78,6 +78,11 @@ signer = types.MakeSigner(p.config, header.Number, header.Time) ) // Iterate over and process the individual transactions for i, tx := range block.Transactions() { + if i == 0 && p.config.Taiko { + if err := tx.MarkAsAnchor(); err != nil { + return nil, nil, 0, err + } + } msg, err := TransactionToMessage(tx, signer, header.BaseFee) if err != nil { return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)

diff --git ethereum/go-ethereum/core/taiko_genesis.go taikoxyz/taiko-geth/core/taiko_genesis.go new file mode 100644 index 0000000000000000000000000000000000000000..b04cac1b5cfa78d77ab2042de9f9d61da6f2fc08 --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_genesis.go @@ -0,0 +1,58 @@ +package core + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" + taikoGenesis "github.com/ethereum/go-ethereum/core/taiko_genesis" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" +) + +// TaikoGenesisBlock returns the Taiko network genesis block configs. +func TaikoGenesisBlock(networkID uint64) *Genesis { + chainConfig := params.TaikoChainConfig + + var allocJSON []byte + switch networkID { + case params.TaikoInternalNetworkID.Uint64(): + chainConfig.ChainID = params.TaikoInternalNetworkID + allocJSON = taikoGenesis.InternalGenesisAllocJSON + case params.TaikoInternalL3NetworkID.Uint64(): + chainConfig.ChainID = params.TaikoInternalL3NetworkID + allocJSON = taikoGenesis.InternalL3GenesisAllocJSON + 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 + default: + chainConfig.ChainID = params.TaikoInternalNetworkID + allocJSON = taikoGenesis.InternalGenesisAllocJSON + } + + 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(8000000), + Difficulty: common.Big0, + Alloc: alloc, + GasUsed: 0, + BaseFee: new(big.Int).SetUint64(10000000), + } +}

diff --git ethereum/go-ethereum/core/state_transition.go taikoxyz/taiko-geth/core/state_transition.go index f84757be781fba4beec4d64c5fa832c259a80a3e..13a9852a8b5840b7180622fbeaccf0828cfbcb56 100644 --- ethereum/go-ethereum/core/state_transition.go +++ taikoxyz/taiko-geth/core/state_transition.go @@ -30,6 +30,10 @@ "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/params" )   +var ( + treasury = common.HexToAddress("0xdf09A0afD09a63fb04ab3573922437e1e637dE8b") +) + // ExecutionResult includes all output after executing given evm // message no matter the execution itself is successful or not. type ExecutionResult struct { @@ -144,6 +148,9 @@ // When SkipAccountChecks is true, the message nonce is not checked against the // account nonce in state. It also disables checking that the sender is an EOA. // This field will be set to true for operations like RPC eth_call. SkipAccountChecks bool + + // CHANGE(taiko): whether the current transaction is the first TaikoL2.anchor transaction in a block. + IsAnchor bool }   // TransactionToMessage converts a transaction into a Message. @@ -161,6 +168,7 @@ AccessList: tx.AccessList(), SkipAccountChecks: false, BlobHashes: tx.BlobHashes(), BlobGasFeeCap: tx.BlobGasFeeCap(), + IsAnchor: tx.IsAnchor(), } // If baseFee provided, set gasPrice to effectiveGasPrice. if baseFee != nil { @@ -252,6 +260,11 @@ blobFee.Mul(blobFee, eip4844.CalcBlobFee(*st.evm.Context.ExcessBlobGas)) mgval.Add(mgval, blobFee) } } + // CHANGE(taiko): skip balance check for TaikoL2.anchor transaction. + if st.msg.IsAnchor { + balanceCheck = common.Big0 + mgval = common.Big0 + } if have, want := st.state.GetBalance(st.msg.From), balanceCheck; have.Cmp(want) < 0 { return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From.Hex(), have, want) } @@ -292,7 +305,7 @@ // Make sure that transaction gasFeeCap is greater than the baseFee (post london) if st.evm.ChainConfig().IsLondon(st.evm.Context.BlockNumber) { // Skip the checks if gas fields are zero and baseFee was explicitly disabled (eth_call) - if !st.evm.Config.NoBaseFee || msg.GasFeeCap.BitLen() > 0 || msg.GasTipCap.BitLen() > 0 { + if (!st.evm.Config.NoBaseFee || msg.GasFeeCap.BitLen() > 0 || msg.GasTipCap.BitLen() > 0) && !st.msg.IsAnchor { if l := msg.GasFeeCap.BitLen(); l > 256 { return fmt.Errorf("%w: address %v, maxFeePerGas bit length: %d", ErrFeeCapVeryHigh, msg.From.Hex(), l) @@ -436,6 +449,13 @@ } else { fee := new(big.Int).SetUint64(st.gasUsed()) fee.Mul(fee, effectiveTip) st.state.AddBalance(st.evm.Context.Coinbase, fee) + // CHANGE(taiko): basefee is not burnt, but sent to a treasury instead. + if st.evm.ChainConfig().Taiko && st.evm.Context.BaseFee != nil && !st.msg.IsAnchor { + st.state.AddBalance( + treasury, + new(big.Int).Mul(st.evm.Context.BaseFee, new(big.Int).SetUint64(st.gasUsed())), + ) + } }   return &ExecutionResult{

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

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

diff --git ethereum/go-ethereum/core/types/tx_dynamic_fee.go taikoxyz/taiko-geth/core/types/tx_dynamic_fee.go index 47b870abbf5c028fef7984dc00b320a1b5848ec8..2676dc74ac3566a1a158db978d7abb991a404183 100644 --- ethereum/go-ethereum/core/types/tx_dynamic_fee.go +++ taikoxyz/taiko-geth/core/types/tx_dynamic_fee.go @@ -38,6 +38,9 @@ // Signature values V *big.Int `json:"v" gencodec:"required"` R *big.Int `json:"r" gencodec:"required"` S *big.Int `json:"s" gencodec:"required"` + + // CHANGE(taiko): if this transaction is the first TaikoL2.anchor transaction in a block + isAnhcor bool }   // copy creates a deep copy of the transaction data and initializes all fields. @@ -56,6 +59,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/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..763ef7550e676883b515b911d27e7a8f6fb332ad --- /dev/null +++ taikoxyz/taiko-geth/core/taiko_genesis/genesis_alloc.go @@ -0,0 +1,26 @@ +package taiko_genesis + +import ( + _ "embed" +) + +//go:embed internal.json +var InternalGenesisAllocJSON []byte + +//go:embed internal_l3.json +var InternalL3GenesisAllocJSON []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

diff --git ethereum/go-ethereum/core/txpool/validation.go taikoxyz/taiko-geth/core/txpool/validation.go index e1c0f314c789ee2da09c6fe32508b924c8c1309b..72c0b16ea6c1ce7f245e6326b9e1a7252ac22d77 100644 --- ethereum/go-ethereum/core/txpool/validation.go +++ taikoxyz/taiko-geth/core/txpool/validation.go @@ -18,8 +18,10 @@ package txpool   import ( "crypto/sha256" + "errors" "fmt" "math/big" + "os"   "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" @@ -90,6 +92,11 @@ // Ensure gasFeeCap is greater than or equal to gasTipCap if tx.GasFeeCapIntCmp(tx.GasTipCap()) < 0 { return core.ErrTipAboveFeeCap } + // CHANGE(taiko): ensure gasFeeCap fee cap is not zero + if os.Getenv("TAIKO_TEST") == "" && 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 { return ErrInvalidSender

diff --git ethereum/go-ethereum/core/types/transaction.go taikoxyz/taiko-geth/core/types/transaction.go index e774809c29d97392171f70bb3cfe5c33d65834f8..ffdacadf0e64070e066db21ea8463f3125b5b606 100644 --- ethereum/go-ethereum/core/types/transaction.go +++ taikoxyz/taiko-geth/core/types/transaction.go @@ -85,6 +85,8 @@ to() *common.Address blobGas() uint64 blobGasFeeCap() *big.Int blobHashes() []common.Hash + isAnchor() bool + markAsAnchor() error   rawSignatureValues() (v, r, s *big.Int) setSignatureValues(chainID, v, r, s *big.Int)

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

diff --git ethereum/go-ethereum/eth/taiko_api_backend.go taikoxyz/taiko-geth/eth/taiko_api_backend.go new file mode 100644 index 0000000000000000000000000000000000000000..49e8580b664fe7c9a43be5493942ee1d2345817f --- /dev/null +++ taikoxyz/taiko-geth/eth/taiko_api_backend.go @@ -0,0 +1,91 @@ +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/core/types" + "github.com/ethereum/go-ethereum/log" +) + +// TaikoAPIBackend handles l2 node related RPC calls. +type TaikoAPIBackend struct { + eth *Ethereum +} + +// NewTaikoAPIBackend creates a new TaikoAPIBackend instance. +func NewTaikoAPIBackend(eth *Ethereum) *TaikoAPIBackend { + return &TaikoAPIBackend{ + eth: eth, + } +} + +// HeadL1Origin returns the latest L2 block's corresponding L1 origin. +func (s *TaikoAPIBackend) HeadL1Origin() (*rawdb.L1Origin, error) { + blockID, err := rawdb.ReadHeadL1Origin(s.eth.ChainDb()) + if err != nil { + return nil, err + } + + if blockID == nil { + return nil, ethereum.NotFound + } + + l1Origin, err := rawdb.ReadL1Origin(s.eth.ChainDb(), blockID) + if err != nil { + return nil, err + } + + if l1Origin == nil { + return nil, ethereum.NotFound + } + + return l1Origin, nil +} + +// L1OriginByID returns the L2 block's corresponding L1 origin. +func (s *TaikoAPIBackend) L1OriginByID(blockID *math.HexOrDecimal256) (*rawdb.L1Origin, error) { + l1Origin, err := rawdb.ReadL1Origin(s.eth.ChainDb(), (*big.Int)(blockID)) + if err != nil { + return nil, err + } + + if l1Origin == nil { + return nil, ethereum.NotFound + } + + return l1Origin, nil +} + +// TxPoolContent retrieves the transaction pool content with the given upper limits. +func (s *TaikoAPIBackend) TxPoolContent( + beneficiary common.Address, + baseFee *big.Int, + maxTransactionsPerBlock uint64, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + locals []string, + maxTransactionsLists uint64, +) ([]types.Transactions, error) { + log.Info( + "Fetching L2 pending transactions finished", + "maxTransactionsPerBlock", maxTransactionsPerBlock, + "blockMaxGasLimit", blockMaxGasLimit, + "maxBytesPerTxList", maxBytesPerTxList, + "maxTransactions", maxTransactionsLists, + "locals", locals, + ) + + return s.eth.Miner().BuildTransactionsLists( + beneficiary, + baseFee, + maxTransactionsPerBlock, + blockMaxGasLimit, + maxBytesPerTxList, + locals, + maxTransactionsLists, + ) +}

diff --git ethereum/go-ethereum/eth/catalyst/api.go taikoxyz/taiko-geth/eth/catalyst/api.go index 1a221941427a0c935fc8a69d1be6c7ab534ac75c..3eb625227094c7e0c6f14cde8aa8952968017b8c 100644 --- ethereum/go-ethereum/eth/catalyst/api.go +++ taikoxyz/taiko-geth/eth/catalyst/api.go @@ -286,6 +286,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 { @@ -295,6 +299,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. @@ -339,6 +347,55 @@ // If payload generation was requested, create a new block to be potentially // sealed by the beacon client. The payload will be requested later, and we // will replace it arbitrarily many times in between. if payloadAttributes != nil { + // CHANGE(taiko): create a L2 block by Taiko protocol. + if isTaiko { + // No need to check payloadAttribute here, because all its fields are + // marked as required. + block, err := api.eth.Miner().SealBlockWith( + update.HeadBlockHash, + payloadAttributes.Timestamp, + payloadAttributes.BlockMetadata, + payloadAttributes.BaseFeePerGas, + payloadAttributes.Withdrawals, + ) + if err != nil { + log.Error("Failed to create sealing block", "err", err) + return valid(nil), engine.InvalidPayloadAttributes.With(err) + } + + // Cache the mined block for later use. + args := &miner.BuildPayloadArgs{ + Parent: block.ParentHash(), + Timestamp: block.Time(), + FeeRecipient: block.Coinbase(), + Random: block.MixDigest(), + Withdrawals: block.Withdrawals(), + } + id := args.Id() + payload, err := api.eth.Miner().BuildPayload(args) + if err != nil { + log.Error("Failed to build payload", "err", err) + return valid(nil), engine.InvalidPayloadAttributes.With(err) + } + + payload.SetFullBlock(block, common.Big0) + + api.localBlocks.put(id, payload) + + // L1Origin **MUST NOT** be nil, it's a required field in PayloadAttributesV1. + l1Origin := payloadAttributes.L1Origin + + // Set the block hash before inserting the L1Origin into database. + l1Origin.L2BlockHash = block.Hash() + + // Write L1Origin. + rawdb.WriteL1Origin(api.eth.ChainDb(), l1Origin.BlockID, l1Origin) + // Write the head L1Origin. + rawdb.WriteHeadL1Origin(api.eth.ChainDb(), l1Origin.BlockID) + + return valid(&id), nil + } + args := &miner.BuildPayloadArgs{ Parent: update.HeadBlockHash, Timestamp: payloadAttributes.Timestamp, @@ -432,7 +489,8 @@ // NewPayloadV2 creates an Eth1 block, inserts it in the chain, and returns the status of the chain. func (api *ConsensusAPI) NewPayloadV2(params engine.ExecutableData) (engine.PayloadStatusV1, error) { if api.eth.BlockChain().Config().IsShanghai(new(big.Int).SetUint64(params.Number), params.Timestamp) { - if params.Withdrawals == nil { + if params.Withdrawals == nil && + (api.eth.BlockChain().Config().Taiko && params.WithdrawalsHash == (common.Hash{})) { // CHANGE(taiko): allow only passing `WithdrawalsHash` return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("nil withdrawals post-shanghai")) } } else if params.Withdrawals != nil { @@ -478,10 +536,37 @@ api.newPayloadLock.Lock() defer api.newPayloadLock.Unlock()   log.Trace("Engine API request received", "method", "NewPayload", "number", params.Number, "hash", params.BlockHash) - block, err := engine.ExecutableDataToBlock(params, versionedHashes) - if err != nil { - log.Warn("Invalid NewPayload params", "params", params, "error", err) - return engine.PayloadStatusV1{Status: engine.INVALID}, nil + // CHANGE(taiko): allow passing the executable data with txHash instead of all transactions. + var ( + block *types.Block + err error + ) + params.TaikoBlock = api.eth.BlockChain().Config().Taiko + if api.eth.BlockChain().Config().Taiko && params.Transactions == nil && params.Withdrawals == nil { + block = types.NewBlockWithHeader(&types.Header{ + ParentHash: params.ParentHash, + UncleHash: types.EmptyUncleHash, + Coinbase: params.FeeRecipient, + Root: params.StateRoot, + TxHash: params.TxHash, + ReceiptHash: params.ReceiptsRoot, + Bloom: types.BytesToBloom(params.LogsBloom), + Difficulty: common.Big0, + Number: new(big.Int).SetUint64(params.Number), + GasLimit: params.GasLimit, + GasUsed: params.GasUsed, + Time: params.Timestamp, + BaseFee: params.BaseFeePerGas, + Extra: params.ExtraData, + MixDigest: params.Random, + WithdrawalsHash: &params.WithdrawalsHash, + }) + } else { + block, err = engine.ExecutableDataToBlock(params, versionedHashes) + if err != nil { + log.Debug("Invalid NewPayload params", "params", params, "error", err) + return engine.PayloadStatusV1{Status: engine.INVALID}, nil + } } // Stash away the last update to warn the user if the beacon client goes offline api.lastNewPayloadLock.Lock() @@ -524,9 +609,18 @@ if parent.Difficulty().BitLen() > 0 && gptd != nil && gptd.Cmp(ttd) >= 0 { log.Error("Ignoring pre-merge parent block", "number", params.Number, "hash", params.BlockHash, "td", ptd, "ttd", ttd) return engine.INVALID_TERMINAL_BLOCK, nil } - if block.Time() <= parent.Time() { - log.Warn("Invalid timestamp", "parent", block.Time(), "block", block.Time()) - return api.invalid(errors.New("invalid timestamp"), parent.Header()), nil + // CHANGE(taiko): a block that has the same timestamp as its parents is + // allowed in Taiko protocol. + if api.eth.BlockChain().Config().Taiko { + if block.Time() < parent.Time() { + log.Warn("Invalid timestamp", "parent", block.Time(), "block", block.Time()) + return api.invalid(errors.New("invalid timestamp"), parent.Header()), nil + } + } else { + if block.Time() <= parent.Time() { + log.Warn("Invalid timestamp", "parent", block.Time(), "block", block.Time()) + return api.invalid(errors.New("invalid timestamp"), parent.Header()), nil + } } // Another cornercase: if the node is in snap sync mode, but the CL client // tries to make it import a block. That should be denied as pushing something

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

diff --git ethereum/go-ethereum/eth/ethconfig/config.go taikoxyz/taiko-geth/eth/ethconfig/config.go index 4bc8b8dc6c6e5c0ad63855d38290742f1b1f6b7f..b570fe8f2aff7c9e38f335594af6ffd77d086eb6 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" @@ -164,6 +165,10 @@ // CreateConsensusEngine creates a consensus engine for the given chain config. // Clique is allowed for now to live standalone, but ethash is forbidden and can // only exist on already merged networks. func CreateConsensusEngine(config *params.ChainConfig, db ethdb.Database) (consensus.Engine, error) { + // CHANGE(taiko): use Taiko consensus engine when the --taiko flag is set. + if config.Taiko { + return taiko.New(config), nil + } // If proof-of-authority is requested, set it up if config.Clique != nil { return beacon.New(clique.New(config.Clique, db)), nil

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

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

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

diff --git ethereum/go-ethereum/miner/taiko_worker.go taikoxyz/taiko-geth/miner/taiko_worker.go new file mode 100644 index 0000000000000000000000000000000000000000..df14d908680a5f30df0ddd9a24890efcafc06c7d --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_worker.go @@ -0,0 +1,290 @@ +package miner + +import ( + "errors" + "fmt" + "math/big" + "time" + + "github.com/ethereum/go-ethereum/beacon/engine" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/txpool" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rlp" +) + +// BuildTransactionsLists builds multiple transactions lists which satisfy all the given limits. +func (w *worker) BuildTransactionsLists( + beneficiary common.Address, + baseFee *big.Int, + maxTransactionsPerBlock uint64, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + localAccounts []string, + maxTransactionsLists uint64, +) ([]types.Transactions, error) { + var ( + txsLists []types.Transactions + currentHead = w.chain.CurrentBlock() + ) + + if currentHead == nil { + return nil, fmt.Errorf("failed to find current head") + } + + // Split the pending transactions into locals and remotes, then + // fill the block with all available pending transactions. + pending := w.eth.TxPool().Pending(false) + 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 + } + } + + if len(pending) == 0 { + return txsLists, nil + } + + var ( + signer = types.MakeSigner(w.chainConfig, new(big.Int).Add(currentHead.Number, common.Big1), currentHead.Time) + locals = newTransactionsByPriceAndNonce(signer, localTxs, baseFee) + remotes = newTransactionsByPriceAndNonce(signer, remoteTxs, baseFee) + ) + + params := &generateParams{ + timestamp: uint64(time.Now().Unix()), + forceTime: true, + parentHash: currentHead.Hash(), + coinbase: beneficiary, + random: currentHead.MixDigest, + noTxs: false, + baseFeePerGas: baseFee, + } + + env, err := w.prepareWork(params) + if err != nil { + return nil, err + } + defer env.discard() + + commitTxs := func() (types.Transactions, bool, error) { + env.tcount = 0 + env.txs = []*types.Transaction{} + env.gasPool = new(core.GasPool).AddGas(blockMaxGasLimit) + env.header.GasLimit = blockMaxGasLimit + + allTxsCommitted := w.commitL2Transactions(env, locals, remotes, maxTransactionsPerBlock, maxBytesPerTxList) + + return env.txs, allTxsCommitted, nil + } + + for i := 0; i < int(maxTransactionsLists); i++ { + txs, allCommitted, err := commitTxs() + if err != nil { + return nil, err + } + + txsLists = append(txsLists, txs) + + if allCommitted { + break + } + } + + return txsLists, nil +} + +// sealBlockWith mines and seals a block with the given block metadata. +func (w *worker) sealBlockWith( + parent common.Hash, + timestamp uint64, + blkMeta *engine.BlockMetadata, + baseFeePerGas *big.Int, + withdrawals types.Withdrawals, +) (*types.Block, error) { + // Decode transactions bytes. + var txs types.Transactions + if err := rlp.DecodeBytes(blkMeta.TxList, &txs); err != nil { + return nil, fmt.Errorf("failed to decode txList: %w", err) + } + + if len(txs) == 0 { + // A L2 block needs to have have at least one `V1TaikoL2.anchor` or + // `V1TaikoL2.invalidateBlock` transaction. + return nil, fmt.Errorf("too less transactions in the block") + } + + params := &generateParams{ + timestamp: timestamp, + forceTime: true, + parentHash: parent, + coinbase: blkMeta.Beneficiary, + random: blkMeta.MixHash, + withdrawals: withdrawals, + noTxs: false, + baseFeePerGas: baseFeePerGas, + } + + env, err := w.prepareWork(params) + if err != nil { + return nil, err + } + defer env.discard() + + env.header.GasLimit = blkMeta.GasLimit + + // Commit transactions. + gasLimit := env.header.GasLimit + rules := w.chain.Config().Rules(env.header.Number, true, timestamp) + + env.gasPool = new(core.GasPool).AddGas(gasLimit) + + for i, tx := range txs { + if i == 0 { + if err := tx.MarkAsAnchor(); err != nil { + return nil, err + } + } + sender, err := types.LatestSignerForChainID(tx.ChainId()).Sender(tx) + if err != nil { + log.Info("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, &txpool.Transaction{Tx: tx}); err != nil { + log.Info("Skip an invalid proposed transaction", "hash", tx.Hash(), "reason", err) + continue + } + env.tcount++ + } + + block, err := w.engine.FinalizeAndAssemble(w.chain, env.header, env.state, env.txs, nil, env.receipts, withdrawals) + if err != nil { + return nil, err + } + + results := make(chan *types.Block, 1) + if err := w.engine.Seal(w.chain, block, results, nil); err != nil { + return nil, err + } + block = <-results + + return block, nil +} + +// commitL2Transactions tries to commit the transactions into the given state. +func (w *worker) commitL2Transactions( + env *environment, + txsLocal *transactionsByPriceAndNonce, + txsRemote *transactionsByPriceAndNonce, + maxTransactionsPerBlock uint64, + maxBytesPerTxList uint64, +) bool { + var ( + txs = txsLocal + isLocal = true + allTxsCommitted bool + accTxListBytes int + ) + +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 + } + allTxsCommitted = true + break + } + tx := ltx.Resolve() + if tx == nil { + log.Warn("Ignoring evicted transaction") + + 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.Tx) + + b, err := rlp.EncodeToBytes(tx) + if err != nil { + log.Trace("Failed to rlp encode the pending transaction %s: %w", tx.Tx.Hash(), err) + txs.Pop() + continue + } + if accTxListBytes+len(b) >= int(maxBytesPerTxList) { + break + } + + // 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.Tx.Protected() && !w.chainConfig.IsEIP155(env.header.Number) { + log.Trace("Ignoring reply protected transaction", "hash", tx.Tx.Hash(), "eip155", w.chainConfig.EIP155Block) + + txs.Pop() + continue + } + // Start executing the transaction + env.state.SetTxContext(tx.Tx.Hash(), env.tcount) + + _, err = w.commitTransaction(env, tx) + switch { + case errors.Is(err, core.ErrGasLimitReached): + // Pop the current out-of-gas transaction without shifting in the next from the account + log.Trace("Gas limit exceeded for current block", "sender", from) + txs.Pop() + + 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", "sender", from, "nonce", tx.Tx.Nonce()) + txs.Shift() + + case errors.Is(err, core.ErrNonceTooHigh): + // Reorg notification data race between the transaction pool and miner, skip account = + log.Trace("Skipping account with hight nonce", "sender", from, "nonce", tx.Tx.Nonce()) + txs.Pop() + + case errors.Is(err, nil): + // Everything ok, shift in the next transaction from the same account + env.tcount++ + if env.tcount >= int(maxTransactionsPerBlock) { + break loop + } + accTxListBytes += len(b) + txs.Shift() + + case errors.Is(err, types.ErrTxTypeNotSupported): + // Pop the unsupported transaction without shifting in the next from the account + log.Trace("Skipping unsupported transaction type", "sender", from, "type", tx.Tx.Type()) + txs.Pop() + + default: + // Strange error, discard the transaction and get the next in line (note, the + // nonce-too-high clause will prevent us from executing in vain). + log.Debug("Transaction failed, account skipped", "hash", tx.Tx.Hash(), "err", err) + txs.Shift() + } + } + + return allTxsCommitted +}

diff --git ethereum/go-ethereum/miner/taiko_miner.go taikoxyz/taiko-geth/miner/taiko_miner.go new file mode 100644 index 0000000000000000000000000000000000000000..a5374f6ee2a1f9967a7c05fb92ab46d29a869bb6 --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_miner.go @@ -0,0 +1,41 @@ +package miner + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/beacon/engine" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// SealBlockWith mines and seals a block without changing the canonical chain. +func (miner *Miner) SealBlockWith( + parent common.Hash, + timestamp uint64, + blkMeta *engine.BlockMetadata, + baseFeePerGas *big.Int, + withdrawals types.Withdrawals, +) (*types.Block, error) { + return miner.worker.sealBlockWith(parent, timestamp, blkMeta, baseFeePerGas, withdrawals) +} + +// BuildTransactionsLists builds multiple transactions lists which satisfy all the given limits. +func (miner *Miner) BuildTransactionsLists( + beneficiary common.Address, + baseFee *big.Int, + maxTransactionsPerBlock uint64, + blockMaxGasLimit uint64, + maxBytesPerTxList uint64, + locals []string, + maxTransactionsLists uint64, +) ([]types.Transactions, error) { + return miner.worker.BuildTransactionsLists( + beneficiary, + baseFee, + maxTransactionsPerBlock, + blockMaxGasLimit, + maxBytesPerTxList, + locals, + maxTransactionsLists, + ) +}

diff --git ethereum/go-ethereum/miner/payload_building.go taikoxyz/taiko-geth/miner/payload_building.go index 299196a3cdf3fcc872508859a7b0193ba47ded20..d0d36fdee9158dbc4e599fce3e698af9cddaebf0 100644 --- ethereum/go-ethereum/miner/payload_building.go +++ taikoxyz/taiko-geth/miner/payload_building.go @@ -69,6 +69,7 @@ fullFees *big.Int stop chan struct{} lock sync.Mutex cond *sync.Cond + done chan struct{} // CHANGE(taiko): done channel to communicate we shouldnt write to `stop` channel. }   // newPayload initializes the payload object. @@ -77,6 +78,7 @@ payload := &Payload{ id: id, empty: empty, stop: make(chan struct{}), + done: make(chan struct{}, 1), // CHANGE(taiko): buffered channel to communicate done to taiko payload builder } log.Info("Starting work on payload", "id", payload.id) payload.cond = sync.NewCond(&payload.lock) @@ -117,6 +119,7 @@ select { case <-payload.stop: default: + payload.done <- struct{}{} // CHANGE(taiko): signal to taiko payload builder to not write to `payload.stop` channel close(payload.stop) } if payload.full != nil { @@ -188,6 +191,10 @@ for { select { case <-timer.C: + // CHANGE(taiko): do not update payload. + if w.chainConfig.Taiko { + continue + } start := time.Now() block, fees, err := w.getSealingBlock(args.Parent, args.Timestamp, args.FeeRecipient, args.Random, args.Withdrawals, false) if err == nil {

diff --git ethereum/go-ethereum/miner/taiko_payload_building.go taikoxyz/taiko-geth/miner/taiko_payload_building.go new file mode 100644 index 0000000000000000000000000000000000000000..7458ee1ae2cba0b306fd5b570ed6706ffd9bd6bb --- /dev/null +++ taikoxyz/taiko-geth/miner/taiko_payload_building.go @@ -0,0 +1,44 @@ +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 payload.stop <- struct{}{}: + default: + } +}

diff --git ethereum/go-ethereum/miner/worker.go taikoxyz/taiko-geth/miner/worker.go index 97967ea2f18bd787961c9d6cb9add18b77c7af06..34a53dcb68cbb4814a6e54024c6d7a649e4089d9 100644 --- ethereum/go-ethereum/miner/worker.go +++ taikoxyz/taiko-geth/miner/worker.go @@ -837,13 +837,14 @@ }   // generateParams wraps various of settings for generating sealing task. type generateParams struct { - timestamp uint64 // The timstamp for sealing task - forceTime bool // Flag whether the given timestamp is immutable or not - parentHash common.Hash // Parent block hash, empty means the latest chain head - coinbase common.Address // The fee recipient address for including transaction - random common.Hash // The randomness generated by beacon chain, empty before the merge - withdrawals types.Withdrawals // List of withdrawals to include in block. - noTxs bool // Flag whether an empty block without any transaction is expected + timestamp uint64 // The timstamp for sealing task + forceTime bool // Flag whether the given timestamp is immutable or not + parentHash common.Hash // Parent block hash, empty means the latest chain head + coinbase common.Address // The fee recipient address for including transaction + random common.Hash // The randomness generated by beacon chain, empty before the merge + withdrawals types.Withdrawals // List of withdrawals to include in block. + noTxs bool // Flag whether an empty block without any transaction is expected + baseFeePerGas *big.Int // CHANGE(taiko): The base fee per gas for the next block }   // prepareWork constructs the sealing task according to the given parameters, @@ -866,10 +867,17 @@ // Sanity check the timestamp correctness, recap the timestamp // to parent+1 if the mutation is allowed. timestamp := genParams.timestamp if parent.Time >= timestamp { - if genParams.forceTime { - return nil, fmt.Errorf("invalid timestamp, parent %d given %d", parent.Time, timestamp) + // CHANGE(taiko): block.timestamp == parent.timestamp is allowed in Taiko protocol. + if !w.chainConfig.Taiko { + if genParams.forceTime { + return nil, fmt.Errorf("invalid timestamp, parent %d given %d", parent.Time, timestamp) + } + timestamp = parent.Time + 1 + } else { + if parent.Time > timestamp { + return nil, fmt.Errorf("invalid timestamp, parent %d given %d", parent.Time, timestamp) + } } - timestamp = parent.Time + 1 } // Construct the sealing block header. header := &types.Header{ @@ -889,10 +897,14 @@ header.MixDigest = genParams.random } // Set baseFee and GasLimit if we are on an EIP-1559 chain if w.chainConfig.IsLondon(header.Number) { - header.BaseFee = eip1559.CalcBaseFee(w.chainConfig, parent) - if !w.chainConfig.IsLondon(parent.Number) { - parentGasLimit := parent.GasLimit * w.chainConfig.ElasticityMultiplier() - header.GasLimit = core.CalcGasLimit(parentGasLimit, w.config.GasCeil) + if w.chainConfig.Taiko && genParams.baseFeePerGas != nil { + header.BaseFee = genParams.baseFeePerGas + } else { + header.BaseFee = eip1559.CalcBaseFee(w.chainConfig, parent) + if !w.chainConfig.IsLondon(parent.Number) { + parentGasLimit := parent.GasLimit * w.chainConfig.ElasticityMultiplier() + header.GasLimit = core.CalcGasLimit(parentGasLimit, w.config.GasCeil) + } } } // Run the consensus preparation with the default or customized consensus engine.

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

diff --git ethereum/go-ethereum/params/config.go taikoxyz/taiko-geth/params/config.go index 75c8fd89d09fa946dca42be0ca940233aea6d7b6..2d70ee4f295a9c6147e076d6c247650035c3162a 100644 --- ethereum/go-ethereum/params/config.go +++ taikoxyz/taiko-geth/params/config.go @@ -253,6 +253,13 @@ var NetworkNames = map[string]string{ MainnetChainConfig.ChainID.String(): "mainnet", GoerliChainConfig.ChainID.String(): "goerli", SepoliaChainConfig.ChainID.String(): "sepolia", + // CHANGE(taiko): add Taiko network name. + TaikoInternalNetworkID.String(): "Taiko Internal 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 L3 (Jolnir)", }   // ChainConfig is the core config which determines the blockchain settings. @@ -304,6 +311,9 @@ // Various consensus engines Ethash *EthashConfig `json:"ethash,omitempty"` Clique *CliqueConfig `json:"clique,omitempty"` IsDevMode bool `json:"isDev,omitempty"` + + // CHANGE(taiko): Taiko network flag. + Taiko bool `json:"taiko"` }   // EthashConfig is the consensus engine configs for proof-of-work based sealing. @@ -336,6 +346,9 @@ network = "unknown" } banner += fmt.Sprintf("Chain ID: %v (%s)\n", c.ChainID, network) switch { + // CHANGE(taiko): print Taiko consensus engine in banner. + case c.Taiko: + banner += "Consensus: Taiko\n" case c.Ethash != nil: if c.TerminalTotalDifficulty == nil { banner += "Consensus: Ethash (proof-of-work)\n"

diff --git ethereum/go-ethereum/params/taiko_config.go taikoxyz/taiko-geth/params/taiko_config.go new file mode 100644 index 0000000000000000000000000000000000000000..351a161e76e4a3f091e0763d72ce61b00f4d5ac9 --- /dev/null +++ taikoxyz/taiko-geth/params/taiko_config.go @@ -0,0 +1,39 @@ +package params + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" +) + +func u64(val uint64) *uint64 { return &val } + +// Network IDs +var ( + TaikoInternalNetworkID = big.NewInt(167001) + TaikoInternalL3NetworkID = big.NewInt(167002) + SnaefellsjokullNetworkID = big.NewInt(167003) + AskjaNetworkID = big.NewInt(167004) + GrimsvotnNetworkID = big.NewInt(167005) + EldfellNetworkID = big.NewInt(167006) + JolnirNetworkID = big.NewInt(167007) +) + +var TaikoChainConfig = &ChainConfig{ + ChainID: TaikoInternalNetworkID, // Use Internal Devnet network ID by default. + HomesteadBlock: common.Big0, + EIP150Block: common.Big0, + EIP155Block: common.Big0, + EIP158Block: common.Big0, + ByzantiumBlock: common.Big0, + ConstantinopleBlock: common.Big0, + PetersburgBlock: common.Big0, + IstanbulBlock: common.Big0, + BerlinBlock: common.Big0, + LondonBlock: common.Big0, + ShanghaiTime: u64(0), + MergeNetsplitBlock: nil, + TerminalTotalDifficulty: common.Big0, + TerminalTotalDifficultyPassed: true, + Taiko: true, +}