fix(evm): Pass block timestamp to MakeSigner and refactor MsgEthereumTx field usage

- Update all calls to `gethcore.MakeSigner` to include the block time as a Unix timestamp (seconds), using `evm.ParseBlockTimeUnixU64(ctx)`.
- Add `ParseBlockTimeUnixU64` utility to extract block time from `sdk.Context` in a safe, reusable way.
- Refactor usage of MsgEthereumTx field getters to use direct struct fields (`From`, `To`, `Value`, `GasFeeCap`, etc.), improving efficiency and clarity.
- Enhance `ParseWeiAsMultipleOfMicronibi` to return `uint256.Int` and handle nil, zero, negative, and overflow edge cases with clear error messages.

Author: Unique-Divine

app/evmante/evmante_can_transfer.go

@@ -25,7 +25,11 @@ func (ctd CanTransferDecorator) AnteHandle(
 	ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler,
 ) (sdk.Context, error) {
 	ethCfg := evm.EthereumConfig(ctd.EVMKeeper.EthChainID(ctx))
-	signer := gethcore.MakeSigner(ethCfg, big.NewInt(ctx.BlockHeight()))
+	signer := gethcore.MakeSigner(
+		ethCfg,
+		big.NewInt(ctx.BlockHeight()),
+		evm.ParseBlockTimeUnixU64(ctx),
+	)
 
 	for _, msg := range tx.GetMsgs() {
 		msgEthTx, ok := msg.(*evm.MsgEthereumTx)
@@ -57,25 +61,25 @@ func (ctd CanTransferDecorator) AnteHandle(
 			return ctx, errors.Wrapf(
 				sdkerrors.ErrInsufficientFee,
 				"gas fee cap (wei) less than block base fee (wei); (%s < %s)",
-				evmMsg.GasFeeCap(), baseFeeWeiPerGas,
+				evmMsg.GasFeeCap, baseFeeWeiPerGas,
 			)
 		}
 
 		// check that caller has enough balance to cover asset transfer for **topmost** call
 		// NOTE: here the gas consumed is from the context with the infinite gas meter
 
-		if evmMsg.Value().Sign() > 0 {
-			nibiruAddr := eth.EthAddrToNibiruAddr(evmMsg.From())
+		if evmMsg.Value.Sign() > 0 {
+			nibiruAddr := eth.EthAddrToNibiruAddr(evmMsg.From)
 			balanceNative := ctd.Bank.GetBalance(ctx, nibiruAddr, evm.EVMBankDenom).Amount.BigInt()
 			balanceWei := evm.NativeToWei(balanceNative)
 
-			if balanceWei.Cmp(evmMsg.Value()) < 0 {
+			if balanceWei.Cmp(evmMsg.Value) < 0 {
 				return ctx, errors.Wrapf(
 					sdkerrors.ErrInsufficientFunds,
 					"failed to transfer %s wei ( balance=%s )from address %s using the EVM block context transfer function",
-					evmMsg.Value(),
+					evmMsg.Value,
 					balanceWei,
-					evmMsg.From(),
+					evmMsg.From,
 				)
 			}
 		}

app/evmante/evmante_sigverify.go

@@ -36,7 +36,11 @@ func (esvd EthSigVerificationDecorator) AnteHandle(
 	chainID := esvd.evmKeeper.EthChainID(ctx)
 	ethCfg := evm.EthereumConfig(chainID)
 	blockNum := big.NewInt(ctx.BlockHeight())
-	signer := gethcore.MakeSigner(ethCfg, blockNum)
+	signer := gethcore.MakeSigner(
+		ethCfg,
+		blockNum,
+		evm.ParseBlockTimeUnixU64(ctx),
+	)
 
 	for _, msg := range tx.GetMsgs() {
 		msgEthTx, ok := msg.(*evm.MsgEthereumTx)

x/evm/const.go

@@ -153,3 +153,13 @@ func ParseWeiAsMultipleOfMicronibi(weiInt *big.Int) (newWeiInt *big.Int, err err
 	newWeiInt = NativeToWei(WeiToNative(weiInt))
 	return newWeiInt, nil
 }
+
+// Parses the block time as a Unix timestamp in seconds for use with
+// "gethcore.MakeSigner".
+func ParseBlockTimeUnixU64(ctx sdk.Context) uint64 {
+	blockTimeI64 := ctx.BlockTime().Unix()
+	if blockTimeI64 <= 0 {
+		return 0
+	}
+	return uint64(blockTimeI64)
+}

x/evm/keeper/grpc_query.go

@@ -495,7 +495,11 @@ func (k Keeper) TraceTx(
 		evmCfg.BaseFeeWei = baseFeeWeiPerGas
 	}
 
-	signer := gethcore.MakeSigner(evmCfg.ChainConfig, big.NewInt(ctx.BlockHeight()))
+	signer := gethcore.MakeSigner(
+		evmCfg.ChainConfig,
+		big.NewInt(ctx.BlockHeight()),
+		evm.ParseBlockTimeUnixU64(ctx),
+	)
 	txConfig := statedb.NewEmptyTxConfig(gethcommon.BytesToHash(ctx.HeaderHash().Bytes()))
 
 	// gas used at this point corresponds to GetProposerAddress & CalculateBaseFee
@@ -679,7 +683,11 @@ func (k Keeper) TraceBlock(
 		tracerConfig, _ = json.Marshal(req.TraceConfig.TracerConfig)
 	}
 
-	signer := gethcore.MakeSigner(evmCfg.ChainConfig, big.NewInt(ctx.BlockHeight()))
+	signer := gethcore.MakeSigner(
+		evmCfg.ChainConfig,
+		big.NewInt(ctx.BlockHeight()),
+		evm.ParseBlockTimeUnixU64(ctx),
+	)
 	txsLength := len(req.Txs)
 	results := make([]*evm.TxTraceResult, 0, txsLength)
 

x/evm/keeper/msg_server.go

@@ -18,6 +18,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/holiman/uint256"
 
 	"github.com/NibiruChain/nibiru/v2/eth"
 	"github.com/NibiruChain/nibiru/v2/x/evm"
@@ -301,42 +302,42 @@ func (k *Keeper) ApplyEvmMsg(
 	// needed when `ApplyMessage` is called under contexts where ante handlers
 	// are not run, for example `eth_call` and `eth_estimateGas`.
 	evmObj.StateDB.PrepareAccessList(
-		msg.From(),
-		msg.To(),
+		msg.From,
+		msg.To,
 		evmObj.ActivePrecompiles(params.Rules{}),
 		msg.AccessList(),
 	)
 
-	msgWei, err := ParseWeiAsMultipleOfMicronibi(msg.Value())
+	msgWei, err := ParseWeiAsMultipleOfMicronibi(msg.Value)
 	if err != nil {
-		return nil, errors.Wrapf(err, "ApplyEvmMsg: invalid wei amount %s", msg.Value())
+		return nil, errors.Wrapf(err, "ApplyEvmMsg: invalid wei amount %s", msg.Value)
 	}
 
 	// take over the nonce management from evm:
 	// - reset sender's nonce to msg.Nonce() before calling evm.
 	// - increase sender's nonce by one no matter the result.
-	evmObj.StateDB.SetNonce(msg.From(), msg.Nonce())
+	evmObj.StateDB.SetNonce(msg.From, msg.Nonce)
 
 	var returnBz []byte
 	var vmErr error
 	if contractCreation {
 		returnBz, _, gasRemaining, vmErr = evmObj.Create(
-			vm.AccountRef(msg.From()),
-			msg.Data(),
+			vm.AccountRef(msg.From),
+			msg.Data,
 			gasRemaining,
 			msgWei,
 		)
 	} else {
 		returnBz, gasRemaining, vmErr = evmObj.Call(
-			vm.AccountRef(msg.From()),
-			*msg.To(),
-			msg.Data(),
+			vm.AccountRef(msg.From),
+			*msg.To,
+			msg.Data,
 			gasRemaining,
 			msgWei,
 		)
 	}
 	// Increment nonce after processing the message
-	evmObj.StateDB.SetNonce(msg.From(), msg.Nonce()+1)
+	evmObj.StateDB.SetNonce(msg.From, msg.Nonce+1)
 
 	// EVM execution error needs to be available for the JSON-RPC client
 	var vmError string
@@ -374,21 +375,33 @@ func (k *Keeper) ApplyEvmMsg(
 	return evmResp, nil
 }
 
-func ParseWeiAsMultipleOfMicronibi(weiInt *big.Int) (newWeiInt *big.Int, err error) {
+func ParseWeiAsMultipleOfMicronibi(weiInt *big.Int) (
+	newWeiInt *uint256.Int, err error,
+) {
 	// if "weiValue" is nil, 0, or negative, early return
-	if weiInt == nil || !(weiInt.Cmp(big.NewInt(0)) > 0) {
-		return weiInt, nil
+	cmpSign := weiInt.Cmp(big.NewInt(0))
+	if weiInt == nil {
+		return (*uint256.Int)(nil), nil
+	} else if cmpSign == 0 {
+		return uint256.NewInt(0), nil
+	} else if cmpSign < 0 {
+		return newWeiInt, fmt.Errorf("Wei parsing error: negative wei value cannot be a uint256 (%s)", weiInt)
 	}
 
 	// err if weiInt is too small
 	tenPow12 := new(big.Int).Exp(big.NewInt(10), big.NewInt(12), nil)
 	if weiInt.Cmp(tenPow12) < 0 {
-		return weiInt, fmt.Errorf(
-			"wei amount is too small (%s), cannot transfer less than 1 micronibi. 1 NIBI == 10^6 micronibi == 10^18 wei", weiInt)
+		return newWeiInt, fmt.Errorf(
+			"Wei parsing error: wei amount is too small (%s), cannot transfer less than 1 micronibi. 1 NIBI == 10^6 micronibi == 10^18 wei", weiInt)
 	}
 
 	// truncate to highest micronibi amount
-	newWeiInt = evm.NativeToWei(evm.WeiToNative(weiInt))
+	newWeiInt, overflowed := uint256.FromBig(
+		evm.NativeToWei(evm.WeiToNative(weiInt)),
+	)
+	if overflowed {
+		return newWeiInt, fmt.Errorf("Wei parsing error: overflow occured in conversion from big.Int to uint256.Int for wei value %s", weiInt)
+	}
 	return newWeiInt, nil
 }