2020-04-17 22:32:01 +00:00
|
|
|
|
package ante
|
|
|
|
|
|
|
|
|
|
import (
|
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
|
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
|
|
|
|
|
authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
|
2021-06-15 07:19:31 +00:00
|
|
|
|
"github.com/palantir/stacktrace"
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-06-14 14:24:08 +00:00
|
|
|
|
ethermint "github.com/cosmos/ethermint/types"
|
2020-04-17 22:32:01 +00:00
|
|
|
|
evmtypes "github.com/cosmos/ethermint/x/evm/types"
|
|
|
|
|
|
2020-06-22 16:07:35 +00:00
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2021-05-10 16:34:00 +00:00
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
|
ethtypes "github.com/ethereum/go-ethereum/core/types"
|
2021-06-02 08:52:53 +00:00
|
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2020-04-17 22:32:01 +00:00
|
|
|
|
)
|
|
|
|
|
|
2020-09-02 19:41:05 +00:00
|
|
|
|
// EVMKeeper defines the expected keeper interface used on the Eth AnteHandler
|
|
|
|
|
type EVMKeeper interface {
|
2021-06-02 08:52:53 +00:00
|
|
|
|
vm.StateDB
|
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
ChainID() *big.Int
|
2020-09-02 19:41:05 +00:00
|
|
|
|
GetParams(ctx sdk.Context) evmtypes.Params
|
2021-05-10 16:34:00 +00:00
|
|
|
|
GetChainConfig(ctx sdk.Context) (evmtypes.ChainConfig, bool)
|
2021-05-25 12:56:36 +00:00
|
|
|
|
WithContext(ctx sdk.Context)
|
|
|
|
|
ResetRefundTransient(ctx sdk.Context)
|
2021-06-02 08:52:53 +00:00
|
|
|
|
NewEVM(msg core.Message, config *params.ChainConfig) *vm.EVM
|
2020-09-02 19:41:05 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-02 08:52:53 +00:00
|
|
|
|
// EthSigVerificationDecorator validates an ethereum signatures
|
2021-04-18 16:39:15 +00:00
|
|
|
|
type EthSigVerificationDecorator struct {
|
2021-05-10 16:34:00 +00:00
|
|
|
|
evmKeeper EVMKeeper
|
2021-04-18 16:39:15 +00:00
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
|
|
|
|
// NewEthSigVerificationDecorator creates a new EthSigVerificationDecorator
|
2021-05-10 16:34:00 +00:00
|
|
|
|
func NewEthSigVerificationDecorator(ek EVMKeeper) EthSigVerificationDecorator {
|
|
|
|
|
return EthSigVerificationDecorator{
|
|
|
|
|
evmKeeper: ek,
|
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// AnteHandle validates checks that the registered chain id is the same as the one on the message, and
|
|
|
|
|
// that the signer address matches the one defined on the message.
|
2020-04-17 22:32:01 +00:00
|
|
|
|
func (esvd EthSigVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// no need to verify signatures on recheck tx
|
|
|
|
|
if ctx.IsReCheckTx() {
|
2021-04-18 16:39:15 +00:00
|
|
|
|
return next(ctx, tx, simulate)
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-11 13:38:51 +00:00
|
|
|
|
if len(tx.GetMsgs()) != 1 {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "only 1 ethereum msg supported per tx, got %d", len(tx.GetMsgs())),
|
|
|
|
|
"",
|
|
|
|
|
)
|
2021-06-11 13:38:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// get and set account must be called with an infinite gas meter in order to prevent
|
|
|
|
|
// additional gas from being deducted.
|
|
|
|
|
infCtx := ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
chainID := esvd.evmKeeper.ChainID()
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
config, found := esvd.evmKeeper.GetChainConfig(infCtx)
|
2021-05-10 16:34:00 +00:00
|
|
|
|
if !found {
|
|
|
|
|
return ctx, evmtypes.ErrChainConfigNotFound
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
ethCfg := config.EthereumConfig(chainID)
|
2021-05-10 16:34:00 +00:00
|
|
|
|
blockNum := big.NewInt(ctx.BlockHeight())
|
|
|
|
|
signer := ethtypes.MakeSigner(ethCfg, blockNum)
|
|
|
|
|
|
2021-06-11 13:38:51 +00:00
|
|
|
|
msg := tx.GetMsgs()[0]
|
|
|
|
|
msgEthTx, ok := msg.(*evmtypes.MsgEthereumTx)
|
|
|
|
|
if !ok {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid transaction type %T, expected %T", tx, &evmtypes.MsgEthereumTx{}),
|
|
|
|
|
"failed to cast transaction",
|
|
|
|
|
)
|
2021-06-11 13:38:51 +00:00
|
|
|
|
}
|
2021-05-10 16:34:00 +00:00
|
|
|
|
|
2021-06-11 13:38:51 +00:00
|
|
|
|
sender, err := signer.Sender(msgEthTx.AsTransaction())
|
|
|
|
|
if err != nil {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrap(sdkerrors.ErrorInvalidSigner, err.Error()),
|
|
|
|
|
"couldn't retrieve sender address ('%s') from the ethereum transaction",
|
|
|
|
|
msgEthTx.From,
|
|
|
|
|
)
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-11 13:38:51 +00:00
|
|
|
|
// set up the sender to the transaction field if not already
|
|
|
|
|
msgEthTx.From = sender.Hex()
|
|
|
|
|
|
|
|
|
|
return next(ctx, msgEthTx, simulate)
|
2021-04-18 16:39:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// EthAccountVerificationDecorator validates an account balance checks
|
|
|
|
|
type EthAccountVerificationDecorator struct {
|
2021-04-17 10:00:07 +00:00
|
|
|
|
ak AccountKeeper
|
|
|
|
|
bankKeeper BankKeeper
|
|
|
|
|
evmKeeper EVMKeeper
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-18 16:39:15 +00:00
|
|
|
|
// NewEthAccountVerificationDecorator creates a new EthAccountVerificationDecorator
|
|
|
|
|
func NewEthAccountVerificationDecorator(ak AccountKeeper, bankKeeper BankKeeper, ek EVMKeeper) EthAccountVerificationDecorator {
|
|
|
|
|
return EthAccountVerificationDecorator{
|
2021-04-17 10:00:07 +00:00
|
|
|
|
ak: ak,
|
|
|
|
|
bankKeeper: bankKeeper,
|
|
|
|
|
evmKeeper: ek,
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-02 08:52:53 +00:00
|
|
|
|
// AnteHandle validates checks that the sender balance is greater than the total transaction cost.
|
|
|
|
|
// The account will be set to store if it doesn't exis, i.e cannot be found on store.
|
|
|
|
|
// This AnteHandler decorator will fail if:
|
|
|
|
|
// - any of the msgs is not a MsgEthereumTx
|
|
|
|
|
// - from address is empty
|
|
|
|
|
// - account balance is lower than the transaction cost
|
2021-04-18 16:39:15 +00:00
|
|
|
|
func (avd EthAccountVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
|
2020-04-17 22:32:01 +00:00
|
|
|
|
if !ctx.IsCheckTx() {
|
|
|
|
|
return next(ctx, tx, simulate)
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// get and set account must be called with an infinite gas meter in order to prevent
|
|
|
|
|
// additional gas from being deducted.
|
|
|
|
|
infCtx := ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
evmDenom := avd.evmKeeper.GetParams(infCtx).EvmDenom
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-06-15 07:19:31 +00:00
|
|
|
|
for i, msg := range tx.GetMsgs() {
|
2021-05-31 09:05:32 +00:00
|
|
|
|
msgEthTx, ok := msg.(*evmtypes.MsgEthereumTx)
|
|
|
|
|
if !ok {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid transaction type %T, expected %T", tx, &evmtypes.MsgEthereumTx{}),
|
|
|
|
|
"failed to cast transaction %d", i,
|
|
|
|
|
)
|
2021-05-31 09:05:32 +00:00
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// sender address should be in the tx cache from the previous AnteHandle call
|
|
|
|
|
from := msgEthTx.GetFrom()
|
|
|
|
|
if from.Empty() {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "from address cannot be empty"),
|
|
|
|
|
"sender address should have been in the tx field from the previous AnteHandle call",
|
|
|
|
|
)
|
2021-05-31 09:05:32 +00:00
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
acc := avd.ak.GetAccount(infCtx, from)
|
|
|
|
|
if acc == nil {
|
2021-06-02 08:52:53 +00:00
|
|
|
|
acc = avd.ak.NewAccountWithAddress(infCtx, from)
|
|
|
|
|
avd.ak.SetAccount(infCtx, acc)
|
2021-05-31 09:05:32 +00:00
|
|
|
|
}
|
2020-09-02 19:41:05 +00:00
|
|
|
|
|
2021-06-15 07:19:31 +00:00
|
|
|
|
// validate sender has enough funds to pay for tx cost
|
2021-05-31 09:05:32 +00:00
|
|
|
|
balance := avd.bankKeeper.GetBalance(infCtx, from, evmDenom)
|
|
|
|
|
if balance.Amount.BigInt().Cmp(msgEthTx.Cost()) < 0 {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(
|
|
|
|
|
sdkerrors.ErrInsufficientFunds,
|
|
|
|
|
"sender balance < tx cost (%s < %s%s)", balance, msgEthTx.Cost(), evmDenom,
|
|
|
|
|
),
|
|
|
|
|
"sender should have had enough funds to pay for tx cost = fee + amount (%s = %s + amount)", msgEthTx.Cost(), msgEthTx.Fee(),
|
2021-05-31 09:05:32 +00:00
|
|
|
|
)
|
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return next(ctx, tx, simulate)
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-18 16:39:15 +00:00
|
|
|
|
// EthNonceVerificationDecorator checks that the account nonce from the transaction matches
|
2020-05-04 22:41:17 +00:00
|
|
|
|
// the sender account sequence.
|
2021-04-18 16:39:15 +00:00
|
|
|
|
type EthNonceVerificationDecorator struct {
|
2021-04-17 10:00:07 +00:00
|
|
|
|
ak AccountKeeper
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-18 16:39:15 +00:00
|
|
|
|
// NewEthNonceVerificationDecorator creates a new EthNonceVerificationDecorator
|
|
|
|
|
func NewEthNonceVerificationDecorator(ak AccountKeeper) EthNonceVerificationDecorator {
|
|
|
|
|
return EthNonceVerificationDecorator{
|
2020-04-17 22:32:01 +00:00
|
|
|
|
ak: ak,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-02 08:52:53 +00:00
|
|
|
|
// AnteHandle validates that the transaction nonces are valid and equivalent to the sender account’s
|
|
|
|
|
// current nonce.
|
2021-04-18 16:39:15 +00:00
|
|
|
|
func (nvd EthNonceVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// no need to check the nonce on ReCheckTx
|
|
|
|
|
if ctx.IsReCheckTx() {
|
|
|
|
|
return next(ctx, tx, simulate)
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// get and set account must be called with an infinite gas meter in order to prevent
|
|
|
|
|
// additional gas from being deducted.
|
|
|
|
|
infCtx := ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-06-15 07:19:31 +00:00
|
|
|
|
for i, msg := range tx.GetMsgs() {
|
2021-05-31 09:05:32 +00:00
|
|
|
|
msgEthTx, ok := msg.(*evmtypes.MsgEthereumTx)
|
|
|
|
|
if !ok {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid transaction type %T, expected %T", tx, &evmtypes.MsgEthereumTx{}),
|
|
|
|
|
"failed to cast transaction %d", i,
|
|
|
|
|
)
|
2021-05-31 09:05:32 +00:00
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// sender address should be in the tx cache from the previous AnteHandle call
|
|
|
|
|
seq, err := nvd.ak.GetSequence(infCtx, msgEthTx.GetFrom())
|
|
|
|
|
if err != nil {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(err, "sequence not found for address %s", msgEthTx.From)
|
2021-05-31 09:05:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// if multiple transactions are submitted in succession with increasing nonces,
|
|
|
|
|
// all will be rejected except the first, since the first needs to be included in a block
|
|
|
|
|
// before the sequence increments
|
|
|
|
|
if msgEthTx.Data.Nonce != seq {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(
|
|
|
|
|
sdkerrors.ErrInvalidSequence,
|
|
|
|
|
"invalid nonce; got %d, expected %d", msgEthTx.Data.Nonce, seq,
|
|
|
|
|
),
|
|
|
|
|
"",
|
2021-05-31 09:05:32 +00:00
|
|
|
|
)
|
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return next(ctx, tx, simulate)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// EthGasConsumeDecorator validates enough intrinsic gas for the transaction and
|
|
|
|
|
// gas consumption.
|
|
|
|
|
type EthGasConsumeDecorator struct {
|
2021-04-17 10:00:07 +00:00
|
|
|
|
ak AccountKeeper
|
|
|
|
|
bankKeeper BankKeeper
|
|
|
|
|
evmKeeper EVMKeeper
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// NewEthGasConsumeDecorator creates a new EthGasConsumeDecorator
|
2021-04-17 10:00:07 +00:00
|
|
|
|
func NewEthGasConsumeDecorator(ak AccountKeeper, bankKeeper BankKeeper, ek EVMKeeper) EthGasConsumeDecorator {
|
2020-04-17 22:32:01 +00:00
|
|
|
|
return EthGasConsumeDecorator{
|
2021-04-17 10:00:07 +00:00
|
|
|
|
ak: ak,
|
|
|
|
|
bankKeeper: bankKeeper,
|
|
|
|
|
evmKeeper: ek,
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// AnteHandle validates that the Ethereum tx message has enough to cover intrinsic gas
|
|
|
|
|
// (during CheckTx only) and that the sender has enough balance to pay for the gas cost.
|
|
|
|
|
//
|
2021-06-02 08:52:53 +00:00
|
|
|
|
// Intrinsic gas for a transaction is the amount of gas that the transaction uses before the
|
|
|
|
|
// transaction is executed. The gas is a constant value plus any cost inccured by additional bytes
|
|
|
|
|
// of data supplied with the transaction.
|
|
|
|
|
//
|
|
|
|
|
// This AnteHandler decorator will fail if:
|
|
|
|
|
// - the transaction contains more than one message
|
|
|
|
|
// - the message is not a MsgEthereumTx
|
|
|
|
|
// - sender account cannot be found
|
|
|
|
|
// - transaction's gas limit is lower than the intrinsic gas
|
|
|
|
|
// - user doesn't have enough balance to deduct the transaction fees (gas_limit * gas_price)
|
|
|
|
|
// - transaction or block gas meter runs out of gas
|
2020-04-17 22:32:01 +00:00
|
|
|
|
func (egcd EthGasConsumeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// get and set account must be called with an infinite gas meter in order to prevent
|
|
|
|
|
// additional gas from being deducted.
|
|
|
|
|
infCtx := ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-06-02 08:52:53 +00:00
|
|
|
|
// reset the refund gas value in the keeper for the current transaction
|
2021-05-31 09:05:32 +00:00
|
|
|
|
egcd.evmKeeper.ResetRefundTransient(infCtx)
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
config, found := egcd.evmKeeper.GetChainConfig(infCtx)
|
|
|
|
|
if !found {
|
|
|
|
|
return ctx, evmtypes.ErrChainConfigNotFound
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
ethCfg := config.EthereumConfig(egcd.evmKeeper.ChainID())
|
2021-05-10 16:34:00 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
blockHeight := big.NewInt(ctx.BlockHeight())
|
|
|
|
|
homestead := ethCfg.IsHomestead(blockHeight)
|
|
|
|
|
istanbul := ethCfg.IsIstanbul(blockHeight)
|
2021-05-10 16:34:00 +00:00
|
|
|
|
|
2021-06-15 07:19:31 +00:00
|
|
|
|
for i, msg := range tx.GetMsgs() {
|
2021-05-31 09:05:32 +00:00
|
|
|
|
msgEthTx, ok := msg.(*evmtypes.MsgEthereumTx)
|
|
|
|
|
if !ok {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid transaction type %T, expected %T", tx, &evmtypes.MsgEthereumTx{}),
|
|
|
|
|
"failed to cast transaction %d", i,
|
|
|
|
|
)
|
2021-05-31 09:05:32 +00:00
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
isContractCreation := msgEthTx.To() == nil
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// fetch sender account from signature
|
|
|
|
|
signerAcc, err := authante.GetSignerAcc(infCtx, egcd.ak, msgEthTx.GetFrom())
|
|
|
|
|
if err != nil {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(err, "account not found for sender %s", msgEthTx.From)
|
2021-05-31 09:05:32 +00:00
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
gasLimit := msgEthTx.GetGas()
|
2020-09-02 19:41:05 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
var accessList ethtypes.AccessList
|
|
|
|
|
if msgEthTx.Data.Accesses != nil {
|
|
|
|
|
accessList = *msgEthTx.Data.Accesses.ToEthAccessList()
|
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
intrinsicGas, err := core.IntrinsicGas(msgEthTx.Data.Input, accessList, isContractCreation, homestead, istanbul)
|
2020-04-17 22:32:01 +00:00
|
|
|
|
if err != nil {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrap(err, "failed to compute intrinsic gas cost"),
|
|
|
|
|
"failed to retrieve intrinsic gas, contract creation = %t; homestead = %t, istanbul = %t", isContractCreation, homestead, istanbul)
|
2021-05-31 09:05:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// intrinsic gas verification during CheckTx
|
|
|
|
|
if ctx.IsCheckTx() && gasLimit < intrinsicGas {
|
|
|
|
|
return ctx, sdkerrors.Wrapf(sdkerrors.ErrOutOfGas, "gas limit too low: %d (gas limit) < %d (intrinsic gas)", gasLimit, intrinsicGas)
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-02 08:52:53 +00:00
|
|
|
|
// calculate the fees paid to validators based on gas limit and price
|
|
|
|
|
feeAmt := msgEthTx.Fee() // fee = gas limit * gas price
|
2021-05-31 09:05:32 +00:00
|
|
|
|
|
|
|
|
|
evmDenom := egcd.evmKeeper.GetParams(infCtx).EvmDenom
|
2021-06-02 08:52:53 +00:00
|
|
|
|
fees := sdk.Coins{sdk.NewCoin(evmDenom, sdk.NewIntFromBigInt(feeAmt))}
|
2021-05-31 09:05:32 +00:00
|
|
|
|
|
|
|
|
|
// deduct the full gas cost from the user balance
|
2021-06-02 08:52:53 +00:00
|
|
|
|
if err := authante.DeductFees(egcd.bankKeeper, infCtx, signerAcc, fees); err != nil {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
err,
|
|
|
|
|
"failed to deduct full gas cost %s from the user %s balance", fees, msgEthTx.From,
|
|
|
|
|
)
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
2021-05-31 09:05:32 +00:00
|
|
|
|
|
|
|
|
|
// consume intrinsic gas for the current transaction. After runTx is executed on Baseapp, the
|
|
|
|
|
// application will consume gas from the block gas pool.
|
|
|
|
|
ctx.GasMeter().ConsumeGas(intrinsicGas, "intrinsic gas")
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-14 14:24:08 +00:00
|
|
|
|
// TODO: deprecate after https://github.com/cosmos/cosmos-sdk/issues/9514 is fixed on SDK
|
|
|
|
|
blockGasLimit := ethermint.BlockGasLimit(ctx)
|
|
|
|
|
|
|
|
|
|
// NOTE: safety check
|
|
|
|
|
if blockGasLimit > 0 {
|
|
|
|
|
// generate a copy of the gas pool (i.e block gas meter) to see if we've run out of gas for this block
|
|
|
|
|
// if current gas consumed is greater than the limit, this funcion panics and the error is recovered on the Baseapp
|
|
|
|
|
gasPool := sdk.NewGasMeter(blockGasLimit)
|
|
|
|
|
gasPool.ConsumeGas(ctx.GasMeter().GasConsumedToLimit(), "gas pool check")
|
|
|
|
|
}
|
2021-05-25 12:56:36 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// we know that we have enough gas on the pool to cover the intrinsic gas
|
|
|
|
|
// set up the updated context to the evm Keeper
|
|
|
|
|
egcd.evmKeeper.WithContext(ctx)
|
|
|
|
|
return next(ctx, tx, simulate)
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-02 08:52:53 +00:00
|
|
|
|
// CanTransferDecorator checks if the sender is allowed to transfer funds according to the EVM block
|
|
|
|
|
// context rules.
|
|
|
|
|
type CanTransferDecorator struct {
|
|
|
|
|
evmKeeper EVMKeeper
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// NewCanTransferDecorator creates a new CanTransferDecorator instance.
|
|
|
|
|
func NewCanTransferDecorator(evmKeeper EVMKeeper) CanTransferDecorator {
|
|
|
|
|
return CanTransferDecorator{
|
|
|
|
|
evmKeeper: evmKeeper,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// AnteHandle creates an EVM from the message and calls the BlockContext CanTransfer function to
|
|
|
|
|
// see if the address can execute the transaction.
|
|
|
|
|
func (ctd CanTransferDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
|
|
|
|
|
// get and set account must be called with an infinite gas meter in order to prevent
|
|
|
|
|
// additional gas from being deducted.
|
|
|
|
|
infCtx := ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
|
|
|
|
|
ctd.evmKeeper.WithContext(infCtx)
|
|
|
|
|
|
|
|
|
|
config, found := ctd.evmKeeper.GetChainConfig(infCtx)
|
|
|
|
|
if !found {
|
|
|
|
|
return ctx, evmtypes.ErrChainConfigNotFound
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ethCfg := config.EthereumConfig(ctd.evmKeeper.ChainID())
|
2021-06-11 13:38:51 +00:00
|
|
|
|
signer := ethtypes.MakeSigner(ethCfg, big.NewInt(ctx.BlockHeight()))
|
2021-06-02 08:52:53 +00:00
|
|
|
|
|
2021-06-15 07:19:31 +00:00
|
|
|
|
for i, msg := range tx.GetMsgs() {
|
2021-06-02 08:52:53 +00:00
|
|
|
|
msgEthTx, ok := msg.(*evmtypes.MsgEthereumTx)
|
|
|
|
|
if !ok {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid transaction type %T, expected %T", tx, &evmtypes.MsgEthereumTx{}),
|
|
|
|
|
"failed to cast transaction %d", i,
|
|
|
|
|
)
|
2021-06-02 08:52:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-11 13:38:51 +00:00
|
|
|
|
coreMsg, err := msgEthTx.AsMessage(signer)
|
2021-06-02 08:52:53 +00:00
|
|
|
|
if err != nil {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
err,
|
|
|
|
|
"failed to create an ethereum core.Message from signer %T", signer,
|
|
|
|
|
)
|
2021-06-02 08:52:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
evm := ctd.evmKeeper.NewEVM(coreMsg, ethCfg)
|
|
|
|
|
|
|
|
|
|
// 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 coreMsg.Value().Sign() > 0 && !evm.Context.CanTransfer(ctd.evmKeeper, coreMsg.From(), coreMsg.Value()) {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrInsufficientFunds, "address %s", coreMsg.From()),
|
|
|
|
|
"failed to transfer %s using the EVM block context transfer function", coreMsg.Value(),
|
|
|
|
|
)
|
2021-06-02 08:52:53 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ctd.evmKeeper.WithContext(ctx)
|
|
|
|
|
|
|
|
|
|
// set the original gas meter
|
|
|
|
|
return next(ctx, tx, simulate)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// AccessListDecorator prepare an access list for the sender if Yolov3/Berlin/EIPs 2929 and 2930 are
|
|
|
|
|
// applicable at the current block number.
|
|
|
|
|
type AccessListDecorator struct {
|
|
|
|
|
evmKeeper EVMKeeper
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// NewAccessListDecorator creates a new AccessListDecorator.
|
|
|
|
|
func NewAccessListDecorator(evmKeeper EVMKeeper) AccessListDecorator {
|
|
|
|
|
return AccessListDecorator{
|
|
|
|
|
evmKeeper: evmKeeper,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// AnteHandle handles the preparatory steps for executing an EVM state transition with
|
|
|
|
|
// regards to both EIP-2929 and EIP-2930:
|
|
|
|
|
//
|
|
|
|
|
// - Add sender to access list (2929)
|
|
|
|
|
// - Add destination to access list (2929)
|
|
|
|
|
// - Add precompiles to access list (2929)
|
|
|
|
|
// - Add the contents of the optional tx access list (2930)
|
2020-04-17 22:32:01 +00:00
|
|
|
|
//
|
2021-06-02 08:52:53 +00:00
|
|
|
|
// The AnteHandler will only prepare the access list if Yolov3/Berlin/EIPs 2929 and 2930 are applicable at the current number.
|
|
|
|
|
func (ald AccessListDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
|
|
|
|
|
// get and set account must be called with an infinite gas meter in order to prevent
|
|
|
|
|
// additional gas from being deducted.
|
|
|
|
|
|
|
|
|
|
infCtx := ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
|
|
|
|
|
|
|
|
|
|
config, found := ald.evmKeeper.GetChainConfig(infCtx)
|
|
|
|
|
if !found {
|
|
|
|
|
return ctx, evmtypes.ErrChainConfigNotFound
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ethCfg := config.EthereumConfig(ald.evmKeeper.ChainID())
|
|
|
|
|
|
|
|
|
|
rules := ethCfg.Rules(big.NewInt(ctx.BlockHeight()))
|
|
|
|
|
|
|
|
|
|
// we don't need to prepare the access list if the chain is not currently on the Berlin upgrade
|
|
|
|
|
if !rules.IsBerlin {
|
|
|
|
|
return next(ctx, tx, simulate)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// setup the keeper context before setting the access list
|
|
|
|
|
ald.evmKeeper.WithContext(infCtx)
|
|
|
|
|
|
2021-06-15 07:19:31 +00:00
|
|
|
|
for i, msg := range tx.GetMsgs() {
|
2021-06-02 08:52:53 +00:00
|
|
|
|
msgEthTx, ok := msg.(*evmtypes.MsgEthereumTx)
|
|
|
|
|
if !ok {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid transaction type %T, expected %T", tx, &evmtypes.MsgEthereumTx{}),
|
|
|
|
|
"failed to cast transaction %d", i,
|
|
|
|
|
)
|
2021-06-02 08:52:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-11 13:38:51 +00:00
|
|
|
|
sender := common.BytesToAddress(msgEthTx.GetFrom())
|
2021-06-02 08:52:53 +00:00
|
|
|
|
|
2021-06-11 13:38:51 +00:00
|
|
|
|
ald.evmKeeper.PrepareAccessList(sender, msgEthTx.To(), vm.ActivePrecompiles(rules), *msgEthTx.Data.Accesses.ToEthAccessList())
|
2021-06-02 08:52:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// set the original gas meter
|
|
|
|
|
ald.evmKeeper.WithContext(ctx)
|
|
|
|
|
return next(ctx, tx, simulate)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// EthIncrementSenderSequenceDecorator increments the sequence of the signers.
|
2021-04-18 16:39:15 +00:00
|
|
|
|
type EthIncrementSenderSequenceDecorator struct {
|
2021-04-17 10:00:07 +00:00
|
|
|
|
ak AccountKeeper
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-18 16:39:15 +00:00
|
|
|
|
// NewEthIncrementSenderSequenceDecorator creates a new EthIncrementSenderSequenceDecorator.
|
|
|
|
|
func NewEthIncrementSenderSequenceDecorator(ak AccountKeeper) EthIncrementSenderSequenceDecorator {
|
|
|
|
|
return EthIncrementSenderSequenceDecorator{
|
2020-04-17 22:32:01 +00:00
|
|
|
|
ak: ak,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-02 08:52:53 +00:00
|
|
|
|
// AnteHandle handles incrementing the sequence of the signer (i.e sender). If the transaction is a
|
|
|
|
|
// contract creation, the nonce will be incremented during the transaction execution and not within
|
|
|
|
|
// this AnteHandler decorator.
|
2021-04-18 16:39:15 +00:00
|
|
|
|
func (issd EthIncrementSenderSequenceDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
|
2020-05-04 22:41:17 +00:00
|
|
|
|
// get and set account must be called with an infinite gas meter in order to prevent
|
|
|
|
|
// additional gas from being deducted.
|
2021-05-31 09:05:32 +00:00
|
|
|
|
infCtx := ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
|
|
|
|
|
|
2021-06-15 07:19:31 +00:00
|
|
|
|
for i, msg := range tx.GetMsgs() {
|
2021-06-02 08:52:53 +00:00
|
|
|
|
msgEthTx, ok := msg.(*evmtypes.MsgEthereumTx)
|
|
|
|
|
if !ok {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid transaction type %T, expected %T", tx, &evmtypes.MsgEthereumTx{}),
|
|
|
|
|
"failed to cast transaction %d", i,
|
|
|
|
|
)
|
2021-06-02 08:52:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// NOTE: on contract creation, the nonce is incremented within the EVM Create function during tx execution
|
|
|
|
|
// and not previous to the state transition ¯\_(ツ)_/¯
|
|
|
|
|
if msgEthTx.To() == nil {
|
|
|
|
|
// contract creation, don't increment sequence on AnteHandler but on tx execution
|
|
|
|
|
// continue to the next item
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
// increment sequence of all signers
|
|
|
|
|
for _, addr := range msg.GetSigners() {
|
|
|
|
|
acc := issd.ak.GetAccount(infCtx, addr)
|
2021-06-02 08:52:53 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
if acc == nil {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(
|
|
|
|
|
sdkerrors.Wrapf(
|
|
|
|
|
sdkerrors.ErrUnknownAddress,
|
|
|
|
|
"account %s (%s) is nil", common.BytesToAddress(addr.Bytes()), addr,
|
|
|
|
|
),
|
|
|
|
|
"signer account not found",
|
2021-05-31 09:05:32 +00:00
|
|
|
|
)
|
|
|
|
|
}
|
2020-05-04 22:41:17 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
if err := acc.SetSequence(acc.GetSequence() + 1); err != nil {
|
2021-06-15 07:19:31 +00:00
|
|
|
|
return ctx, stacktrace.Propagate(err, "failed to set sequence to %d", acc.GetSequence()+1)
|
2021-05-31 09:05:32 +00:00
|
|
|
|
}
|
2020-04-17 22:32:01 +00:00
|
|
|
|
|
2021-05-31 09:05:32 +00:00
|
|
|
|
issd.ak.SetAccount(infCtx, acc)
|
2020-04-17 22:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-04 22:41:17 +00:00
|
|
|
|
// set the original gas meter
|
2020-04-17 22:32:01 +00:00
|
|
|
|
return next(ctx, tx, simulate)
|
|
|
|
|
}
|