Canyon Hard Fork

.github/workflows/ci.yml

@@ -6,12 +6,14 @@ on:
       - alpha
       - stable
       - op-erigon
+      - tip/canyon
   pull_request:
     branches:
       - devel
       - alpha
       - stable
       - op-erigon
+      - tip/canyon
     types:
       - opened
       - reopened

cmd/erigon-el/backend/backend.go

@@ -251,7 +251,7 @@ func NewBackend(stack *node.Node, config *ethconfig.Config, logger log.Logger) (
 			genesisSpec = nil
 		}
 		var genesisErr error
-		chainConfig, genesis, genesisErr = core.WriteGenesisBlock(tx, genesisSpec, config.OverrideShanghaiTime, tmpdir, logger)
+		chainConfig, genesis, genesisErr = core.WriteGenesisBlock(tx, genesisSpec, config.OverrideShanghaiTime, config.OverrideOptimismCanyonTime, tmpdir, logger)
 		if _, ok := genesisErr.(*chain.ConfigCompatError); genesisErr != nil && !ok {
 			return genesisErr
 		}

cmd/integration/commands/state_domains.go

@@ -532,6 +532,16 @@ func (b *blockProcessor) applyBlock(
 		}
 	}
 
+	// Optimism Canyon
+	ibs := state.New(b.reader)
+	misc.EnsureCreate2Deployer(b.chainConfig, header.Time, ibs)
+	if err := ibs.FinalizeTx(rules, b.writer); err != nil {
+		return nil, err
+	}
+	if err := b.writer.w.FinishTx(); err != nil {
+		return nil, fmt.Errorf("finish create2Deployer failed: %w", err)
+	}
+
 	b.txNum++ // Pre-block transaction
 	b.writer.w.SetTxNum(b.txNum)
 	if err := b.writer.w.FinishTx(); err != nil {

cmd/rpcdaemon/commands/erigon_block.go

@@ -190,8 +190,8 @@ func buildBlockResponse(br services.FullBlockReader, db kv.Tx, blockNum uint64,
 		additionalFields["totalDifficulty"] = (*hexutil.Big)(td)
 	}
 
-	depositNonces := rawdb.ReadDepositNonces(db, blockNum)
-	response, err := ethapi.RPCMarshalBlockEx(block, true, fullTx, nil, common.Hash{}, additionalFields, depositNonces)
+	receipts := rawdb.ReadRawReceipts(db, blockNum)
+	response, err := ethapi.RPCMarshalBlockEx(block, true, fullTx, nil, common.Hash{}, additionalFields, receipts)
 
 	if err == nil && rpc.BlockNumber(block.NumberU64()) == rpc.PendingBlockNumber {
 		// Pending blocks need to nil out a few fields

cmd/rpcdaemon/commands/eth_api.go

@@ -403,12 +403,14 @@ type RPCTransaction struct {
 	SourceHash *common.Hash `json:"sourceHash,omitempty"`
 	Mint       *hexutil.Big `json:"mint,omitempty"`
 	IsSystemTx *bool        `json:"isSystemTx,omitempty"`
+	// deposit-tx post-Canyon only
+	DepositReceiptVersion *hexutil.Uint64 `json:"depositReceiptVersion,omitempty"`
 }
 
 // newRPCTransaction returns a transaction that will serialize to the RPC
 // representation, with the given location metadata set (if available).
 func newRPCTransaction(tx types.Transaction, blockHash common.Hash, blockNumber uint64, index uint64, baseFee *big.Int,
-	depositNonce *uint64) *RPCTransaction {
+	receipt *types.Receipt) *RPCTransaction {
 	// Determine the signer. For replay-protected transactions, use the most permissive
 	// signer, because we assume that signers are backwards-compatible with old
 	// transactions. For non-protected transactions, the homestead signer signer is used
@@ -464,8 +466,12 @@ func newRPCTransaction(tx types.Transaction, blockHash common.Hash, blockNumber
 		if t.IsSystemTransaction {
 			result.IsSystemTx = &t.IsSystemTransaction
 		}
-		if depositNonce != nil {
-			result.Nonce = hexutil.Uint64(*depositNonce)
+		if receipt != nil && receipt.DepositNonce != nil {
+			result.Nonce = hexutil.Uint64(*receipt.DepositNonce)
+			if receipt.DepositReceiptVersion != nil {
+				result.DepositReceiptVersion = new(hexutil.Uint64)
+				*result.DepositReceiptVersion = hexutil.Uint64(*receipt.DepositReceiptVersion)
+			}
 		}
 		result.GasPrice = (*hexutil.Big)(common.Big0)
 		// must contain v, r, s values for backwards compatibility.
@@ -537,7 +543,7 @@ func newRPCBorTransaction(opaqueTx types.Transaction, txHash common.Hash, blockH
 func newRPCPendingTransaction(tx types.Transaction, current *types.Header, config *chain.Config) *RPCTransaction {
 	var baseFee *big.Int
 	if current != nil {
-		baseFee = misc.CalcBaseFee(config, current)
+		baseFee = misc.CalcBaseFee(config, current, current.Time+1)
 	}
 	return newRPCTransaction(tx, common.Hash{}, 0, 0, baseFee, nil)
 }

cmd/rpcdaemon/commands/eth_block.go

@@ -231,8 +231,8 @@ func (api *APIImpl) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber
 		}
 	}
 
-	depositNonces := rawdb.ReadDepositNonces(tx, b.NumberU64())
-	response, err := ethapi.RPCMarshalBlockEx(b, true, fullTx, borTx, borTxHash, additionalFields, depositNonces)
+	receipts := rawdb.ReadRawReceipts(tx, b.NumberU64())
+	response, err := ethapi.RPCMarshalBlockEx(b, true, fullTx, borTx, borTxHash, additionalFields, receipts)
 	if err == nil && number == rpc.PendingBlockNumber {
 		// Pending blocks need to nil out a few fields
 		for _, field := range []string{"hash", "nonce", "miner"} {
@@ -291,8 +291,8 @@ func (api *APIImpl) GetBlockByHash(ctx context.Context, numberOrHash rpc.BlockNu
 		}
 	}
 
-	depositNonces := rawdb.ReadDepositNonces(tx, number)
-	response, err := ethapi.RPCMarshalBlockEx(block, true, fullTx, borTx, borTxHash, additionalFields, depositNonces)
+	receipts := rawdb.ReadRawReceipts(tx, number)
+	response, err := ethapi.RPCMarshalBlockEx(block, true, fullTx, borTx, borTxHash, additionalFields, receipts)
 
 	if chainConfig.Bor != nil {
 		response["miner"], _ = ecrecover(block.Header(), chainConfig.Bor)

cmd/rpcdaemon/commands/eth_receipts.go

@@ -773,8 +773,13 @@ func marshalReceipt(receipt *types.Receipt, txn types.Transaction, chainConfig *
 			fields["l1GasUsed"] = hexutil.Big(*receipt.L1GasUsed)
 			fields["l1Fee"] = hexutil.Big(*receipt.L1Fee)
 			fields["l1FeeScalar"] = receipt.FeeScalar
-		} else if receipt.DepositNonce != nil {
-			fields["depositNonce"] = hexutil.Uint64(*receipt.DepositNonce)
+		} else {
+			if receipt.DepositNonce != nil {
+				fields["depositNonce"] = hexutil.Uint64(*receipt.DepositNonce)
+			}
+			if receipt.DepositReceiptVersion != nil {
+				fields["depositReceiptVersion"] = hexutil.Uint64(*receipt.DepositReceiptVersion)
+			}
 		}
 	}
 

cmd/rpcdaemon/commands/eth_txs.go

@@ -86,12 +86,11 @@ func (api *APIImpl) GetTransactionByHash(ctx context.Context, txnHash common.Has
 		}
 
 		if chainConfig.IsOptimism() {
-			depositNonces := rawdb.ReadDepositNonces(tx, block.NumberU64())
-			if txnIndex >= uint64(len(depositNonces)) {
-				return nil, fmt.Errorf("depositNonce for tx %x not found", txnHash)
-			} else {
-				return newRPCTransaction(txn, blockHash, blockNum, txnIndex, baseFee, depositNonces[txnIndex]), nil
+			receipts := rawdb.ReadRawReceipts(tx, block.NumberU64())
+			if len(receipts) <= int(txnIndex) {
+				return nil, fmt.Errorf("block has less receipts than expected: %d <= %d, block: %d", len(receipts), int(txnIndex), blockNum)
 			}
+			return newRPCTransaction(txn, blockHash, blockNum, txnIndex, baseFee, receipts[txnIndex]), nil
 		}
 		return newRPCTransaction(txn, blockHash, blockNum, txnIndex, baseFee, nil), nil
 	}
@@ -209,12 +208,11 @@ func (api *APIImpl) GetTransactionByBlockHashAndIndex(ctx context.Context, block
 	}
 
 	if chainConfig.IsOptimism() {
-		depositNonces := rawdb.ReadDepositNonces(tx, block.NumberU64())
-		if uint64(txIndex) >= uint64(len(depositNonces)) {
-			return nil, fmt.Errorf("depositNonce for tx %x not found", txs[txIndex].Hash())
-		} else {
-			return newRPCTransaction(txs[txIndex], block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee(), depositNonces[txIndex]), nil
+		receipts := rawdb.ReadRawReceipts(tx, block.NumberU64())
+		if len(receipts) <= int(txIndex) {
+			return nil, fmt.Errorf("block has less receipts than expected: %d <= %d, block: %d", len(receipts), int(txIndex), block.NumberU64())
 		}
+		return newRPCTransaction(txs[txIndex], block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee(), receipts[txIndex]), nil
 	}
 	return newRPCTransaction(txs[txIndex], block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee(), nil), nil
 }
@@ -280,12 +278,11 @@ func (api *APIImpl) GetTransactionByBlockNumberAndIndex(ctx context.Context, blo
 		return newRPCBorTransaction(borTx, derivedBorTxHash, block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee(), chainConfig.ChainID), nil
 	}
 	if chainConfig.IsOptimism() {
-		depositNonces := rawdb.ReadDepositNonces(tx, blockNum)
-		if uint64(txIndex) >= uint64(len(depositNonces)) {
-			return nil, fmt.Errorf("depositNonce for tx %x not found", txs[txIndex].Hash())
-		} else {
-			return newRPCTransaction(txs[txIndex], block.Hash(), blockNum, uint64(txIndex), block.BaseFee(), depositNonces[txIndex]), nil
+		receipts := rawdb.ReadRawReceipts(tx, block.NumberU64())
+		if len(receipts) <= int(txIndex) {
+			return nil, fmt.Errorf("block has less receipts than expected: %d <= %d, block: %d", len(receipts), int(txIndex), block.NumberU64())
 		}
+		return newRPCTransaction(txs[txIndex], block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee(), receipts[txIndex]), nil
 	}
 	return newRPCTransaction(txs[txIndex], block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee(), nil), nil
 }

cmd/rpcdaemon/commands/eth_uncles.go

@@ -46,8 +46,8 @@ func (api *APIImpl) GetUncleByBlockNumberAndIndex(ctx context.Context, number rp
 		return nil, nil
 	}
 	uncle := types.NewBlockWithHeader(uncles[index])
-	depositNonces := rawdb.ReadDepositNonces(tx, blockNum)
-	return ethapi.RPCMarshalBlock(uncle, false, false, additionalFields, depositNonces)
+	receipts := rawdb.ReadRawReceipts(tx, blockNum)
+	return ethapi.RPCMarshalBlock(uncle, false, false, additionalFields, receipts)
 }
 
 // GetUncleByBlockHashAndIndex implements eth_getUncleByBlockHashAndIndex. Returns information about an uncle given a block's hash and the index of the uncle.
@@ -79,8 +79,8 @@ func (api *APIImpl) GetUncleByBlockHashAndIndex(ctx context.Context, hash common
 		return nil, nil
 	}
 	uncle := types.NewBlockWithHeader(uncles[index])
-	depositNonces := rawdb.ReadDepositNonces(tx, number)
-	return ethapi.RPCMarshalBlock(uncle, false, false, additionalFields, depositNonces)
+	receipts := rawdb.ReadRawReceipts(tx, number)
+	return ethapi.RPCMarshalBlock(uncle, false, false, additionalFields, receipts)
 }
 
 // GetUncleCountByBlockNumber implements eth_getUncleCountByBlockNumber. Returns the number of uncles in the block, if any.

cmd/rpcdaemon/commands/graphql_api.go

@@ -116,8 +116,8 @@ func (api *GraphQLAPIImpl) delegateGetBlockByNumber(tx kv.Tx, b *types.Block, nu
 		return nil, err
 	}
 	additionalFields := make(map[string]interface{})
-	depositNonces := rawdb.ReadDepositNonces(tx, uint64(number.Int64()))
-	response, err := ethapi.RPCMarshalBlock(b, inclTx, inclTx, additionalFields, depositNonces)
+	receipts := rawdb.ReadRawReceipts(tx, uint64(number.Int64()))
+	response, err := ethapi.RPCMarshalBlock(b, inclTx, inclTx, additionalFields, receipts)
 	if !inclTx {
 		delete(response, "transactions") // workaround for https://github.com/ledgerwatch/erigon/issues/4989#issuecomment-1218415666
 	}

cmd/rpcdaemon/commands/otterscan_api.go

@@ -520,18 +520,17 @@ func (api *OtterscanAPIImpl) searchTransactionsBeforeV3(tx kv.TemporalTx, ctx co
 			return nil, err
 		}
 		var rpcTx *RPCTransaction
+		var receipt *types.Receipt
 		if chainConfig.IsOptimism() {
-			depositNonces := rawdb.ReadDepositNonces(tx, blockNum)
-			if txIndex >= len(depositNonces) {
-				return nil, fmt.Errorf("depositNonce for tx %x not found", txn.Hash())
-			} else {
-				rpcTx = newRPCTransaction(txn, blockHash, blockNum, uint64(txIndex), header.BaseFee, depositNonces[txIndex])
+			receipts := rawdb.ReadRawReceipts(tx, blockNum)
+			if len(receipts) <= txIndex {
+				return nil, fmt.Errorf("block has less receipts than expected: %d <= %d, block: %d", len(receipts), txIndex, blockNum)
 			}
-		} else {
-			rpcTx = newRPCTransaction(txn, blockHash, blockNum, uint64(txIndex), header.BaseFee, nil)
+			receipt = receipts[txIndex]
 		}
+		rpcTx = newRPCTransaction(txn, blockHash, blockNum, uint64(txIndex), header.BaseFee, receipt)
 		txs = append(txs, rpcTx)
-		receipt := &types.Receipt{
+		receipt = &types.Receipt{
 			Type: txn.Type(), CumulativeGasUsed: res.UsedGas,
 			TransactionIndex: uint(txIndex),
 			BlockNumber:      header.Number, BlockHash: blockHash, Logs: rawLogs,
@@ -677,8 +676,8 @@ func (api *OtterscanAPIImpl) delegateGetBlockByNumber(tx kv.Tx, b *types.Block,
 		return nil, err
 	}
 	additionalFields := make(map[string]interface{})
-	depositNonces := rawdb.ReadDepositNonces(tx, uint64(number.Int64()))
-	response, err := ethapi.RPCMarshalBlock(b, inclTx, inclTx, additionalFields, depositNonces)
+	receipts := rawdb.ReadRawReceipts(tx, uint64(number.Int64()))
+	response, err := ethapi.RPCMarshalBlock(b, inclTx, inclTx, additionalFields, receipts)
 	if !inclTx {
 		delete(response, "transactions") // workaround for https://github.com/ledgerwatch/erigon/issues/4989#issuecomment-1218415666
 	}

cmd/rpcdaemon/commands/otterscan_search_trace.go

@@ -94,11 +94,6 @@ func (api *OtterscanAPIImpl) traceBlock(dbtx kv.Tx, ctx context.Context, blockNu
 	header := block.Header()
 	rules := chainConfig.Rules(block.NumberU64(), header.Time)
 	found := false
-
-	var depositNonces []*uint64
-	if chainConfig.IsOptimism() {
-		depositNonces = rawdb.ReadDepositNonces(dbtx, blockNum)
-	}
 	for idx, tx := range block.Transactions() {
 		ibs.SetTxContext(tx.Hash(), block.Hash(), idx)
 
@@ -116,11 +111,11 @@ func (api *OtterscanAPIImpl) traceBlock(dbtx kv.Tx, ctx context.Context, blockNu
 		_ = ibs.FinalizeTx(rules, cachedWriter)
 
 		if tracer.Found {
-			var depositNonce *uint64
-			if chainConfig.IsOptimism() && idx < len(depositNonces) {
-				depositNonce = depositNonces[idx]
+			var receipt *types.Receipt
+			if chainConfig.IsOptimism() && idx < len(block.Transactions()) {
+				receipt = blockReceipts[idx]
 			}
-			rpcTx := newRPCTransaction(tx, block.Hash(), blockNum, uint64(idx), block.BaseFee(), depositNonce)
+			rpcTx := newRPCTransaction(tx, block.Hash(), blockNum, uint64(idx), block.BaseFee(), receipt)
 			mReceipt := marshalReceipt(blockReceipts[idx], tx, chainConfig, block.HeaderNoCopy(), tx.Hash(), true)
 			mReceipt["timestamp"] = block.Time()
 			rpcTxs = append(rpcTxs, rpcTx)

cmd/state/commands/erigon4.go

@@ -410,6 +410,16 @@ func processBlock23(startTxNum uint64, trace bool, txNumStart uint64, rw *StateR
 		}
 	}
 
+	// Optimism Canyon
+	ibs := state.New(rw)
+	misc.EnsureCreate2Deployer(chainConfig, header.Time, ibs)
+	if err := ibs.FinalizeTx(rules, ww); err != nil {
+		return 0, nil, err
+	}
+	if err := ww.w.FinishTx(); err != nil {
+		return 0, nil, fmt.Errorf("finish create2Deployer failed: %w", err)
+	}
+
 	txNum++ // Pre-block transaction
 	ww.w.SetTxNum(txNum)
 	if err := ww.w.FinishTx(); err != nil {

cmd/state/commands/opcode_tracer.go

@@ -717,6 +717,10 @@ func runBlock(engine consensus.Engine, ibs *state.IntraBlockState, txnWriter sta
 	if chainConfig.DAOForkBlock != nil && chainConfig.DAOForkBlock.Cmp(block.Number()) == 0 {
 		misc.ApplyDAOHardFork(ibs)
 	}
+
+	// Optimism Canyon
+	misc.EnsureCreate2Deployer(chainConfig, header.Time, ibs)
+
 	systemcontracts.UpgradeBuildInSystemContract(chainConfig, header.Number, ibs, logger)
 	rules := chainConfig.Rules(block.NumberU64(), block.Time())
 	for i, tx := range block.Transactions() {

cmd/state/exec3/state.go

@@ -134,13 +134,22 @@ func (rw *Worker) RunTxTaskNoLock(txTask *exec22.TxTask) {
 
 	rules := txTask.Rules
 	daoForkTx := rw.chainConfig.DAOForkBlock != nil && rw.chainConfig.DAOForkBlock.Uint64() == txTask.BlockNum && txTask.TxIndex == -1
+	// Optimism Canyon
+	create2DeployerTx := txTask.TxIndex == -1
+
 	var err error
 	header := txTask.Header
 
 	switch {
-	case daoForkTx:
-		//fmt.Printf("txNum=%d, blockNum=%d, DAO fork\n", txTask.TxNum, txTask.BlockNum)
-		misc.ApplyDAOHardFork(ibs)
+	case daoForkTx || create2DeployerTx:
+		if daoForkTx {
+			//fmt.Printf("txNum=%d, blockNum=%d, DAO fork\n", txTask.TxNum, txTask.BlockNum)
+			misc.ApplyDAOHardFork(ibs)
+		}
+		if create2DeployerTx && header != nil {
+			// Optimism Canyon
+			misc.EnsureCreate2Deployer(rw.chainConfig, header.Time, ibs)
+		}
 		ibs.SoftFinalise()
 	case txTask.TxIndex == -1:
 		if txTask.BlockNum == 0 {

cmd/state/exec3/state_recon.go

@@ -293,6 +293,9 @@ func (rw *ReconWorker) runTxTask(txTask *exec22.TxTask) error {
 	ibs := rw.ibs
 	rules := txTask.Rules
 	daoForkTx := rw.chainConfig.DAOForkBlock != nil && rw.chainConfig.DAOForkBlock.Uint64() == txTask.BlockNum && txTask.TxIndex == -1
+	// Optimism Canyon
+	create2DeployerTx := txTask.TxIndex == -1
+
 	var err error
 	if txTask.BlockNum == 0 && txTask.TxIndex == -1 {
 		//fmt.Printf("txNum=%d, blockNum=%d, Genesis\n", txTask.TxNum, txTask.BlockNum)
@@ -303,9 +306,15 @@ func (rw *ReconWorker) runTxTask(txTask *exec22.TxTask) error {
 		}
 		// For Genesis, rules should be empty, so that empty accounts can be included
 		rules = &chain.Rules{}
-	} else if daoForkTx {
-		//fmt.Printf("txNum=%d, blockNum=%d, DAO fork\n", txNum, blockNum)
-		misc.ApplyDAOHardFork(ibs)
+	} else if daoForkTx || create2DeployerTx {
+		if daoForkTx {
+			//fmt.Printf("txNum=%d, blockNum=%d, DAO fork\n", txNum, blockNum)
+			misc.ApplyDAOHardFork(ibs)
+		}
+		if create2DeployerTx && txTask.Header != nil {
+			// Optimism Canyon
+			misc.EnsureCreate2Deployer(rw.chainConfig, txTask.Header.Time, ibs)
+		}
 		ibs.SoftFinalise()
 	} else if txTask.Final {
 		if txTask.BlockNum > 0 {