Bring recent commits for EIP-7623 in geth

accounts/abi/bind/backends/blockchain.go

@@ -156,13 +156,13 @@ func (b *BlockchainContractBackend) callContract(call kaia.CallMsg, block *types
 	if call.AccessList != nil {
 		accessList = *call.AccessList
 	}
-	intrinsicGas, dataTokens, err := types.IntrinsicGas(call.Data, accessList, nil, call.To == nil, b.bc.Config().Rules(block.Number()))
+	intrinsicGas, err := types.IntrinsicGas(call.Data, accessList, nil, call.To == nil, b.bc.Config().Rules(block.Number()))
 	if err != nil {
 		return nil, err
 	}
 
 	msg := types.NewMessage(call.From, call.To, 0, call.Value, call.Gas, gasPrice, nil, nil, call.Data,
-		false, intrinsicGas, dataTokens, accessList, nil)
+		false, intrinsicGas, accessList, nil)
 
 	txContext := blockchain.NewEVMTxContext(msg, block.Header(), b.bc.Config())
 	blockContext := blockchain.NewEVMBlockContext(block.Header(), b.bc, nil)

accounts/abi/bind/backends/simulated.go

@@ -500,8 +500,8 @@ func (b *SimulatedBackend) callContract(_ context.Context, call kaia.CallMsg, bl
 	if call.AccessList != nil {
 		accessList = *call.AccessList
 	}
-	intrinsicGas, dataTokens, _ := types.IntrinsicGas(call.Data, accessList, nil, call.To == nil, b.config.Rules(block.Number()))
-	msg := types.NewMessage(call.From, call.To, nonce, call.Value, call.Gas, gasPrice, nil, nil, call.Data, true, intrinsicGas, dataTokens, accessList, nil)
+	intrinsicGas, _ := types.IntrinsicGas(call.Data, accessList, nil, call.To == nil, b.config.Rules(block.Number()))
+	msg := types.NewMessage(call.From, call.To, nonce, call.Value, call.Gas, gasPrice, nil, nil, call.Data, true, intrinsicGas, accessList, nil)
 
 	txContext := blockchain.NewEVMTxContext(msg, block.Header(), b.config)
 	blockContext := blockchain.NewEVMBlockContext(block.Header(), b.blockchain, nil)

api/api_ethereum.go

@@ -1413,11 +1413,11 @@ func EthDoCall(ctx context.Context, b Backend, args EthTransactionArgs, blockNrO
 	} else {
 		baseFee = new(big.Int).SetUint64(params.ZeroBaseFee)
 	}
-	intrinsicGas, dataTokens, err := types.IntrinsicGas(args.data(), args.GetAccessList(), nil, args.To == nil, b.ChainConfig().Rules(header.Number))
+	intrinsicGas, err := types.IntrinsicGas(args.data(), args.GetAccessList(), nil, args.To == nil, b.ChainConfig().Rules(header.Number))
 	if err != nil {
 		return nil, err
 	}
-	msg, err := args.ToMessage(globalGasCap, baseFee, intrinsicGas, dataTokens)
+	msg, err := args.ToMessage(globalGasCap, baseFee, intrinsicGas)
 	if err != nil {
 		return nil, err
 	}
@@ -1570,11 +1570,11 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH
 	precompiles := vm.ActivePrecompiles(rules)
 
 	toMsg := func() (*types.Transaction, error) {
-		intrinsicGas, dataTokens, err := types.IntrinsicGas(args.data(), nil, nil, args.To == nil, rules)
+		intrinsicGas, err := types.IntrinsicGas(args.data(), nil, nil, args.To == nil, rules)
 		if err != nil {
 			return nil, err
 		}
-		return args.ToMessage(gasCap, header.BaseFee, intrinsicGas, dataTokens)
+		return args.ToMessage(gasCap, header.BaseFee, intrinsicGas)
 	}
 
 	if args.Gas == nil {

api/api_public_blockchain.go

@@ -332,7 +332,7 @@ func DoCall(ctx context.Context, b Backend, args CallArgs, blockNrOrHash rpc.Blo
 	// this makes sure resources are cleaned up.
 	defer cancel()
 
-	intrinsicGas, dataTokens, err := types.IntrinsicGas(args.InputData(), args.GetAccessList(), nil, args.To == nil, b.ChainConfig().Rules(header.Number))
+	intrinsicGas, err := types.IntrinsicGas(args.InputData(), args.GetAccessList(), nil, args.To == nil, b.ChainConfig().Rules(header.Number))
 	if err != nil {
 		return nil, 0, err
 	}
@@ -344,7 +344,7 @@ func DoCall(ctx context.Context, b Backend, args CallArgs, blockNrOrHash rpc.Blo
 	} else {
 		baseFee = new(big.Int).SetUint64(params.ZeroBaseFee)
 	}
-	msg, err := args.ToMessage(globalGasCap.Uint64(), baseFee, intrinsicGas, dataTokens)
+	msg, err := args.ToMessage(globalGasCap.Uint64(), baseFee, intrinsicGas)
 	if err != nil {
 		return nil, 0, err
 	}
@@ -694,7 +694,7 @@ func newRPCTransactionFromBlockHash(b *types.Block, hash common.Hash, config *pa
 	return nil
 }
 
-func (args *CallArgs) ToMessage(globalGasCap uint64, baseFee *big.Int, intrinsicGas uint64, dataTokens uint64) (*types.Transaction, error) {
+func (args *CallArgs) ToMessage(globalGasCap uint64, baseFee *big.Int, intrinsicGas uint64) (*types.Transaction, error) {
 	if args.GasPrice != nil && (args.MaxFeePerGas != nil || args.MaxPriorityFeePerGas != nil) {
 		return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
 	} else if args.MaxFeePerGas != nil && args.MaxPriorityFeePerGas != nil {
@@ -742,5 +742,5 @@ func (args *CallArgs) ToMessage(globalGasCap uint64, baseFee *big.Int, intrinsic
 	if args.AccessList != nil {
 		accessList = *args.AccessList
 	}
-	return types.NewMessage(addr, args.To, 0, value, gas, gasPrice, nil, nil, args.InputData(), false, intrinsicGas, dataTokens, accessList, nil), nil
+	return types.NewMessage(addr, args.To, 0, value, gas, gasPrice, nil, nil, args.InputData(), false, intrinsicGas, accessList, nil), nil
 }

api/tx_args.go

@@ -729,7 +729,7 @@ func (args *EthTransactionArgs) setDefaults(ctx context.Context, b Backend) erro
 }
 
 // ToMessage change EthTransactionArgs to types.Transaction in Kaia.
-func (args *EthTransactionArgs) ToMessage(globalGasCap uint64, baseFee *big.Int, intrinsicGas uint64, dataTokens uint64) (*types.Transaction, error) {
+func (args *EthTransactionArgs) ToMessage(globalGasCap uint64, baseFee *big.Int, intrinsicGas uint64) (*types.Transaction, error) {
 	// Reject invalid combinations of pre- and post-1559 fee styles
 	if args.GasPrice != nil && (args.MaxFeePerGas != nil || args.MaxPriorityFeePerGas != nil) {
 		return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
@@ -780,7 +780,7 @@ func (args *EthTransactionArgs) ToMessage(globalGasCap uint64, baseFee *big.Int,
 	if args.AccessList != nil {
 		accessList = *args.AccessList
 	}
-	return types.NewMessage(addr, args.To, 0, value, gas, gasPrice, nil, nil, data, false, intrinsicGas, dataTokens, accessList, nil), nil
+	return types.NewMessage(addr, args.To, 0, value, gas, gasPrice, nil, nil, data, false, intrinsicGas, accessList, nil), nil
 }
 
 // toTransaction converts the arguments to a transaction.

blockchain/bench_test.go

@@ -111,7 +111,7 @@ func genValueTx(nbytes int) func(int, *BlockGen) {
 	return func(i int, gen *BlockGen) {
 		toaddr := common.Address{}
 		data := make([]byte, nbytes)
-		gas, _, _ := types.IntrinsicGas(data, nil, nil, false, params.TestChainConfig.Rules(big.NewInt(0)))
+		gas, _ := types.IntrinsicGas(data, nil, nil, false, params.TestChainConfig.Rules(big.NewInt(0)))
 		signer := types.LatestSignerForChainID(params.TestChainConfig.ChainID)
 		tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(benchRootAddr), toaddr, big.NewInt(1), gas, nil, data), signer, benchRootKey)
 		gen.AddTx(tx)

blockchain/blockchain_test.go

@@ -1461,8 +1461,8 @@ func TestAccessListTx(t *testing.T) {
 			b.SetRewardbase(common.Address{1})
 
 			// One transaction to 0xAAAA
-			intrinsicGas, dataTokens, _ := types.IntrinsicGas([]byte{}, list, nil, false, gspec.Config.Rules(block.Number()))
-			tx, _ := types.SignTx(types.NewMessage(senderAddr, &contractAddr, senderNonce, big.NewInt(0), 30000, big.NewInt(1), nil, nil, []byte{}, false, intrinsicGas, dataTokens, list, nil), signer, senderKey)
+			intrinsicGas, _ := types.IntrinsicGas([]byte{}, list, nil, false, gspec.Config.Rules(block.Number()))
+			tx, _ := types.SignTx(types.NewMessage(senderAddr, &contractAddr, senderNonce, big.NewInt(0), 30000, big.NewInt(1), nil, nil, []byte{}, false, intrinsicGas, list, nil), signer, senderKey)
 			b.AddTx(tx)
 		})
 		if n, err := chain.InsertChain(blocks); err != nil {
@@ -2345,13 +2345,13 @@ func TestEIP7702(t *testing.T) {
 		b.SetRewardbase(common.Address{1})
 
 		authorizationList := []types.Authorization{*auth1, *auth2}
-		intrinsicGas, dataTokens, err := types.IntrinsicGas(nil, nil, authorizationList, false, params.TestRules)
+		intrinsicGas, err := types.IntrinsicGas(nil, nil, authorizationList, false, params.TestRules)
 		if err != nil {
 			t.Fatalf("failed to run intrinsic gas: %v", err)
 		}
 
 		tx, err := types.SignTx(types.NewMessage(addr1, &addr1, uint64(0), nil, 500000, nil, newGkei(50),
-			big.NewInt(20), nil, false, intrinsicGas, dataTokens, nil, authorizationList), signer, key1)
+			big.NewInt(20), nil, false, intrinsicGas, nil, authorizationList), signer, key1)
 		if err != nil {
 			t.Fatalf("failed to sign tx: %v", err)
 		}
@@ -2426,13 +2426,13 @@ func TestEIP7702(t *testing.T) {
 		}, key1)
 
 		authorizationList := []types.Authorization{*authForEmpty}
-		intrinsicGas, dataTokens, err := types.IntrinsicGas(nil, nil, authorizationList, false, params.TestRules)
+		intrinsicGas, err := types.IntrinsicGas(nil, nil, authorizationList, false, params.TestRules)
 		if err != nil {
 			t.Fatalf("failed to run intrinsic gas: %v", err)
 		}
 
 		tx, err := types.SignTx(types.NewMessage(addr1, &addr1, state.GetNonce(addr1), nil, 500000, nil, newGkei(50),
-			big.NewInt(20), nil, false, intrinsicGas, dataTokens, nil, authorizationList), signer, key1)
+			big.NewInt(20), nil, false, intrinsicGas, nil, authorizationList), signer, key1)
 		if err != nil {
 			t.Fatalf("failed to sign tx: %v", err)
 		}

blockchain/state_processor.go

@@ -112,7 +112,7 @@ func ProcessParentBlockHash(header *types.Header, vmenv *vm.EVM, statedb vm.Stat
 		gasLimit = uint64(30_000_000)
 	)
 
-	intrinsicGas, dataTokens, err := types.IntrinsicGas(data, nil, nil, false, rules)
+	intrinsicGas, err := types.IntrinsicGas(data, nil, nil, false, rules)
 	if err != nil {
 		return err
 	}
@@ -129,7 +129,6 @@ func ProcessParentBlockHash(header *types.Header, vmenv *vm.EVM, statedb vm.Stat
 		data,
 		false,
 		intrinsicGas,
-		dataTokens,
 		nil,
 		nil,
 	)

blockchain/state_transition.go

@@ -23,6 +23,7 @@
 package blockchain
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"math"
@@ -112,7 +113,7 @@ type Message interface {
 
 	// IntrinsicGas returns `intrinsic gas` based on the tx type.
 	// This value is used to differentiate tx fee based on the tx type.
-	IntrinsicGas(currentBlockNumber uint64) (uint64, uint64, error)
+	IntrinsicGas(currentBlockNumber uint64) (uint64, error)
 
 	// Type returns the transaction type of the message.
 	Type() types.TxType
@@ -352,7 +353,7 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	}
 	rules := st.evm.ChainConfig().Rules(st.evm.Context.BlockNumber)
 	if rules.IsPrague {
-		floorGas, err := FloorDataGas(st.msg.Type(), validatedGas.Tokens, validatedGas.SigValidateGas)
+		floorGas, err := FloorDataGas(st.msg.Type(), msg.Data(), validatedGas.SigValidateGas)
 		if err != nil {
 			return nil, err
 		}
@@ -430,7 +431,7 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	if rules.IsPrague {
 		// After EIP-7623: Data-heavy transactions pay the floor gas.
 		// Overflow error has already been checked and can be ignored here.
-		floorGas, _ := FloorDataGas(st.msg.Type(), validatedGas.Tokens, validatedGas.SigValidateGas)
+		floorGas, _ := FloorDataGas(st.msg.Type(), msg.Data(), validatedGas.SigValidateGas)
 		if st.gasUsed() < floorGas {
 			st.gas = st.initialGas - floorGas
 		}
@@ -608,7 +609,12 @@ func (st *StateTransition) processAuthorizationList(authList types.Authorization
 
 // FloorDataGas calculates the minimum gas required for a transaction
 // based on its data tokens (EIP-7623).
-func FloorDataGas(txType types.TxType, tokens, sigValidateGas uint64) (uint64, error) {
+func FloorDataGas(txType types.TxType, data []byte, sigValidateGas uint64) (uint64, error) {
+	var (
+		z      = uint64(bytes.Count(data, []byte{0}))
+		nz     = uint64(len(data)) - z
+		tokens = nz*params.TokenPerNonZeroByte7623 + z
+	)
 	// Check for overflow
 	// Instead of using parmas.TxGas, we should consider the tx type
 	// because Kaia tx type has different tx gas (e.g., fee delegated tx).
@@ -619,5 +625,6 @@ func FloorDataGas(txType types.TxType, tokens, sigValidateGas uint64) (uint64, e
 	if (math.MaxUint64-txGas)/params.CostFloorPerToken7623 < tokens {
 		return 0, types.ErrGasUintOverflow
 	}
+	// We add up sig validate gas too, as it's the final floor gas
 	return txGas + tokens*params.CostFloorPerToken7623 + sigValidateGas, nil
 }

blockchain/system/multicall.go

@@ -49,7 +49,6 @@ func (caller *ContractCallerForMultiCall) CallContract(ctx context.Context, call
 	gasPrice := big.NewInt(0) // execute call regardless of the balance of the sender
 	gasLimit := uint64(1e8)   // enough gas limit to execute multicall contract functions
 	intrinsicGas := uint64(0) // read operation doesn't require intrinsicGas
-	dataTokens := uint64(0)   // read operation doesn't require intrinsicGas
 
 	// call.From: zero address will be assigned if nothing is specified
 	// call.To: the target contract address will be assigned by `BoundContract`
@@ -64,7 +63,7 @@ func (caller *ContractCallerForMultiCall) CallContract(ctx context.Context, call
 	}
 
 	msg := types.NewMessage(call.From, call.To, caller.state.GetNonce(call.From),
-		call.Value, gasLimit, gasPrice, nil, nil, call.Data, false, intrinsicGas, dataTokens, nil, nil)
+		call.Value, gasLimit, gasPrice, nil, nil, call.Data, false, intrinsicGas, nil, nil)
 
 	blockContext := blockchain.NewEVMBlockContext(caller.header, caller.chain, nil)
 	txContext := blockchain.NewEVMTxContext(msg, caller.header, caller.chain.Config())

blockchain/system/rebalance.go

@@ -108,7 +108,6 @@ func (caller *Kip103ContractCaller) CallContract(ctx context.Context, call kaia.
 	gasPrice := big.NewInt(0) // execute call regardless of the balance of the sender
 	gasLimit := uint64(1e8)   // enough gas limit to execute kip103 contract functions
 	intrinsicGas := uint64(0) // read operation doesn't require intrinsicGas
-	dataTokens := uint64(0)   // read operation doesn't require intrinsicGas
 
 	// call.From: zero address will be assigned if nothing is specified
 	// call.To: the target contract address will be assigned by `BoundContract`
@@ -123,7 +122,7 @@ func (caller *Kip103ContractCaller) CallContract(ctx context.Context, call kaia.
 	//	return nil, err
 	//}
 	msg := types.NewMessage(call.From, call.To, caller.state.GetNonce(call.From),
-		call.Value, gasLimit, gasPrice, nil, nil, call.Data, false, intrinsicGas, dataTokens, nil, nil)
+		call.Value, gasLimit, gasPrice, nil, nil, call.Data, false, intrinsicGas, nil, nil)
 
 	blockContext := blockchain.NewEVMBlockContext(caller.header, caller.chain, nil)
 	txContext := blockchain.NewEVMTxContext(msg, caller.header, caller.chain.Config())

blockchain/tx_pool.go

@@ -836,7 +836,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction) error {
 		}
 	}
 
-	intrGas, dataTokens, err := tx.IntrinsicGas(pool.currentBlockNumber)
+	intrGas, err := tx.IntrinsicGas(pool.currentBlockNumber)
 	sigValGas := gasFrom + gasFeePayer
 	if err != nil {
 		return err
@@ -846,7 +846,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction) error {
 	}
 	// Ensure the transaction can cover floor data gas.
 	if pool.rules.IsPrague {
-		floorGas, err := FloorDataGas(tx.Type(), dataTokens, sigValGas)
+		floorGas, err := FloorDataGas(tx.Type(), tx.Data(), sigValGas)
 		if err != nil {
 			return err
 		}

blockchain/types/transaction.go

@@ -82,7 +82,6 @@ func ErrFeePayer(err error) error {
 type ValidatedGas struct {
 	IntrinsicGas   uint64
 	SigValidateGas uint64
-	Tokens         uint64
 }
 
 type Transaction struct {
@@ -406,7 +405,7 @@ func (tx *Transaction) ValidatedGas() *ValidatedGas {
 func (tx *Transaction) MakeRPCOutput() map[string]interface{} { return tx.data.MakeRPCOutput() }
 func (tx *Transaction) GetTxInternalData() TxInternalData     { return tx.data }
 
-func (tx *Transaction) IntrinsicGas(currentBlockNumber uint64) (uint64, uint64, error) {
+func (tx *Transaction) IntrinsicGas(currentBlockNumber uint64) (uint64, error) {
 	return tx.data.IntrinsicGas(currentBlockNumber)
 }
 
@@ -597,7 +596,7 @@ func (tx *Transaction) Execute(vm VM, stateDB StateDB, currentBlockNumber uint64
 // XXX Rename message to something less arbitrary?
 // TODO-Kaia: Message is removed and this function will return *Transaction.
 func (tx *Transaction) AsMessageWithAccountKeyPicker(s Signer, picker AccountKeyPicker, currentBlockNumber uint64) (*Transaction, error) {
-	intrinsicGas, dataTokens, err := tx.IntrinsicGas(currentBlockNumber)
+	intrinsicGas, err := tx.IntrinsicGas(currentBlockNumber)
 	if err != nil {
 		return nil, err
 	}
@@ -620,7 +619,7 @@ func (tx *Transaction) AsMessageWithAccountKeyPicker(s Signer, picker AccountKey
 	}
 
 	tx.mu.Lock()
-	tx.validatedGas = &ValidatedGas{IntrinsicGas: intrinsicGas, SigValidateGas: gasFrom + gasFeePayer, Tokens: dataTokens}
+	tx.validatedGas = &ValidatedGas{IntrinsicGas: intrinsicGas, SigValidateGas: gasFrom + gasFeePayer}
 	tx.mu.Unlock()
 
 	return tx, err
@@ -1092,9 +1091,9 @@ func (t *TransactionsByPriceAndNonce) Clear() {
 }
 
 // NewMessage returns a `*Transaction` object with the given arguments.
-func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice, gasFeeCap, gasTipCap *big.Int, data []byte, checkNonce bool, intrinsicGas uint64, dataTokens uint64, list AccessList, auth AuthorizationList) *Transaction {
+func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice, gasFeeCap, gasTipCap *big.Int, data []byte, checkNonce bool, intrinsicGas uint64, list AccessList, auth AuthorizationList) *Transaction {
 	transaction := &Transaction{
-		validatedGas:      &ValidatedGas{IntrinsicGas: intrinsicGas, SigValidateGas: 0, Tokens: dataTokens},
+		validatedGas:      &ValidatedGas{IntrinsicGas: intrinsicGas, SigValidateGas: 0},
 		validatedFeePayer: from,
 		validatedSender:   from,
 		checkNonce:        checkNonce,

blockchain/types/transaction_test.go

@@ -627,28 +627,27 @@ func TestIntrinsicGas(t *testing.T) {
 		data, err = hex.DecodeString(tc.inputString) // decode input string to hex data
 		assert.Equal(t, nil, err)
 
-		// TODO-Kaia: Add test for EIP-7623
-		gas, _, err = IntrinsicGas(data, nil, nil, false, params.Rules{IsIstanbul: false})
+		gas, err = IntrinsicGas(data, nil, nil, false, params.Rules{IsIstanbul: false})
 		assert.Equal(t, tc.expectGas1, gas)
 		assert.Equal(t, nil, err)
 
-		gas, _, err = IntrinsicGas(data, nil, nil, false, params.Rules{IsIstanbul: true})
+		gas, err = IntrinsicGas(data, nil, nil, false, params.Rules{IsIstanbul: true})
 		assert.Equal(t, tc.expectGas2, gas)
 		assert.Equal(t, nil, err)
 
-		gas, _, err = IntrinsicGas(data, nil, nil, false, params.Rules{IsIstanbul: true, IsShanghai: true, IsPrague: true})
+		gas, err = IntrinsicGas(data, nil, nil, false, params.Rules{IsIstanbul: true, IsShanghai: true, IsPrague: true})
 		assert.Equal(t, tc.expectGas3, gas)
 		assert.Equal(t, nil, err)
 
-		gas, _, err = IntrinsicGas(data, nil, nil, true, params.Rules{IsIstanbul: false})
+		gas, err = IntrinsicGas(data, nil, nil, true, params.Rules{IsIstanbul: false})
 		assert.Equal(t, tc.expectGas4, gas)
 		assert.Equal(t, nil, err)
 
-		gas, _, err = IntrinsicGas(data, nil, nil, true, params.Rules{IsIstanbul: true})
+		gas, err = IntrinsicGas(data, nil, nil, true, params.Rules{IsIstanbul: true})
 		assert.Equal(t, tc.expectGas5, gas)
 		assert.Equal(t, nil, err)
 
-		gas, _, err = IntrinsicGas(data, nil, nil, true, params.Rules{IsIstanbul: true, IsShanghai: true, IsPrague: true})
+		gas, err = IntrinsicGas(data, nil, nil, true, params.Rules{IsIstanbul: true, IsShanghai: true, IsPrague: true})
 		assert.Equal(t, tc.expectGas6, gas)
 		assert.Equal(t, nil, err)
 	}