6eadc8fdf8
* rpc, evm: remove tc receipt * rm receipt from gRPC query service * update eth block * update tx service response * rpc tx fixes * update bloom * fix * more fixes * c++
142 lines
3.7 KiB
Go
142 lines
3.7 KiB
Go
package keeper
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"math/big"
|
|
"time"
|
|
|
|
"github.com/armon/go-metrics"
|
|
ethcmn "github.com/ethereum/go-ethereum/common"
|
|
ethtypes "github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
|
|
tmtypes "github.com/tendermint/tendermint/types"
|
|
|
|
"github.com/cosmos/cosmos-sdk/telemetry"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
|
|
|
|
"github.com/cosmos/ethermint/x/evm/types"
|
|
)
|
|
|
|
var _ types.MsgServer = &Keeper{}
|
|
|
|
func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*types.MsgEthereumTxResponse, error) {
|
|
defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), types.TypeMsgEthereumTx)
|
|
|
|
ctx := sdk.UnwrapSDKContext(goCtx)
|
|
k.CommitStateDB.WithContext(ctx)
|
|
|
|
ethMsg, err := msg.AsMessage()
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrorInvalidSigner, err.Error())
|
|
}
|
|
|
|
config, found := k.GetChainConfig(ctx)
|
|
if !found {
|
|
return nil, types.ErrChainConfigNotFound
|
|
}
|
|
|
|
var labels []metrics.Label
|
|
if msg.To() == nil {
|
|
labels = []metrics.Label{
|
|
telemetry.NewLabel("execution", "create"),
|
|
}
|
|
} else {
|
|
labels = []metrics.Label{
|
|
telemetry.NewLabel("execution", "call"),
|
|
// add label to the called recipient address (contract or account)
|
|
telemetry.NewLabel("to", msg.Data.To),
|
|
}
|
|
}
|
|
|
|
sender := ethMsg.From()
|
|
|
|
txHash := tmtypes.Tx(ctx.TxBytes()).Hash()
|
|
ethHash := ethcmn.BytesToHash(txHash)
|
|
|
|
// Ethereum formatted tx hash
|
|
etherumTxHash := msg.AsTransaction().Hash()
|
|
|
|
st := &types.StateTransition{
|
|
Message: ethMsg,
|
|
Csdb: k.CommitStateDB.WithContext(ctx),
|
|
ChainID: msg.ChainID(),
|
|
TxHash: ðHash,
|
|
Simulate: ctx.IsCheckTx(),
|
|
}
|
|
|
|
// since the txCount is used by the stateDB, and a simulated tx is run only on the node it's submitted to,
|
|
// then this will cause the txCount/stateDB of the node that ran the simulated tx to be different than the
|
|
// other nodes, causing a consensus error
|
|
if !st.Simulate {
|
|
// Prepare db for logs
|
|
k.CommitStateDB.Prepare(ethHash, k.headerHash, int(k.GetTxIndexTransient()))
|
|
k.IncreaseTxIndexTransient()
|
|
}
|
|
|
|
executionResult, err := st.TransitionDb(ctx, config)
|
|
if err != nil {
|
|
if errors.Is(err, vm.ErrExecutionReverted) && executionResult != nil {
|
|
// keep the execution result for revert reason
|
|
executionResult.Response.Reverted = true
|
|
return executionResult.Response, nil
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
if !st.Simulate {
|
|
bloom, found := k.GetBlockBloomTransient()
|
|
if !found {
|
|
bloom = big.NewInt(0)
|
|
}
|
|
// update block bloom filter
|
|
logsBloom := ethtypes.LogsBloom(executionResult.Logs)
|
|
bloom = bloom.Or(bloom, new(big.Int).SetBytes(logsBloom))
|
|
k.SetBlockBloomTransient(bloom)
|
|
}
|
|
|
|
defer func() {
|
|
if st.Message.Value().IsInt64() {
|
|
telemetry.SetGauge(
|
|
float32(st.Message.Value().Int64()),
|
|
"tx", "msg", "ethereum_tx",
|
|
)
|
|
}
|
|
|
|
telemetry.IncrCounterWithLabels(
|
|
[]string{types.ModuleName, "ethereum_tx"},
|
|
1,
|
|
labels,
|
|
)
|
|
}()
|
|
|
|
attrs := []sdk.Attribute{
|
|
sdk.NewAttribute(sdk.AttributeKeyAmount, st.Message.Value().String()),
|
|
sdk.NewAttribute(types.AttributeKeyTxHash, ethcmn.BytesToHash(txHash).Hex()),
|
|
sdk.NewAttribute(types.AttributeKeyEthereumTxHash, etherumTxHash.Hex()),
|
|
}
|
|
|
|
if len(msg.Data.To) > 0 {
|
|
attrs = append(attrs, sdk.NewAttribute(types.AttributeKeyRecipient, msg.Data.To))
|
|
}
|
|
|
|
// emit events
|
|
ctx.EventManager().EmitEvents(sdk.Events{
|
|
sdk.NewEvent(
|
|
types.EventTypeEthereumTx,
|
|
attrs...,
|
|
),
|
|
sdk.NewEvent(
|
|
sdk.EventTypeMessage,
|
|
sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
|
|
sdk.NewAttribute(sdk.AttributeKeySender, sender.String()),
|
|
),
|
|
})
|
|
|
|
executionResult.Response.Hash = etherumTxHash.Hex()
|
|
return executionResult.Response, nil
|
|
}
|