From d4f94b975ebf92a24deceef842e78f9bcaaba254 Mon Sep 17 00:00:00 2001 From: Diego Essaya Date: Wed, 4 Oct 2023 10:44:29 -0300 Subject: [PATCH] fix(jsonrpc): require tx.GasPrice == chain gas price --- packages/chainutil/evmcall.go | 9 ++- packages/chainutil/evmestimategas.go | 13 +++-- packages/evm/evmutil/gasprice.go | 23 ++++++++ packages/evm/jsonrpc/evmchain.go | 33 +++-------- packages/evm/jsonrpc/jsonrpctest/env.go | 27 +++++---- .../evm/jsonrpc/jsonrpctest/jsonrpc_test.go | 8 +-- packages/evm/jsonrpc/types.go | 3 +- packages/isc/request.go | 3 + packages/isc/request_evmcall.go | 5 ++ packages/isc/request_evmtx.go | 4 ++ packages/isc/request_offledger.go | 6 ++ .../testdbhash/TestStorageContract.hex | 2 +- packages/vm/core/accounts/impl_views.go | 2 +- packages/vm/core/accounts/nonce.go | 19 +------ packages/vm/core/accounts/stateaccess.go | 2 +- .../vm/core/evm/emulator/emulator_test.go | 8 ++- packages/vm/core/evm/evmimpl/external.go | 10 ---- packages/vm/core/evm/evmtest/evm_test.go | 56 +++++-------------- packages/vm/core/evm/evmtest/utils_test.go | 17 +++--- packages/vm/core/evm/interface.go | 5 -- packages/vm/gas/feepolicy.go | 21 +++++++ packages/vm/vmimpl/skipreq.go | 37 +++++++----- tools/cluster/tests/env.go | 15 +++-- tools/cluster/tests/pruning_test.go | 3 +- tools/cluster/tests/spam_test.go | 3 +- tools/cluster/tests/wasp-cli_test.go | 5 +- 26 files changed, 178 insertions(+), 161 deletions(-) create mode 100644 packages/evm/evmutil/gasprice.go diff --git a/packages/chainutil/evmcall.go b/packages/chainutil/evmcall.go index b3c9ec4ad7..4f0afd7d4e 100644 --- a/packages/chainutil/evmcall.go +++ b/packages/chainutil/evmcall.go @@ -8,18 +8,25 @@ import ( "github.com/iotaledger/wasp/packages/chain" "github.com/iotaledger/wasp/packages/isc" + "github.com/iotaledger/wasp/packages/parameters" "github.com/iotaledger/wasp/packages/vm/core/evm" + "github.com/iotaledger/wasp/packages/vm/gas" ) // EVMCall executes an EVM contract call and returns its output, discarding any state changes func EVMCall(ch chain.ChainCore, aliasOutput *isc.AliasOutputWithID, call ethereum.CallMsg) ([]byte, error) { - gasLimit := getMaxCallGasLimit(ch) + info := getChainInfo(ch) // 0 means view call + gasLimit := gas.EVMCallGasLimit(info.GasLimits, &info.GasFeePolicy.EVMGasRatio) if call.Gas != 0 && call.Gas > gasLimit { call.Gas = gasLimit } + if call.GasPrice == nil { + call.GasPrice = info.GasFeePolicy.GasPriceWei(parameters.L1().BaseToken.Decimals) + } + iscReq := isc.NewEVMOffLedgerCallRequest(ch.ID(), call) // TODO: setting EstimateGasMode = true feels wrong here res, err := runISCRequest(ch, aliasOutput, time.Now(), iscReq, true) diff --git a/packages/chainutil/evmestimategas.go b/packages/chainutil/evmestimategas.go index c1a7d17fc4..1a1b30c7ce 100644 --- a/packages/chainutil/evmestimategas.go +++ b/packages/chainutil/evmestimategas.go @@ -10,6 +10,7 @@ import ( "github.com/iotaledger/wasp/packages/chain" "github.com/iotaledger/wasp/packages/isc" + "github.com/iotaledger/wasp/packages/parameters" "github.com/iotaledger/wasp/packages/vm" "github.com/iotaledger/wasp/packages/vm/core/governance" "github.com/iotaledger/wasp/packages/vm/gas" @@ -27,14 +28,19 @@ func EVMEstimateGas(ch chain.ChainCore, aliasOutput *isc.AliasOutputWithID, call gasCap uint64 ) - maximumPossibleGas := getMaxCallGasLimit(ch) + info := getChainInfo(ch) + maximumPossibleGas := gas.EVMCallGasLimit(info.GasLimits, &info.GasFeePolicy.EVMGasRatio) if call.Gas >= params.TxGas { hi = call.Gas } else { hi = maximumPossibleGas } + if call.GasPrice == nil { + call.GasPrice = info.GasFeePolicy.GasPriceWei(parameters.L1().BaseToken.Decimals) + } + gasCap = hi // Create a helper to check if a gas allowance results in an executable transaction @@ -114,9 +120,8 @@ func EVMEstimateGas(ch chain.ChainCore, aliasOutput *isc.AliasOutputWithID, call return hi, nil } -func getMaxCallGasLimit(ch chain.ChainCore) uint64 { - info := governance.NewStateAccess(mustLatestState(ch)).ChainInfo(ch.ID()) - return gas.EVMCallGasLimit(info.GasLimits, &info.GasFeePolicy.EVMGasRatio) +func getChainInfo(ch chain.ChainCore) *isc.ChainInfo { + return governance.NewStateAccess(mustLatestState(ch)).ChainInfo(ch.ID()) } func resolveError(ch chain.ChainCore, receiptError *isc.UnresolvedVMError) (isOutOfGas bool, resolved *isc.VMError, err error) { diff --git a/packages/evm/evmutil/gasprice.go b/packages/evm/evmutil/gasprice.go new file mode 100644 index 0000000000..81cd47dccc --- /dev/null +++ b/packages/evm/evmutil/gasprice.go @@ -0,0 +1,23 @@ +package evmutil + +import ( + "fmt" + + "github.com/ethereum/go-ethereum/core/types" + + "github.com/iotaledger/wasp/packages/parameters" + "github.com/iotaledger/wasp/packages/vm/gas" +) + +func CheckGasPrice(tx *types.Transaction, gasFeePolicy *gas.FeePolicy) error { + expectedGasPrice := gasFeePolicy.GasPriceWei(parameters.L1().BaseToken.Decimals) + gasPrice := tx.GasPrice() + if gasPrice.Cmp(expectedGasPrice) != 0 { + return fmt.Errorf( + "invalid gas price: got %s, want %s", + gasPrice.Text(10), + expectedGasPrice.Text(10), + ) + } + return nil +} diff --git a/packages/evm/jsonrpc/evmchain.go b/packages/evm/jsonrpc/evmchain.go index fd7eb1d925..4759183599 100644 --- a/packages/evm/jsonrpc/evmchain.go +++ b/packages/evm/jsonrpc/evmchain.go @@ -185,19 +185,22 @@ func (e *EVMChain) SendTransaction(tx *types.Transaction) error { return fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), expectedNonce) } - if err := e.checkEnoughL2FundsForGasBudget(sender, tx.Gas()); err != nil { + gasFeePolicy := e.GasFeePolicy() + if err := e.checkEnoughL2FundsForGasBudget(sender, tx.Gas(), gasFeePolicy); err != nil { + return err + } + if err := evmutil.CheckGasPrice(tx, gasFeePolicy); err != nil { return err } return e.backend.EVMSendTransaction(tx) } -func (e *EVMChain) checkEnoughL2FundsForGasBudget(sender common.Address, evmGas uint64) error { - gasRatio := e.GasRatio() +func (e *EVMChain) checkEnoughL2FundsForGasBudget(sender common.Address, evmGas uint64, gasFeePolicy *gas.FeePolicy) error { + gasRatio := gasFeePolicy.EVMGasRatio balance, err := e.Balance(sender, nil) if err != nil { return fmt.Errorf("could not fetch sender balance: %w", err) } - gasFeePolicy := e.GasFeePolicy() gasLimits := e.gasLimits() @@ -443,27 +446,7 @@ func (e *EVMChain) EstimateGas(callMsg ethereum.CallMsg, blockNumberOrHash *rpc. func (e *EVMChain) GasPrice() *big.Int { e.log.Debugf("GasPrice()") - - iscState := e.backend.ISCLatestState() - governancePartition := subrealm.NewReadOnly(iscState, kv.Key(governance.Contract.Hname().Bytes())) - feePolicy := governance.MustGetGasFeePolicy(governancePartition) - - // special case '0:0' for free request - if feePolicy.GasPerToken.IsZero() { - return big.NewInt(0) - } - - // convert to wei (18 decimals) - decimalsDifference := 18 - parameters.L1().BaseToken.Decimals - price := big.NewInt(10) - price.Exp(price, new(big.Int).SetUint64(uint64(decimalsDifference)), nil) - - price.Mul(price, new(big.Int).SetUint64(uint64(feePolicy.GasPerToken.B))) - price.Div(price, new(big.Int).SetUint64(uint64(feePolicy.GasPerToken.A))) - price.Mul(price, new(big.Int).SetUint64(uint64(feePolicy.EVMGasRatio.A))) - price.Div(price, new(big.Int).SetUint64(uint64(feePolicy.EVMGasRatio.B))) - - return price + return e.GasFeePolicy().GasPriceWei(parameters.L1().BaseToken.Decimals) } func (e *EVMChain) StorageAt(address common.Address, key common.Hash, blockNumberOrHash *rpc.BlockNumberOrHash) (common.Hash, error) { diff --git a/packages/evm/jsonrpc/jsonrpctest/env.go b/packages/evm/jsonrpc/jsonrpctest/env.go index ae3b0ea242..17d6111dd7 100644 --- a/packages/evm/jsonrpc/jsonrpctest/env.go +++ b/packages/evm/jsonrpc/jsonrpctest/env.go @@ -26,7 +26,6 @@ import ( "github.com/iotaledger/wasp/packages/evm/evmutil" "github.com/iotaledger/wasp/packages/evm/jsonrpc" "github.com/iotaledger/wasp/packages/isc" - "github.com/iotaledger/wasp/packages/vm/core/evm" ) // Env is a testing environment for the EVM JSON-RPC support, allowing to run the same tests @@ -58,15 +57,14 @@ func (e *Env) DeployEVMContract(creator *ecdsa.PrivateKey, contractABI abi.ABI, value := big.NewInt(0) gasLimit := e.estimateGas(ethereum.CallMsg{ - From: creatorAddress, - To: nil, // contract creation - GasPrice: evm.GasPrice, - Value: value, - Data: data, + From: creatorAddress, + To: nil, // contract creation + Value: value, + Data: data, }) tx, err := types.SignTx( - types.NewContractCreation(nonce, value, gasLimit, evm.GasPrice, data), + types.NewContractCreation(nonce, value, gasLimit, e.MustGetGasPrice(), data), e.Signer(), creator, ) @@ -278,6 +276,12 @@ func (e *Env) MustSendTransaction(args *jsonrpc.SendTxArgs) common.Hash { return res } +func (e *Env) MustGetGasPrice() *big.Int { + res, err := e.Client.SuggestGasPrice(context.Background()) + require.NoError(e.T, err) + return res +} + func (e *Env) getLogs(q ethereum.FilterQuery) []types.Log { logs, err := e.Client.FilterLogs(context.Background(), q) require.NoError(e.T, err) @@ -312,7 +316,7 @@ func (e *Env) TestRPCGetLogs() { Data: callArguments, }) transferTx, err := types.SignTx( - types.NewTransaction(e.NonceAt(creatorAddress), contractAddress, value, gas, evm.GasPrice, callArguments), + types.NewTransaction(e.NonceAt(creatorAddress), contractAddress, value, gas, e.MustGetGasPrice(), callArguments), e.Signer(), creator, ) @@ -328,7 +332,7 @@ func (e *Env) TestRPCInvalidNonce() { // try sending correct nonces in invalid order 1,2, then 0 - this should succeed createTx := func(nonce uint64) *types.Transaction { tx, err := types.SignTx( - types.NewTransaction(nonce, toAddress, big.NewInt(0), math.MaxUint64, evm.GasPrice, nil), + types.NewTransaction(nonce, toAddress, big.NewInt(0), math.MaxUint64, e.MustGetGasPrice(), nil), e.Signer(), from, ) @@ -358,7 +362,7 @@ func (e *Env) TestRPCGasLimitTooLow() { nonce := e.NonceAt(fromAddress) gasLimit := uint64(1) // lower than intrinsic gas tx, err := types.SignTx( - types.NewTransaction(nonce, toAddress, value, gasLimit, evm.GasPrice, nil), + types.NewTransaction(nonce, toAddress, value, gasLimit, e.MustGetGasPrice(), nil), e.Signer(), from, ) @@ -372,8 +376,7 @@ func (e *Env) TestRPCGasLimitTooLow() { } func (e *Env) TestGasPrice() { - gasPrice, err := e.Client.SuggestGasPrice(context.Background()) - require.NoError(e.T, err) + gasPrice := e.MustGetGasPrice() require.NotZero(e.T, gasPrice.Uint64()) } diff --git a/packages/evm/jsonrpc/jsonrpctest/jsonrpc_test.go b/packages/evm/jsonrpc/jsonrpctest/jsonrpc_test.go index e1374dd33e..44a03c3407 100644 --- a/packages/evm/jsonrpc/jsonrpctest/jsonrpc_test.go +++ b/packages/evm/jsonrpc/jsonrpctest/jsonrpc_test.go @@ -277,7 +277,7 @@ func TestRPCSignTransaction(t *testing.T) { From: ethAddr, To: &to, Gas: &gas, - GasPrice: (*hexutil.Big)(evm.GasPrice), + GasPrice: (*hexutil.Big)(big.NewInt(1000)), Value: (*hexutil.Big)(big.NewInt(42)), Nonce: &nonce, }) @@ -304,7 +304,7 @@ func TestRPCSendTransaction(t *testing.T) { txHash := env.MustSendTransaction(&jsonrpc.SendTxArgs{ From: ethAddr, Gas: &gas, - GasPrice: (*hexutil.Big)(evm.GasPrice), + GasPrice: (*hexutil.Big)(env.MustGetGasPrice()), Nonce: &nonce, Data: (*hexutil.Bytes)(&data), }) @@ -406,7 +406,7 @@ func TestRPCLogIndex(t *testing.T) { value := big.NewInt(0) gas := uint64(100_000) tx, err := types.SignTx( - types.NewTransaction(env.NonceAt(creatorAddress), contractAddress, value, gas, evm.GasPrice, callArguments), + types.NewTransaction(env.NonceAt(creatorAddress), contractAddress, value, gas, env.MustGetGasPrice(), callArguments), env.Signer(), creator, ) @@ -443,7 +443,7 @@ func TestRPCTxRejectedIfNotEnoughFunds(t *testing.T) { value := big.NewInt(0) gasLimit := uint64(10_000) tx, err := types.SignTx( - types.NewContractCreation(nonce, value, gasLimit, evm.GasPrice, data), + types.NewContractCreation(nonce, value, gasLimit, env.MustGetGasPrice(), data), env.Signer(), creator, ) diff --git a/packages/evm/jsonrpc/types.go b/packages/evm/jsonrpc/types.go index 26d0a10212..f0f0c182ac 100644 --- a/packages/evm/jsonrpc/types.go +++ b/packages/evm/jsonrpc/types.go @@ -19,7 +19,6 @@ import ( iotago "github.com/iotaledger/iota.go/v3" "github.com/iotaledger/wasp/packages/evm/evmutil" - "github.com/iotaledger/wasp/packages/vm/core/evm" ) // RPCTransaction represents a transaction that will serialize to the RPC representation of a transaction @@ -238,7 +237,7 @@ type SendTxArgs struct { // setDefaults is a helper function that fills in default values for unspecified tx fields. func (args *SendTxArgs) setDefaults(e *EthService) error { if args.GasPrice == nil { - args.GasPrice = (*hexutil.Big)(evm.GasPrice) + args.GasPrice = (*hexutil.Big)(e.evmChain.GasPrice()) } if args.Value == nil { args.Value = new(hexutil.Big) diff --git a/packages/isc/request.go b/packages/isc/request.go index b772ccf865..f75403c95f 100644 --- a/packages/isc/request.go +++ b/packages/isc/request.go @@ -5,6 +5,8 @@ import ( "io" "time" + "github.com/ethereum/go-ethereum/core/types" + iotago "github.com/iotaledger/iota.go/v3" "github.com/iotaledger/wasp/packages/cryptolib" "github.com/iotaledger/wasp/packages/hashing" @@ -57,6 +59,7 @@ type OffLedgerRequest interface { ChainID() ChainID Nonce() uint64 VerifySignature() error + EVMTransaction() *types.Transaction } type OnLedgerRequest interface { diff --git a/packages/isc/request_evmcall.go b/packages/isc/request_evmcall.go index 2273ce3e0b..bcd3d170f5 100644 --- a/packages/isc/request_evmcall.go +++ b/packages/isc/request_evmcall.go @@ -6,6 +6,7 @@ import ( "io" "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/core/types" iotago "github.com/iotaledger/iota.go/v3" "github.com/iotaledger/wasp/packages/evm/evmtypes" @@ -122,3 +123,7 @@ func (req *evmOffLedgerCallRequest) TargetAddress() iotago.Address { func (req *evmOffLedgerCallRequest) VerifySignature() error { return fmt.Errorf("%T should never be used to send regular requests", req) } + +func (*evmOffLedgerCallRequest) EVMTransaction() *types.Transaction { + return nil +} diff --git a/packages/isc/request_evmtx.go b/packages/isc/request_evmtx.go index 2cf9ad2a54..5ade9724b8 100644 --- a/packages/isc/request_evmtx.go +++ b/packages/isc/request_evmtx.go @@ -148,3 +148,7 @@ func (req *evmOffLedgerTxRequest) VerifySignature() error { } return nil } + +func (req *evmOffLedgerTxRequest) EVMTransaction() *types.Transaction { + return req.tx +} diff --git a/packages/isc/request_offledger.go b/packages/isc/request_offledger.go index 5726884a99..72f6d6ae7d 100644 --- a/packages/isc/request_offledger.go +++ b/packages/isc/request_offledger.go @@ -6,6 +6,8 @@ import ( "io" "time" + "github.com/ethereum/go-ethereum/core/types" + iotago "github.com/iotaledger/iota.go/v3" "github.com/iotaledger/wasp/packages/cryptolib" "github.com/iotaledger/wasp/packages/hashing" @@ -232,3 +234,7 @@ func (req *OffLedgerRequestData) WithSender(sender *cryptolib.PublicKey) Unsigne } return req } + +func (*OffLedgerRequestData) EVMTransaction() *types.Transaction { + return nil +} diff --git a/packages/testutil/testdbhash/TestStorageContract.hex b/packages/testutil/testdbhash/TestStorageContract.hex index 46f4f44737..2d02933c45 100644 --- a/packages/testutil/testdbhash/TestStorageContract.hex +++ b/packages/testutil/testdbhash/TestStorageContract.hex @@ -1 +1 @@ -0xab29bd35687b3fb2d8008be9b7beae844b93b647a3a397e535328f4a48795a4e +0x0db336907593bdd7de084b947deb51f85783b6774a189a5dbdd72843a588c84d diff --git a/packages/vm/core/accounts/impl_views.go b/packages/vm/core/accounts/impl_views.go index da99762004..a9157770fb 100644 --- a/packages/vm/core/accounts/impl_views.go +++ b/packages/vm/core/accounts/impl_views.go @@ -66,7 +66,7 @@ func viewAccounts(ctx isc.SandboxView) dict.Dict { // nonces are only sent with off-ledger requests func viewGetAccountNonce(ctx isc.SandboxView) dict.Dict { account := ctx.Params().MustGetAgentID(ParamAgentID, ctx.Caller()) - nonce := accountNonce(ctx.StateR(), account, ctx.ChainID()) + nonce := AccountNonce(ctx.StateR(), account, ctx.ChainID()) ret := dict.New() ret.Set(ParamAccountNonce, codec.EncodeUint64(nonce)) return ret diff --git a/packages/vm/core/accounts/nonce.go b/packages/vm/core/accounts/nonce.go index 3fa8510d0b..c8d21e97bb 100644 --- a/packages/vm/core/accounts/nonce.go +++ b/packages/vm/core/accounts/nonce.go @@ -1,8 +1,6 @@ package accounts import ( - "fmt" - "github.com/iotaledger/wasp/packages/isc" "github.com/iotaledger/wasp/packages/kv" "github.com/iotaledger/wasp/packages/kv/codec" @@ -12,8 +10,8 @@ func nonceKey(callerAgentID isc.AgentID, chainID isc.ChainID) kv.Key { return keyNonce + accountKey(callerAgentID, chainID) } -// Nonce returns the "total request count" for an account (it's the accountNonce that is expected in the next request) -func accountNonce(state kv.KVStoreReader, callerAgentID isc.AgentID, chainID isc.ChainID) uint64 { +// Nonce returns the "total request count" for an account (it's the AccountNonce that is expected in the next request) +func AccountNonce(state kv.KVStoreReader, callerAgentID isc.AgentID, chainID isc.ChainID) uint64 { if callerAgentID.Kind() == isc.AgentIDKindEthereumAddress { panic("to get EVM nonce, call EVM contract") } @@ -29,17 +27,6 @@ func IncrementNonce(state kv.KVStore, callerAgentID isc.AgentID, chainID isc.Cha // don't update EVM nonces return } - next := accountNonce(state, callerAgentID, chainID) + next := AccountNonce(state, callerAgentID, chainID) state.Set(nonceKey(callerAgentID, chainID), codec.EncodeUint64(next)) } - -func CheckNonce(state kv.KVStoreReader, agentID isc.AgentID, nonce uint64, chainID isc.ChainID) error { - if agentID.Kind() == isc.AgentIDKindEthereumAddress { - panic("to get EVM nonce, call EVM contract") - } - expected := accountNonce(state, agentID, chainID) - if nonce != expected { - return fmt.Errorf("invalid nonce, expected %d, got %d", expected, nonce) - } - return nil -} diff --git a/packages/vm/core/accounts/stateaccess.go b/packages/vm/core/accounts/stateaccess.go index 5b8913de00..09b3c09c2d 100644 --- a/packages/vm/core/accounts/stateaccess.go +++ b/packages/vm/core/accounts/stateaccess.go @@ -22,7 +22,7 @@ func NewStateAccess(store kv.KVStoreReader) *StateAccess { } func (sa *StateAccess) Nonce(agentID isc.AgentID, chainID isc.ChainID) uint64 { - return accountNonce(sa.state, agentID, chainID) + return AccountNonce(sa.state, agentID, chainID) } func (sa *StateAccess) AccountExists(agentID isc.AgentID, chainID isc.ChainID) bool { diff --git a/packages/vm/core/evm/emulator/emulator_test.go b/packages/vm/core/evm/emulator/emulator_test.go index 0e44572b57..059c323f55 100644 --- a/packages/vm/core/evm/emulator/emulator_test.go +++ b/packages/vm/core/evm/emulator/emulator_test.go @@ -69,6 +69,8 @@ var gasLimits = GasLimits{ Call: gas.EVMCallGasLimit(gas.LimitsDefault, &util.Ratio32{A: 1, B: 1}), } +var gasPrice = big.NewInt(0) // ignored in the emulator + func estimateGas(callMsg ethereum.CallMsg, e *EVMEmulator) (uint64, error) { lo := params.TxGas hi := gasLimits.Call @@ -122,7 +124,7 @@ func sendTransaction( nonce := emu.StateDB().GetNonce(senderAddress) tx, err := types.SignTx( - types.NewTransaction(nonce, receiverAddress, amount, gasLimit, evm.GasPrice, data), + types.NewTransaction(nonce, receiverAddress, amount, gasLimit, gasPrice, data), emu.Signer(), sender, ) @@ -366,7 +368,7 @@ func deployEVMContract(t testing.TB, emu *EVMEmulator, creator *ecdsa.PrivateKey require.NoError(t, err) tx, err := types.SignTx( - types.NewContractCreation(nonce, txValue, gasLimit, evm.GasPrice, data), + types.NewContractCreation(nonce, txValue, gasLimit, gasPrice, data), emu.Signer(), creator, ) @@ -659,7 +661,7 @@ func initBenchmark(b *testing.B) (*EVMEmulator, []*types.Transaction, *context) gasLimit := uint64(100000) txs[i], err = types.SignTx( - types.NewTransaction(nonce, contractAddress, amount, gasLimit, evm.GasPrice, callArguments), + types.NewTransaction(nonce, contractAddress, amount, gasLimit, gasPrice, callArguments), emu.Signer(), sender, ) diff --git a/packages/vm/core/evm/evmimpl/external.go b/packages/vm/core/evm/evmimpl/external.go index e8b3234338..d59070877a 100644 --- a/packages/vm/core/evm/evmimpl/external.go +++ b/packages/vm/core/evm/evmimpl/external.go @@ -1,8 +1,6 @@ package evmimpl import ( - "fmt" - "github.com/ethereum/go-ethereum/common" "github.com/iotaledger/wasp/packages/kv" @@ -15,11 +13,3 @@ func Nonce(evmPartition kv.KVStoreReader, addr common.Address) uint64 { stateDBStore := emulator.StateDBSubrealmR(emuState) return emulator.GetNonce(stateDBStore, addr) } - -func CheckNonce(evmPartition kv.KVStore, addr common.Address, nonce uint64) error { - expected := Nonce(evmPartition, addr) - if nonce != expected { - return fmt.Errorf("Invalid nonce (%s) expected %d, got %d", addr, expected, nonce) - } - return nil -} diff --git a/packages/vm/core/evm/evmtest/evm_test.go b/packages/vm/core/evm/evmtest/evm_test.go index 42bad95b76..b0be6b057c 100644 --- a/packages/vm/core/evm/evmtest/evm_test.go +++ b/packages/vm/core/evm/evmtest/evm_test.go @@ -42,7 +42,6 @@ import ( "github.com/iotaledger/wasp/packages/util" "github.com/iotaledger/wasp/packages/vm" "github.com/iotaledger/wasp/packages/vm/core/accounts" - "github.com/iotaledger/wasp/packages/vm/core/evm" "github.com/iotaledger/wasp/packages/vm/core/evm/iscmagic" "github.com/iotaledger/wasp/packages/vm/gas" ) @@ -390,10 +389,9 @@ func TestCallViewGasLimit(t *testing.T) { require.NoError(t, err) senderAddress := crypto.PubkeyToAddress(loop.defaultSender.PublicKey) callMsg := loop.callMsg(ethereum.CallMsg{ - From: senderAddress, - Gas: math.MaxUint64, - GasPrice: evm.GasPrice, - Data: callArguments, + From: senderAddress, + Gas: math.MaxUint64, + Data: callArguments, }) _, err = loop.chain.evmChain.CallContract(callMsg, nil) require.Contains(t, err.Error(), "out of gas") @@ -1494,17 +1492,14 @@ func TestEVMWithdrawAll(t *testing.T) { require.EqualValues(t, tokensToWithdraw, env.solo.L1BaseTokens(receiver)) } -func TestEVMNonZeroGasPriceRequest(t *testing.T) { +func TestEVMGasPriceMismatch(t *testing.T) { env := initEVM(t) ethKey, senderAddress := env.soloChain.NewEthereumAccountWithL2Funds() // deploy solidity `storage` contract storage := env.deployStorageContract(ethKey) - // call FuncCallView to call EVM contract's `retrieve` view, get 42 - require.EqualValues(t, 42, storage.retrieve()) - - // issue a tx with non-0 gas price + // issue a tx with an arbitrary gas price valueToStore := uint32(888) gasPrice := big.NewInt(1234) // non 0 callArguments, err := storage.abi.Pack("store", valueToStore) @@ -1516,18 +1511,7 @@ func TestEVMNonZeroGasPriceRequest(t *testing.T) { require.NoError(t, err) err = storage.chain.evmChain.SendTransaction(tx) - require.NoError(t, err) - - rec := env.soloChain.LastReceipt() - - require.EqualValues(t, valueToStore, storage.retrieve()) - - // assert the gas fee is the same as a normal request (with 0 gas price) - res, err := storage.store(999) - require.NoError(t, err) - require.EqualValues(t, 999, storage.retrieve()) - require.Equal(t, res.iscReceipt.GasBurned, rec.GasBurned) - require.Equal(t, res.iscReceipt.GasFeeCharged, rec.GasFeeCharged) + require.ErrorContains(t, err, "invalid gas price") } func TestEVMTransferBaseTokens(t *testing.T) { @@ -1538,7 +1522,7 @@ func TestEVMTransferBaseTokens(t *testing.T) { sendTx := func(amount *big.Int) { nonce := env.getNonce(ethAddr) - unsignedTx := types.NewTransaction(nonce, someEthereumAddr, amount, env.maxGasLimit(), util.Big0, []byte{}) + unsignedTx := types.NewTransaction(nonce, someEthereumAddr, amount, env.maxGasLimit(), env.evmChain.GasPrice(), []byte{}) tx, err := types.SignTx(unsignedTx, evmutil.Signer(big.NewInt(int64(env.evmChainID))), ethKey) require.NoError(t, err) err = env.evmChain.SendTransaction(tx) @@ -1664,7 +1648,7 @@ func TestSendEntireBalance(t *testing.T) { testparameters.GetL1ParamsForTesting().BaseToken.Decimals, ) - unsignedTx := types.NewTransaction(0, someEthereumAddr, initialBalanceInEthDecimals, env.maxGasLimit(), util.Big0, []byte{}) + unsignedTx := types.NewTransaction(0, someEthereumAddr, initialBalanceInEthDecimals, env.maxGasLimit(), env.evmChain.GasPrice(), []byte{}) tx, err := types.SignTx(unsignedTx, evmutil.Signer(big.NewInt(int64(env.evmChainID))), ethKey) require.NoError(t, err) err = env.evmChain.SendTransaction(tx) @@ -1685,11 +1669,10 @@ func TestSendEntireBalance(t *testing.T) { ) estimatedGas, err := env.evmChain.EstimateGas(ethereum.CallMsg{ - From: ethAddr, - To: &someEthereumAddr, - GasPrice: evm.GasPrice, - Value: currentBalanceInEthDecimals, - Data: []byte{}, + From: ethAddr, + To: &someEthereumAddr, + Value: currentBalanceInEthDecimals, + Data: []byte{}, }, nil) require.NoError(t, err) @@ -1702,7 +1685,7 @@ func TestSendEntireBalance(t *testing.T) { currentBalance-tokensForGasBudget, testparameters.GetL1ParamsForTesting().BaseToken.Decimals, ) - unsignedTx = types.NewTransaction(1, someEthereumAddr, valueToSendInEthDecimals, gasLimit, util.Big0, []byte{}) + unsignedTx = types.NewTransaction(1, someEthereumAddr, valueToSendInEthDecimals, gasLimit, env.evmChain.GasPrice(), []byte{}) tx, err = types.SignTx(unsignedTx, evmutil.Signer(big.NewInt(int64(env.evmChainID))), ethKey) require.NoError(t, err) err = env.evmChain.SendTransaction(tx) @@ -1862,11 +1845,10 @@ func TestChangeGasPerToken(t *testing.T) { require.Greater(t, fee2, fee) } -func TestGasPriceIgnored(t *testing.T) { +func TestGasPriceIgnoredInEstimateGas(t *testing.T) { env := initEVM(t) var gasLimit []uint64 - var gasUsed []uint64 for _, gasPrice := range []*big.Int{ nil, @@ -1884,22 +1866,12 @@ func TestGasPriceIgnored(t *testing.T) { }}, "store", uint32(3)) require.NoError(t, err) - res, err := storage.store(uint32(3), ethCallOptions{ - sender: ethKey, - gasLimit: gas, - gasPrice: gasPrice, - }) - require.NoError(t, err) - gasLimit = append(gasLimit, gas) - gasUsed = append(gasUsed, res.evmReceipt.GasUsed) }) } t.Log("gas limit", gasLimit) - t.Log("gas used", gasUsed) require.Len(t, lo.Uniq(gasLimit), 1) - require.Len(t, lo.Uniq(gasUsed), 1) } // calling views via eth_call must not cost gas (still has a maximum budget, but simple view calls should pass) diff --git a/packages/vm/core/evm/evmtest/utils_test.go b/packages/vm/core/evm/evmtest/utils_test.go index 6448da0af9..11004c2d82 100644 --- a/packages/vm/core/evm/evmtest/utils_test.go +++ b/packages/vm/core/evm/evmtest/utils_test.go @@ -319,15 +319,14 @@ func (e *soloChainEnv) deployContract(creator *ecdsa.PrivateKey, abiJSON string, value := big.NewInt(0) gasLimit, err := e.evmChain.EstimateGas(ethereum.CallMsg{ - From: creatorAddress, - GasPrice: evm.GasPrice, - Value: value, - Data: data, + From: creatorAddress, + Value: value, + Data: data, }, nil) require.NoError(e.t, err) tx, err := types.SignTx( - types.NewContractCreation(nonce, value, gasLimit, evm.GasPrice, data), + types.NewContractCreation(nonce, value, gasLimit, e.evmChain.GasPrice(), data), e.signer(), creator, ) @@ -425,7 +424,7 @@ func (e *evmContractInstance) parseEthCallOptions(opts []ethCallOptions, callDat opt.value = big.NewInt(0) } if opt.gasPrice == nil { - opt.gasPrice = evm.GasPrice + opt.gasPrice = e.chain.evmChain.GasPrice() } if opt.gasLimit == 0 { var err error @@ -509,10 +508,8 @@ func (e *evmContractInstance) callView(fnName string, args []interface{}, v inte require.NoError(e.chain.t, err) senderAddress := crypto.PubkeyToAddress(e.defaultSender.PublicKey) callMsg := e.callMsg(ethereum.CallMsg{ - From: senderAddress, - Gas: 0, - GasPrice: evm.GasPrice, - Data: callArguments, + From: senderAddress, + Data: callArguments, }) var bn *rpc.BlockNumberOrHash if len(blockNumberOrHash) > 0 { diff --git a/packages/vm/core/evm/interface.go b/packages/vm/core/evm/interface.go index 935db8d971..876a4c00b2 100644 --- a/packages/vm/core/evm/interface.go +++ b/packages/vm/core/evm/interface.go @@ -4,8 +4,6 @@ package evm import ( - "math/big" - "github.com/iotaledger/wasp/packages/isc/coreutil" "github.com/iotaledger/wasp/packages/vm/core/evm/evmnames" ) @@ -60,6 +58,3 @@ const ( // TODO shouldn't this be different between chain, to prevent replay attacks? (maybe derived from ISC ChainID) DefaultChainID = uint16(1074) // IOTA -- get it? ) - -// Gas is charged in isc VM (L1 currencies), not ETH -var GasPrice = big.NewInt(0) diff --git a/packages/vm/gas/feepolicy.go b/packages/vm/gas/feepolicy.go index bc82d57711..ab765f9ae0 100644 --- a/packages/vm/gas/feepolicy.go +++ b/packages/vm/gas/feepolicy.go @@ -3,6 +3,7 @@ package gas import ( "fmt" "io" + "math/big" "github.com/iotaledger/hive.go/serializer/v2" "github.com/iotaledger/wasp/packages/util" @@ -129,3 +130,23 @@ func (p *FeePolicy) Write(w io.Writer) error { ww.WriteUint8(p.ValidatorFeeShare) return ww.Err } + +// GasPriceWei returns the gas price converted to wei +func (p *FeePolicy) GasPriceWei(l1BaseTokenDecimals uint32) *big.Int { + // special case '0:0' for free request + if p.GasPerToken.IsZero() { + return big.NewInt(0) + } + + // convert to wei (18 decimals) + decimalsDifference := 18 - l1BaseTokenDecimals + price := big.NewInt(10) + price.Exp(price, new(big.Int).SetUint64(uint64(decimalsDifference)), nil) + + price.Mul(price, new(big.Int).SetUint64(uint64(p.GasPerToken.B))) + price.Div(price, new(big.Int).SetUint64(uint64(p.GasPerToken.A))) + price.Mul(price, new(big.Int).SetUint64(uint64(p.EVMGasRatio.A))) + price.Div(price, new(big.Int).SetUint64(uint64(p.EVMGasRatio.B))) + + return price +} diff --git a/packages/vm/vmimpl/skipreq.go b/packages/vm/vmimpl/skipreq.go index 9c2240e170..47793788e4 100644 --- a/packages/vm/vmimpl/skipreq.go +++ b/packages/vm/vmimpl/skipreq.go @@ -6,6 +6,7 @@ import ( "time" iotago "github.com/iotaledger/iota.go/v3" + "github.com/iotaledger/wasp/packages/evm/evmutil" "github.com/iotaledger/wasp/packages/isc" "github.com/iotaledger/wasp/packages/kv" "github.com/iotaledger/wasp/packages/vm/core/accounts" @@ -68,25 +69,35 @@ func (reqctx *requestContext) checkReasonToSkipOffLedger() error { return err } senderAccount := offledgerReq.SenderAccount() - reqNonce := offledgerReq.Nonce() - var nonceErr error + reqNonce := offledgerReq.Nonce() + var expectedNonce uint64 if evmAgentID, ok := senderAccount.(*isc.EthereumAddressAgentID); ok { withContractState(reqctx.uncommittedState, evm.Contract, func(s kv.KVStore) { - nonceErr = evmimpl.CheckNonce(s, evmAgentID.EthAddress(), reqNonce) + expectedNonce = evmimpl.Nonce(s, evmAgentID.EthAddress()) + }) + } else { + withContractState(reqctx.uncommittedState, accounts.Contract, func(s kv.KVStore) { + expectedNonce = accounts.AccountNonce( + s, + senderAccount, + reqctx.ChainID(), + ) }) - return nonceErr } - - withContractState(reqctx.uncommittedState, accounts.Contract, func(s kv.KVStore) { - nonceErr = accounts.CheckNonce( - s, - senderAccount, - reqNonce, - reqctx.ChainID(), + if reqNonce != expectedNonce { + return fmt.Errorf( + "invalid nonce (%s): expected %d, got %d", + offledgerReq.SenderAccount(), expectedNonce, reqNonce, ) - }) - return nonceErr + } + + if evmTx := offledgerReq.EVMTransaction(); evmTx != nil { + if err := evmutil.CheckGasPrice(evmTx, reqctx.vm.chainInfo.GasFeePolicy); err != nil { + return err + } + } + return nil } // checkReasonToSkipOnLedger check reasons to skip UTXO request diff --git a/tools/cluster/tests/env.go b/tools/cluster/tests/env.go index 12803ccd9a..7a3b88ed3c 100644 --- a/tools/cluster/tests/env.go +++ b/tools/cluster/tests/env.go @@ -161,15 +161,14 @@ func (e *ChainEnv) DeploySolidityContract(creator *ecdsa.PrivateKey, abiJSON str jsonRPCClient := e.EVMJSONRPClient(0) // send request to node #0 gasLimit, err := jsonRPCClient.EstimateGas(context.Background(), ethereum.CallMsg{ - From: creatorAddress, - GasPrice: evm.GasPrice, - Value: value, - Data: data, + From: creatorAddress, + Value: value, + Data: data, }) require.NoError(e.t, err) tx, err := types.SignTx( - types.NewContractCreation(nonce, value, gasLimit, evm.GasPrice, data), + types.NewContractCreation(nonce, value, gasLimit, e.GetGasPriceEVM(), data), EVMSigner(), creator, ) @@ -191,6 +190,12 @@ func (e *ChainEnv) GetNonceEVM(addr common.Address) uint64 { return nonce } +func (e *ChainEnv) GetGasPriceEVM() *big.Int { + res, err := e.EVMJSONRPClient(0).SuggestGasPrice(context.Background()) + require.NoError(e.t, err) + return res +} + func (e *ChainEnv) EVMJSONRPClient(nodeIndex int) *ethclient.Client { return NewEVMJSONRPClient(e.t, e.Chain.ChainID.String(), e.Clu, nodeIndex) } diff --git a/tools/cluster/tests/pruning_test.go b/tools/cluster/tests/pruning_test.go index 80dcab5323..b84b2ea052 100644 --- a/tools/cluster/tests/pruning_test.go +++ b/tools/cluster/tests/pruning_test.go @@ -19,7 +19,6 @@ import ( "github.com/iotaledger/wasp/packages/testutil/testmisc" "github.com/iotaledger/wasp/packages/testutil/utxodb" "github.com/iotaledger/wasp/packages/vm/core/blocklog" - "github.com/iotaledger/wasp/packages/vm/core/evm" "github.com/iotaledger/wasp/tools/cluster/templates" ) @@ -72,7 +71,7 @@ func TestPruning(t *testing.T) { callArguments, err2 := storageContractABI.Pack("store", uint32(i)) require.NoError(t, err2) tx, err2 := types.SignTx( - types.NewTransaction(nonce+i, storageContractAddr, big.NewInt(0), 100000, evm.GasPrice, callArguments), + types.NewTransaction(nonce+i, storageContractAddr, big.NewInt(0), 100000, env.GetGasPriceEVM(), callArguments), EVMSigner(), evmPvtKey, ) diff --git a/tools/cluster/tests/spam_test.go b/tools/cluster/tests/spam_test.go index fce9bf85c6..638967bfb8 100644 --- a/tools/cluster/tests/spam_test.go +++ b/tools/cluster/tests/spam_test.go @@ -24,7 +24,6 @@ import ( "github.com/iotaledger/wasp/packages/solo" "github.com/iotaledger/wasp/packages/testutil" "github.com/iotaledger/wasp/packages/testutil/utxodb" - "github.com/iotaledger/wasp/packages/vm/core/evm" ) // executed in cluster_test.go @@ -268,7 +267,7 @@ func testSpamEVM(t *testing.T, env *ChainEnv) { callArguments, err2 := storageContractABI.Pack("store", uint32(i)) require.NoError(t, err2) tx, err2 := types.SignTx( - types.NewTransaction(nonce+i, storageContractAddr, big.NewInt(0), 100000, evm.GasPrice, callArguments), + types.NewTransaction(nonce+i, storageContractAddr, big.NewInt(0), 100000, env.GetGasPriceEVM(), callArguments), EVMSigner(), evmPvtKey, ) diff --git a/tools/cluster/tests/wasp-cli_test.go b/tools/cluster/tests/wasp-cli_test.go index b65f7e7481..1aac057070 100644 --- a/tools/cluster/tests/wasp-cli_test.go +++ b/tools/cluster/tests/wasp-cli_test.go @@ -20,10 +20,10 @@ import ( iotago "github.com/iotaledger/iota.go/v3" "github.com/iotaledger/wasp/clients/apiclient" "github.com/iotaledger/wasp/packages/kv/codec" + "github.com/iotaledger/wasp/packages/parameters" "github.com/iotaledger/wasp/packages/vm/core/accounts" "github.com/iotaledger/wasp/packages/vm/core/blob" "github.com/iotaledger/wasp/packages/vm/core/blocklog" - "github.com/iotaledger/wasp/packages/vm/core/evm" "github.com/iotaledger/wasp/packages/vm/gas" "github.com/iotaledger/wasp/packages/vm/vmtypes" "github.com/iotaledger/wasp/tools/cluster/templates" @@ -848,9 +848,10 @@ func TestEVMISCReceipt(t *testing.T) { w.MustRun("chain", "deposit", ethAddr.String(), "base:100000000", "--node=0") // send some arbitrary EVM tx + gasPrice := gas.DefaultFeePolicy().GasPriceWei(parameters.L1().BaseToken.Decimals) jsonRPCClient := NewEVMJSONRPClient(t, w.ChainID(0), w.Cluster, 0) tx, err := types.SignTx( - types.NewTransaction(0, ethAddr, big.NewInt(123), 100000, evm.GasPrice, []byte{}), + types.NewTransaction(0, ethAddr, big.NewInt(123), 100000, gasPrice, []byte{}), EVMSigner(), ethPvtKey, )