feat(all): preconfs

.github/workflows/docker.yml

@@ -5,6 +5,8 @@ on:
     branches: [ taiko ]
     tags:
       - "v*"
+  pull_request:
+    branches: [ taiko ]
 
 jobs:
   push-docker-image:

accounts/abi/bind/base.go

@@ -425,6 +425,7 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 	if opts.NoSend {
 		return signedTx, nil
 	}
+	// change(taiko): slot and sig
 	if err := c.transactor.SendTransaction(ensureContext(opts.Context), signedTx); err != nil {
 		return nil, err
 	}

cmd/geth/config.go

@@ -191,6 +191,10 @@ func makeFullNode(ctx *cli.Context) *node.Node {
 		v := ctx.Uint64(utils.OverrideVerkle.Name)
 		cfg.Eth.OverrideVerkle = &v
 	}
+	// change(taiko):
+	if ctx.IsSet(utils.PreconfirmationForwardingURLFlag.Name) {
+		cfg.Eth.PreconfirmationForwardingURL = ctx.String(utils.PreconfirmationForwardingURLFlag.Name)
+	}
 
 	backend, eth := utils.RegisterEthService(stack, &cfg.Eth)
 

cmd/geth/main.go

@@ -190,6 +190,7 @@ var (
 		utils.AllowUnprotectedTxs,
 		utils.BatchRequestLimit,
 		utils.BatchResponseMaxSize,
+		utils.PreconfirmationForwardingURLFlag,
 	}
 
 	metricsFlags = []cli.Flag{

cmd/utils/flags.go

@@ -837,6 +837,14 @@ var (
 		Category: flags.APICategory,
 	}
 
+	// CHANGE(taiko): preconf url
+	PreconfirmationForwardingURLFlag = &cli.StringFlag{
+		Name:     "preconfirmationforwardingurl",
+		Usage:    "URL to forward eth_sendTransaction requests before confirmation",
+		Category: flags.APICategory,
+		Value:    "",
+	}
+
 	// Gas price oracle settings
 	GpoBlocksFlag = &cli.IntFlag{
 		Name:     "gpo.blocks",

consensus/taiko/consensus.go

@@ -303,6 +303,7 @@ func (t *Taiko) ValidateAnchorTx(tx *types.Transaction, header *types.Header) (b
 	}
 
 	if tx.GasFeeCap().Cmp(header.BaseFee) != 0 {
+		log.Info("anchor tx fails validation", "gasFeeCap", tx.GasFeeCap(), "header baseFee", header.BaseFee)
 		return false, nil
 	}
 

core/state_transition.go

@@ -28,6 +28,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto/kzg4844"
+	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/holiman/uint256"
 )
@@ -277,6 +278,8 @@ func (st *StateTransition) buyGas() error {
 		mgval = common.Big0
 	}
 	if have, want := st.state.GetBalance(st.msg.From), balanceCheckU256; have.Cmp(want) < 0 {
+		log.Info("failed to get balance", "have", have, "want", want, "isAnchor", st.msg.IsAnchor)
+
 		return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From.Hex(), have, want)
 	}
 	if err := st.gp.SubGas(st.msg.GasLimit); err != nil {
@@ -479,6 +482,8 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	}
 	effectiveTipU256, _ := uint256.FromBig(effectiveTip)
 
+	log.Info("executed transaction", "from", msg.From, "to", msg.To, "gas", st.gasUsed(), "gasPrice", msg.GasPrice, "effectiveTip", effectiveTip, "value", msg.Value, "isAnchor", msg.IsAnchor)
+
 	if st.evm.Config.NoBaseFee && msg.GasFeeCap.Sign() == 0 && msg.GasTipCap.Sign() == 0 {
 		// Skip fee payment when NoBaseFee is set and the fee fields
 		// are 0. This avoids a negative effectiveTip being applied to

core/taiko_genesis.go

@@ -55,6 +55,10 @@ func TaikoGenesisBlock(networkID uint64) *Genesis {
 		chainConfig.ChainID = params.HeklaNetworkID
 		chainConfig.OntakeBlock = HeklaOntakeBlock
 		allocJSON = taikoGenesis.HeklaGenesisAllocJSON
+	case params.PreconfsNetworkID.Uint64():
+		chainConfig.OntakeBlock = new(big.Int).SetUint64(0)
+		chainConfig.ChainID = params.PreconfsNetworkID
+		allocJSON = taikoGenesis.PreconfsGenesisAllocJSON
 	default:
 		chainConfig.ChainID = params.TaikoInternalL2ANetworkID
 		chainConfig.OntakeBlock = InternalDevnetOntakeBlock

core/taiko_genesis/genesis_alloc.go

@@ -33,3 +33,6 @@ var HeklaGenesisAllocJSON []byte
 
 //go:embed mainnet.json
 var MainnetGenesisAllocJSON []byte
+
+//go:embed preconfs.json
+var PreconfsGenesisAllocJSON []byte

eth/api_backend.go

@@ -48,6 +48,12 @@ type EthAPIBackend struct {
 	allowUnprotectedTxs bool
 	eth                 *Ethereum
 	gpo                 *gasprice.Oracle
+	preconfirmationURL  string // change(taiko)
+}
+
+// GetPreconfirmationForwardingURL
+func (b *EthAPIBackend) GetPreconfirmationForwardingURL() string {
+	return b.preconfirmationURL
 }
 
 // ChainConfig returns the active chain configuration.

eth/backend.go

@@ -96,6 +96,9 @@ type Ethereum struct {
 	lock sync.RWMutex // Protects the variadic fields (e.g. gas price and etherbase)
 
 	shutdownTracker *shutdowncheck.ShutdownTracker // Tracks if and when the node has shutdown ungracefully
+
+	// change(taiko)
+	PreconfirmationForwardingURL string
 }
 
 // New creates a new Ethereum object (including the initialisation of the common Ethereum object),
@@ -254,7 +257,8 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 	eth.miner = miner.New(eth, config.Miner, eth.engine)
 	eth.miner.SetExtra(makeExtraData(config.Miner.ExtraData))
 
-	eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, eth, nil}
+	// change(TAIKO): preconfirmation URL
+	eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, eth, nil, config.PreconfirmationForwardingURL}
 	if eth.APIBackend.allowUnprotectedTxs {
 		log.Info("Unprotected transactions allowed")
 	}

eth/ethconfig/config.go

@@ -157,6 +157,9 @@ type Config struct {
 
 	// OverrideVerkle (TODO: remove after the fork)
 	OverrideVerkle *uint64 `toml:",omitempty"`
+
+	// change(taiko): preconf url
+	PreconfirmationForwardingURL string
 }
 
 // CreateConsensusEngine creates a consensus engine for the given chain config.

ethclient/ethclient.go

@@ -619,6 +619,7 @@ func (ec *Client) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64
 	return uint64(hex), nil
 }
 
+// change(taiko): slot / signature for preconfs
 // SendTransaction injects a signed transaction into the pending pool for execution.
 //
 // If the transaction was a contract creation use the TransactionReceipt method to get the
@@ -628,6 +629,7 @@ func (ec *Client) SendTransaction(ctx context.Context, tx *types.Transaction) er
 	if err != nil {
 		return err
 	}
+
 	return ec.c.CallContext(ctx, nil, "eth_sendRawTransaction", hexutil.Encode(data))
 }
 

internal/ethapi/api.go

@@ -23,6 +23,7 @@ import (
 	"fmt"
 	"maps"
 	"math/big"
+	"strconv"
 	"strings"
 	"time"
 
@@ -657,6 +658,21 @@ func (api *BlockChainAPI) ChainId() *hexutil.Big {
 
 // BlockNumber returns the block number of the chain head.
 func (api *BlockChainAPI) BlockNumber() hexutil.Uint64 {
+	if forwardURL := api.b.GetPreconfirmationForwardingURL(); forwardURL != "" {
+		log.Info("forwarding blockNumber request")
+
+		// Forward the raw transaction to the specified URL
+		res, err := forward[string](forwardURL, "eth_blockNumber", nil)
+
+		if err == nil && res != nil {
+			log.Info("forwarded block number request", "res", res)
+			i, _ := strconv.ParseUint(*res, 0, 64)
+
+			log.Info("parsed block number", "bn", hexutil.Uint64(i))
+			return hexutil.Uint64(i)
+		}
+	}
+
 	header, _ := api.b.HeaderByNumber(context.Background(), rpc.LatestBlockNumber) // latest header should always be available
 	return hexutil.Uint64(header.Number.Uint64())
 }
@@ -665,6 +681,27 @@ func (api *BlockChainAPI) BlockNumber() hexutil.Uint64 {
 // given block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta
 // block numbers are also allowed.
 func (api *BlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
+	// change(taiko): check to see if it exists from the preconfer.
+	// Check if PreconfirmationForwardingURL is set
+	if forwardURL := api.b.GetPreconfirmationForwardingURL(); forwardURL != "" {
+		log.Info("forwarding balance request", "addr", address.Hex())
+		if blockNr, ok := blockNrOrHash.Number(); ok {
+			log.Info("forwarding balance request", "blockNr", blockNr.String())
+			bal, err := forward[string](forwardURL, "eth_getBalance", []interface{}{address.Hex(), blockNr.String()})
+			if err == nil && bal != nil {
+				return (*hexutil.Big)(hexutil.MustDecodeBig(*bal)), nil
+			}
+		}
+
+		if blockHash, ok := blockNrOrHash.Hash(); ok {
+			log.Info("forwarding balance request", "blockNr", blockHash.Hex())
+			bal, err := forward[string](forwardURL, "eth_getBalance", []interface{}{address.Hex(), blockHash.Hex()})
+			if err == nil && bal != nil {
+				return (*hexutil.Big)(hexutil.MustDecodeBig(*bal)), nil
+			}
+		}
+	}
+
 	state, _, err := api.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
 	if state == nil || err != nil {
 		return nil, err
@@ -845,7 +882,18 @@ func (api *BlockChainAPI) GetBlockByNumber(ctx context.Context, number rpc.Block
 				response[field] = nil
 			}
 		}
-		return response, nil
+		return response, err
+	} else {
+		// change(taiko): check to see if it exists from the preconfer.
+		// Check if PreconfirmationForwardingURL is set
+		if forwardURL := api.b.GetPreconfirmationForwardingURL(); forwardURL != "" {
+			log.Info("forwarding getBlockByNumber", "number", number.Int64(), "numberStr", number.String())
+			// Forward the raw transaction to the specified URL
+			b, err := forward[map[string]interface{}](forwardURL, "eth_getBlockByNumber", []interface{}{number.String(), fullTx})
+			if err == nil && b != nil {
+				return *b, nil
+			}
+		}
 	}
 	return nil, err
 }
@@ -856,6 +904,16 @@ func (api *BlockChainAPI) GetBlockByHash(ctx context.Context, hash common.Hash,
 	block, err := api.b.BlockByHash(ctx, hash)
 	if block != nil {
 		return RPCMarshalBlock(block, true, fullTx, api.b.ChainConfig()), nil
+	} else {
+		// change(taiko): check to see if it exists from the preconfer.
+		// Check if PreconfirmationForwardingURL is set
+		if forwardURL := api.b.GetPreconfirmationForwardingURL(); forwardURL != "" {
+			log.Info("forwarding getBlockByHash", "hash", hash.Hex())
+			m, err := forward[map[string]interface{}](forwardURL, "eth_getBlockByHash", []interface{}{hash.Hex(), fullTx})
+			if err == nil && m != nil {
+				return *m, nil
+			}
+		}
 	}
 	return nil, err
 }
@@ -1231,6 +1289,7 @@ func applyMessageWithEVM(ctx context.Context, evm *vm.EVM, msg *core.Message, st
 		return nil, fmt.Errorf("execution aborted (timeout = %v)", timeout)
 	}
 	if err != nil {
+		log.Info("error executing in doCall", "isAnchor", msg.IsAnchor, "err", err)
 		return result, fmt.Errorf("err: %w (supplied gas %d)", err, msg.GasLimit)
 	}
 	return result, nil
@@ -1750,6 +1809,26 @@ func (api *TransactionAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Cont
 
 // GetTransactionCount returns the number of transactions the given address has sent for the given block number
 func (api *TransactionAPI) GetTransactionCount(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Uint64, error) {
+	// change(taiko): check to see if it exists from the preconfer.
+	// Check if PreconfirmationForwardingURL is set
+	if forwardURL := api.b.GetPreconfirmationForwardingURL(); forwardURL != "" {
+		log.Info("forwarding getTransactionCount", "addr", address.Hex())
+
+		if blockNr, ok := blockNrOrHash.Number(); ok {
+			txCount, err := forward[hexutil.Uint64](forwardURL, "eth_getTransactionCount", []interface{}{address.Hex(), blockNr.String()})
+			if err == nil && txCount != nil {
+				return txCount, nil
+			}
+		}
+
+		if blockHash, ok := blockNrOrHash.Hash(); ok {
+			txCount, err := forward[hexutil.Uint64](forwardURL, "eth_getTransactionCount", []interface{}{address.Hex(), blockHash.Hex()})
+			if err == nil && txCount != nil {
+				return txCount, nil
+			}
+		}
+	}
+
 	// Ask transaction pool for the nonce which includes pending transactions
 	if blockNr, ok := blockNrOrHash.Number(); ok && blockNr == rpc.PendingBlockNumber {
 		nonce, err := api.b.GetPoolNonce(ctx, address)
@@ -1807,9 +1886,23 @@ func (api *TransactionAPI) GetRawTransactionByHash(ctx context.Context, hash com
 // GetTransactionReceipt returns the transaction receipt for the given transaction hash.
 func (api *TransactionAPI) GetTransactionReceipt(ctx context.Context, hash common.Hash) (map[string]interface{}, error) {
 	found, tx, blockHash, blockNumber, index, err := api.b.GetTransaction(ctx, hash)
-	if err != nil {
-		return nil, NewTxIndexingError() // transaction is not fully indexed
+	if err != nil || !found {
+		// change(taiko): check to see if it exists from the preconfer.
+		// Check if PreconfirmationForwardingURL is set
+		if forwardURL := api.b.GetPreconfirmationForwardingURL(); forwardURL != "" {
+			log.Info("forwarding get transaction receipt", "url", forwardURL)
+			// Forward the raw transaction to the specified URL
+			m, err := forward[map[string]interface{}](forwardURL, "eth_getTransactionReceipt", []interface{}{hash.Hex()})
+			if err == nil && m != nil {
+				return *m, err
+			}
+		}
+
+		if err != nil {
+			return nil, NewTxIndexingError() // transaction is not fully indexed
+		}
 	}
+
 	if !found {
 		return nil, nil // transaction is not existent or reachable
 	}
@@ -1971,9 +2064,22 @@ func (api *TransactionAPI) FillTransaction(ctx context.Context, args Transaction
 	return &SignTransactionResult{data, tx}, nil
 }
 
+// change(taiko): preconf logic
 // SendRawTransaction will add the signed transaction to the transaction pool.
 // The sender is responsible for signing the transaction and using the correct nonce.
 func (api *TransactionAPI) SendRawTransaction(ctx context.Context, input hexutil.Bytes) (common.Hash, error) {
+	// Check if PreconfirmationForwardingURL is set
+	if forwardURL := api.b.GetPreconfirmationForwardingURL(); forwardURL != "" {
+		log.Info("forwarding send raw tx", "url", forwardURL)
+		// Forward the raw transaction to the specified URL
+		h, err := forward[string](forwardURL, "eth_sendRawTransaction", []interface{}{input.String()})
+		if err == nil && h != nil {
+			return common.HexToHash(*h), nil
+		} else {
+			return common.Hash{}, err
+		}
+	}
+
 	tx := new(types.Transaction)
 	if err := tx.UnmarshalBinary(input); err != nil {
 		return common.Hash{}, err

internal/ethapi/api_test.go

@@ -470,6 +470,10 @@ func (b *testBackend) setPendingBlock(block *types.Block) {
 	b.pending = block
 }
 
+// change(taiko): get preconf url
+func (b testBackend) GetPreconfirmationForwardingURL() string {
+	return ""
+}
 func (b testBackend) SyncProgress() ethereum.SyncProgress { return ethereum.SyncProgress{} }
 func (b testBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
 	return big.NewInt(0), nil

internal/ethapi/backend.go

@@ -96,6 +96,9 @@ type Backend interface {
 	SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription
 	BloomStatus() (uint64, uint64)
 	ServiceFilter(ctx context.Context, session *bloombits.MatcherSession)
+
+	// change(taiko)
+	GetPreconfirmationForwardingURL() string
 }
 
 func GetAPIs(apiBackend Backend) []rpc.API {