Merge branch 'master' into debug-block

Author: eljobe

arbitrum/multigas/resources.go

@@ -2,6 +2,7 @@ package multigas
 
 import (
 	"encoding/json"
+	"fmt"
 	"io"
 	"math/bits"
 
@@ -25,6 +26,14 @@ const (
 	NumResourceKind
 )
 
+// CheckResourceKind checks whether the given id is a valid resource.
+func CheckResourceKind(id uint8) (ResourceKind, error) {
+	if id <= uint8(ResourceKindUnknown) || id >= uint8(NumResourceKind) {
+		return ResourceKindUnknown, fmt.Errorf("invalid resource id: %v", id)
+	}
+	return ResourceKind(id), nil
+}
+
 // MultiGas tracks gas usage across multiple resource kinds, while also
 // maintaining a single-dimensional total gas sum and refund amount.
 type MultiGas struct {
@@ -68,11 +77,6 @@ func MultiGasFromPairs(pairs ...Pair) MultiGas {
 	return mg
 }
 
-// UnknownGas returns a MultiGas initialized with unknown gas.
-func UnknownGas(amount uint64) MultiGas {
-	return NewMultiGas(ResourceKindUnknown, amount)
-}
-
 // ComputationGas returns a MultiGas initialized with computation gas.
 func ComputationGas(amount uint64) MultiGas {
 	return NewMultiGas(ResourceKindComputation, amount)

arbitrum/multigas/resources_test.go

@@ -10,6 +10,24 @@ import (
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
+func TestCheckResourceKind(t *testing.T) {
+	_, err := CheckResourceKind(0)
+	if err == nil {
+		t.Errorf("expected error, got nil")
+	}
+	_, err = CheckResourceKind(uint8(NumResourceKind))
+	if err == nil {
+		t.Errorf("expected error, got nil")
+	}
+	resource, err := CheckResourceKind(uint8(ResourceKindComputation))
+	if err != nil {
+		t.Errorf("unexpected error, got %v", err)
+	}
+	if resource != ResourceKindComputation {
+		t.Errorf("expected computation resource, got %v", resource)
+	}
+}
+
 func TestZeroGas(t *testing.T) {
 	zero := ZeroGas()
 	if zero.SingleGas() != 0 {

arbitrum/recordingdb.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
@@ -334,7 +335,7 @@ func (r *RecordingDatabase) GetOrRecreateState(ctx context.Context, header *type
 	returnedBlockNumber := header.Number.Uint64()
 	for ctx.Err() == nil {
 		var block *types.Block
-		state, block, err = AdvanceStateByBlock(ctx, r.bc, state, blockToRecreate, prevHash, logFunc)
+		state, block, _, err = AdvanceStateByBlock(ctx, r.bc, state, blockToRecreate, prevHash, logFunc, vm.Config{})
 		if err != nil {
 			return nil, err
 		}

arbitrum/recreatestate.go

@@ -69,20 +69,20 @@ func FindLastAvailableState(ctx context.Context, bc *core.BlockChain, stateFor S
 	return state, currentHeader, release, ctx.Err()
 }
 
-func AdvanceStateByBlock(ctx context.Context, bc *core.BlockChain, state *state.StateDB, blockToRecreate uint64, prevBlockHash common.Hash, logFunc StateBuildingLogFunction) (*state.StateDB, *types.Block, error) {
+func AdvanceStateByBlock(ctx context.Context, bc *core.BlockChain, state *state.StateDB, blockToRecreate uint64, prevBlockHash common.Hash, logFunc StateBuildingLogFunction, vmConfig vm.Config) (*state.StateDB, *types.Block, types.Receipts, error) {
 	block := bc.GetBlockByNumber(blockToRecreate)
 	if block == nil {
-		return nil, nil, fmt.Errorf("block not found while recreating: %d", blockToRecreate)
+		return nil, nil, nil, fmt.Errorf("block not found while recreating: %d", blockToRecreate)
 	}
 	if block.ParentHash() != prevBlockHash {
-		return nil, nil, fmt.Errorf("reorg detected: number %d expectedPrev: %v foundPrev: %v", blockToRecreate, prevBlockHash, block.ParentHash())
+		return nil, nil, nil, fmt.Errorf("reorg detected: number %d expectedPrev: %v foundPrev: %v", blockToRecreate, prevBlockHash, block.ParentHash())
 	}
 	if logFunc != nil {
 		logFunc(block.Header(), true)
 	}
-	_, err := bc.Processor().Process(block, state, vm.Config{})
+	result, err := bc.Processor().Process(block, state, vmConfig)
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed recreating state for block %d : %w", blockToRecreate, err)
+		return nil, nil, nil, fmt.Errorf("failed recreating state for block %d : %w", blockToRecreate, err)
 	}
-	return state, block, nil
+	return state, block, result.Receipts, nil
 }

core/reverted_tx_gas.go

@@ -0,0 +1,28 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// RevertedTxGasUsed maps specific transaction hashes that have been previously reverted to the amount
+// of GAS used by that specific transaction alone.
+var RevertedTxGasUsed = map[common.Hash]uint64{
+	// Arbitrum Sepolia (chain_id=421614). Tx timestamp: Oct-13-2025 03:30:36 AM +UTC
+	common.HexToHash("0x58df300a7f04fe31d41d24672786cbe1c58b4f3d8329d0d74392d814dd9f7e40"): 45174,
+}

core/state_transition.go

@@ -681,34 +681,43 @@ func (st *stateTransition) execute() (*ExecutionResult, error) {
 		ret   []byte
 		vmerr error // vm errors do not effect consensus and are therefore not assigned to err
 	)
-	if contractCreation {
-		deployedContract = &common.Address{}
-		ret, *deployedContract, st.gasRemaining, multiGas, vmerr = st.evm.Create(msg.From, msg.Data, st.gasRemaining, value)
-		usedMultiGas = usedMultiGas.SaturatingAdd(multiGas)
-	} else {
-		// Increment the nonce for the next transaction.
-		st.state.SetNonce(msg.From, st.state.GetNonce(msg.From)+1, tracing.NonceChangeEoACall)
 
-		// Apply EIP-7702 authorizations.
-		if msg.SetCodeAuthorizations != nil {
-			for _, auth := range msg.SetCodeAuthorizations {
-				// Note errors are ignored, we simply skip invalid authorizations here.
-				st.applyAuthorization(&auth)
+	// Check against hardcoded transaction hashes that have previously reverted, so instead
+	// of executing the transaction we just update state nonce and remaining gas to avoid
+	// state divergence.
+	usedMultiGas, vmerr = st.handleRevertedTx(msg, usedMultiGas)
+
+	// vmerr is only not nil when we find a previous reverted transaction
+	if vmerr == nil {
+		if contractCreation {
+			deployedContract = &common.Address{}
+			ret, *deployedContract, st.gasRemaining, multiGas, vmerr = st.evm.Create(msg.From, msg.Data, st.gasRemaining, value)
+			usedMultiGas = usedMultiGas.SaturatingAdd(multiGas)
+		} else {
+			// Increment the nonce for the next transaction.
+			st.state.SetNonce(msg.From, st.state.GetNonce(msg.From)+1, tracing.NonceChangeEoACall)
+
+			// Apply EIP-7702 authorizations.
+			if msg.SetCodeAuthorizations != nil {
+				for _, auth := range msg.SetCodeAuthorizations {
+					// Note errors are ignored, we simply skip invalid authorizations here.
+					st.applyAuthorization(&auth)
+				}
 			}
-		}
 
-		// Perform convenience warming of sender's delegation target. Although the
-		// sender is already warmed in Prepare(..), it's possible a delegation to
-		// the account was deployed during this transaction. To handle correctly,
-		// simply wait until the final state of delegations is determined before
-		// performing the resolution and warming.
-		if addr, ok := types.ParseDelegation(st.state.GetCode(*msg.To)); ok {
-			st.state.AddAddressToAccessList(addr)
-		}
+			// Perform convenience warming of sender's delegation target. Although the
+			// sender is already warmed in Prepare(..), it's possible a delegation to
+			// the account was deployed during this transaction. To handle correctly,
+			// simply wait until the final state of delegations is determined before
+			// performing the resolution and warming.
+			if addr, ok := types.ParseDelegation(st.state.GetCode(*msg.To)); ok {
+				st.state.AddAddressToAccessList(addr)
+			}
 
-		// Execute the transaction's call.
-		ret, st.gasRemaining, multiGas, vmerr = st.evm.Call(msg.From, st.to(), msg.Data, st.gasRemaining, value)
-		usedMultiGas = usedMultiGas.SaturatingAdd(multiGas)
+			// Execute the transaction's call.
+			ret, st.gasRemaining, multiGas, vmerr = st.evm.Call(msg.From, st.to(), msg.Data, st.gasRemaining, value)
+			usedMultiGas = usedMultiGas.SaturatingAdd(multiGas)
+		}
 	}
 
 	// Refund the gas that was held to limit the amount of computation done.
@@ -787,6 +796,30 @@ func (st *stateTransition) execute() (*ExecutionResult, error) {
 	}, nil
 }
 
+// handleRevertedTx attempts to process a reverted transaction. It returns
+// ErrExecutionReverted with the updated multiGas if a matching reverted
+// tx is found; otherwise, it returns nil error with unchangedmultiGas
+func (st *stateTransition) handleRevertedTx(msg *Message, usedMultiGas multigas.MultiGas) (multigas.MultiGas, error) {
+	if msg.Tx == nil {
+		return usedMultiGas, nil
+	}
+
+	txHash := msg.Tx.Hash()
+	if l2GasUsed, ok := RevertedTxGasUsed[txHash]; ok {
+		st.state.SetNonce(msg.From, st.state.GetNonce(msg.From)+1, tracing.NonceChangeEoACall)
+
+		// Calculate adjusted gas since l2GasUsed contains params.TxGas
+		adjustedGas := l2GasUsed - params.TxGas
+		st.gasRemaining -= adjustedGas
+
+		// Update multigas and return ErrExecutionReverted error
+		usedMultiGas = usedMultiGas.SaturatingAdd(multigas.ComputationGas(adjustedGas))
+		return usedMultiGas, vm.ErrExecutionReverted
+	}
+
+	return usedMultiGas, nil
+}
+
 // validateAuthorization validates an EIP-7702 authorization against the state.
 func (st *stateTransition) validateAuthorization(auth *types.SetCodeAuthorization) (authority common.Address, err error) {
 	// Verify chain ID is null or equal to current chain ID.

core/vm/gas_table.go

@@ -304,8 +304,7 @@ func gasKeccak256(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memor
 	if wordGas, overflow = math.SafeMul(toWordSize(wordGas), params.Keccak256WordGas); overflow {
 		return multigas.ZeroGas(), ErrGasUintOverflow
 	}
-	// TODO(NIT-3484): Update multi dimensional gas here
-	if multiGas, overflow = multiGas.SafeIncrement(multigas.ResourceKindUnknown, wordGas); overflow {
+	if multiGas, overflow = multiGas.SafeIncrement(multigas.ResourceKindComputation, wordGas); overflow {
 		return multigas.ZeroGas(), ErrGasUintOverflow
 	}
 	return multiGas, nil
@@ -402,8 +401,7 @@ func gasExpFrontier(evm *EVM, contract *Contract, stack *Stack, mem *Memory, mem
 	if gas, overflow = math.SafeAdd(gas, params.ExpGas); overflow {
 		return multigas.ZeroGas(), ErrGasUintOverflow
 	}
-	// TODO(NIT-3484): Update multi dimensional gas here
-	return multigas.UnknownGas(gas), nil
+	return multigas.ComputationGas(gas), nil
 }
 
 func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (multigas.MultiGas, error) {
@@ -416,8 +414,7 @@ func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memor
 	if gas, overflow = math.SafeAdd(gas, params.ExpGas); overflow {
 		return multigas.ZeroGas(), ErrGasUintOverflow
 	}
-	// TODO(NIT-3484): Update multi dimensional gas here
-	return multigas.UnknownGas(gas), nil
+	return multigas.ComputationGas(gas), nil
 }
 
 func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (multigas.MultiGas, error) {

node/database.go

@@ -41,6 +41,7 @@ type DatabaseOptions struct {
 	ReadOnly         bool   // if true, no writes can be performed
 
 	PebbleExtraOptions *pebble.ExtraOptions
+	NoFreezer          bool
 }
 
 type InternalOpenOptions struct {
@@ -59,6 +60,9 @@ func OpenDatabase(o InternalOpenOptions) (ethdb.Database, error) {
 	if err != nil {
 		return nil, err
 	}
+	if o.DatabaseOptions.NoFreezer {
+		return rawdb.NewDatabase(kvdb), nil
+	}
 	opts := rawdb.OpenOptions{
 		Ancient:          o.AncientsDirectory,
 		Era:              o.EraDirectory,

signer/core/apitypes/types.go

@@ -108,6 +108,7 @@ type SendTxArgs struct {
 	BlobHashes []common.Hash `json:"blobVersionedHashes,omitempty"`
 
 	// For BlobTxType transactions with blob sidecar
+	BlobVersion byte                 `json:"blobVersion,omitempty"`
 	Blobs       []kzg4844.Blob       `json:"blobs,omitempty"`
 	Commitments []kzg4844.Commitment `json:"commitments,omitempty"`
 	Proofs      []kzg4844.Proof      `json:"proofs,omitempty"`
@@ -235,37 +236,56 @@ func (args *SendTxArgs) validateTxSidecar() error {
 	if args.Commitments != nil && len(args.Commitments) != n {
 		return fmt.Errorf("number of blobs and commitments mismatch (have=%d, want=%d)", len(args.Commitments), n)
 	}
-	if args.Proofs != nil && len(args.Proofs) != n {
-		return fmt.Errorf("number of blobs and proofs mismatch (have=%d, want=%d)", len(args.Proofs), n)
-	}
 	if args.BlobHashes != nil && len(args.BlobHashes) != n {
 		return fmt.Errorf("number of blobs and hashes mismatch (have=%d, want=%d)", len(args.BlobHashes), n)
 	}
-
+	if args.Proofs != nil {
+		if len(args.Proofs) == n {
+			// v1 transaction
+			for i, b := range args.Blobs {
+				if err := kzg4844.VerifyBlobProof(&b, args.Commitments[i], args.Proofs[i]); err != nil {
+					return fmt.Errorf("failed to verify blob proof: %v", err)
+				}
+			}
+		} else if len(args.Proofs) == n*kzg4844.CellProofsPerBlob {
+			// v2 transaction
+			if err := kzg4844.VerifyCellProofs(args.Blobs, args.Commitments, args.Proofs); err != nil {
+				return fmt.Errorf("failed to verify blob proof: %v", err)
+			}
+		} else {
+			return fmt.Errorf("number of proofs and blobs mismatch (have=%d, want=%d or %d)", len(args.Proofs), n, n*kzg4844.CellProofsPerBlob)
+		}
+	}
 	if args.Commitments == nil {
 		// Generate commitment and proof.
 		commitments := make([]kzg4844.Commitment, n)
-		proofs := make([]kzg4844.Proof, n)
+		proofs := make([]kzg4844.Proof, 0, n)
 		for i, b := range args.Blobs {
 			c, err := kzg4844.BlobToCommitment(&b)
 			if err != nil {
 				return fmt.Errorf("blobs[%d]: error computing commitment: %v", i, err)
 			}
 			commitments[i] = c
-			p, err := kzg4844.ComputeBlobProof(&b, c)
-			if err != nil {
-				return fmt.Errorf("blobs[%d]: error computing proof: %v", i, err)
+		}
+		if args.BlobVersion == 1 {
+			for i, b := range args.Blobs {
+				p, err := kzg4844.ComputeCellProofs(&b)
+				if err != nil {
+					return fmt.Errorf("blobs[%d]: error computing cell proof: %v", i, err)
+				}
+				proofs = append(proofs, p...)
+			}
+		} else {
+			for i, b := range args.Blobs {
+				p, err := kzg4844.ComputeBlobProof(&b, commitments[i])
+				if err != nil {
+					return fmt.Errorf("blobs[%d]: error computing proof: %v", i, err)
+				}
+				proofs = append(proofs, p)
 			}
-			proofs[i] = p
 		}
 		args.Commitments = commitments
 		args.Proofs = proofs
-	} else {
-		for i, b := range args.Blobs {
-			if err := kzg4844.VerifyBlobProof(&b, args.Commitments[i], args.Proofs[i]); err != nil {
-				return fmt.Errorf("failed to verify blob proof: %v", err)
-			}
-		}
 	}
 
 	hashes := make([]common.Hash, n)