197 lines
5.7 KiB
Go
197 lines
5.7 KiB
Go
package handlers
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/cosmos/cosmos-sdk/x/auth"
|
|
|
|
"github.com/cosmos/ethermint/types"
|
|
ethcmn "github.com/ethereum/go-ethereum/common"
|
|
|
|
ethtypes "github.com/ethereum/go-ethereum/core/types"
|
|
)
|
|
|
|
const (
|
|
// TODO: Ported from the SDK and may have a different context/value for
|
|
// Ethermint.
|
|
verifySigCost = 100
|
|
)
|
|
|
|
// internalAnteHandler reflects a function signature an internal ante handler
|
|
// must implementing. Internal ante handlers will be dependant upon the
|
|
// transaction type.
|
|
type internalAnteHandler func(
|
|
sdkCtx sdk.Context, tx sdk.Tx, am auth.AccountMapper,
|
|
) (newCtx sdk.Context, res sdk.Result, abort bool)
|
|
|
|
// AnteHandler handles Ethereum transactions and passes SDK transactions to the
|
|
// embeddedAnteHandler if it's an Ethermint transaction. The ante handler gets
|
|
// invoked after the BaseApp performs the runTx. At this point, the transaction
|
|
// should be properly decoded via the TxDecoder and should be of a proper type,
|
|
// Transaction or EmbeddedTx.
|
|
func AnteHandler(am auth.AccountMapper) sdk.AnteHandler {
|
|
return func(sdkCtx sdk.Context, tx sdk.Tx) (newCtx sdk.Context, res sdk.Result, abort bool) {
|
|
var (
|
|
gasLimit int64
|
|
handler internalAnteHandler
|
|
)
|
|
|
|
switch tx := tx.(type) {
|
|
case types.Transaction:
|
|
gasLimit = int64(tx.Data.GasLimit)
|
|
handler = handleEthTx
|
|
case types.EmbeddedTx:
|
|
gasLimit = tx.Fee.Gas
|
|
handler = handleEmbeddedTx
|
|
default:
|
|
return sdkCtx, sdk.ErrInternal(fmt.Sprintf("invalid transaction: %T", tx)).Result(), true
|
|
}
|
|
|
|
newCtx = sdkCtx.WithGasMeter(sdk.NewGasMeter(gasLimit))
|
|
|
|
// AnteHandlers must have their own defer/recover in order for the
|
|
// BaseApp to know how much gas was used! This is because the GasMeter
|
|
// is created in the AnteHandler, but if it panics the context won't be
|
|
// set properly in runTx's recover.
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
switch rType := r.(type) {
|
|
case sdk.ErrorOutOfGas:
|
|
log := fmt.Sprintf("out of gas in location: %v", rType.Descriptor)
|
|
res = sdk.ErrOutOfGas(log).Result()
|
|
res.GasWanted = gasLimit
|
|
res.GasUsed = newCtx.GasMeter().GasConsumed()
|
|
abort = true
|
|
default:
|
|
panic(r)
|
|
}
|
|
}
|
|
}()
|
|
|
|
return handler(newCtx, tx, am)
|
|
}
|
|
}
|
|
|
|
// handleEthTx implements an ante handler for an Ethereum transaction. It
|
|
// validates the signature and if valid returns an OK result.
|
|
//
|
|
// TODO: Do we need to do any further validation or account manipulation
|
|
// (e.g. increment nonce)?
|
|
func handleEthTx(sdkCtx sdk.Context, tx sdk.Tx, am auth.AccountMapper) (sdk.Context, sdk.Result, bool) {
|
|
ethTx, ok := tx.(types.Transaction)
|
|
if !ok {
|
|
return sdkCtx, sdk.ErrInternal(fmt.Sprintf("invalid transaction: %T", tx)).Result(), true
|
|
}
|
|
|
|
// the SDK chainID is a string representation of integer
|
|
chainID, ok := new(big.Int).SetString(sdkCtx.ChainID(), 10)
|
|
if !ok {
|
|
// TODO: ErrInternal may not be correct error to throw here?
|
|
return sdkCtx, sdk.ErrInternal(fmt.Sprintf("invalid chainID: %s", sdkCtx.ChainID())).Result(), true
|
|
}
|
|
|
|
// validate signature
|
|
gethTx := ethTx.ConvertTx(chainID)
|
|
signer := ethtypes.NewEIP155Signer(chainID)
|
|
|
|
_, err := signer.Sender(&gethTx)
|
|
if err != nil {
|
|
return sdkCtx, sdk.ErrUnauthorized("signature verification failed").Result(), true
|
|
}
|
|
|
|
return sdkCtx, sdk.Result{GasWanted: int64(ethTx.Data.GasLimit)}, false
|
|
}
|
|
|
|
// handleEmbeddedTx implements an ante handler for an SDK transaction. It
|
|
// validates the signature and if valid returns an OK result.
|
|
func handleEmbeddedTx(sdkCtx sdk.Context, tx sdk.Tx, am auth.AccountMapper) (sdk.Context, sdk.Result, bool) {
|
|
etx, ok := tx.(types.EmbeddedTx)
|
|
if !ok {
|
|
return sdkCtx, sdk.ErrInternal(fmt.Sprintf("invalid transaction: %T", tx)).Result(), true
|
|
}
|
|
|
|
if err := validateEmbeddedTxBasic(etx); err != nil {
|
|
return sdkCtx, err.Result(), true
|
|
}
|
|
|
|
signerAddrs := etx.GetRequiredSigners()
|
|
signerAccs := make([]auth.Account, len(signerAddrs))
|
|
|
|
// validate signatures
|
|
for i, sig := range etx.Signatures {
|
|
signer := ethcmn.BytesToAddress(signerAddrs[i].Bytes())
|
|
|
|
signerAcc, err := validateSignature(sdkCtx, etx, signer, sig, am)
|
|
if err.Code() != sdk.CodeOK {
|
|
return sdkCtx, err.Result(), false
|
|
}
|
|
|
|
// TODO: Fees!
|
|
|
|
am.SetAccount(sdkCtx, signerAcc)
|
|
signerAccs[i] = signerAcc
|
|
}
|
|
|
|
newCtx := auth.WithSigners(sdkCtx, signerAccs)
|
|
|
|
return newCtx, sdk.Result{GasWanted: etx.Fee.Gas}, false
|
|
}
|
|
|
|
// validateEmbeddedTxBasic validates an EmbeddedTx based on things that don't
|
|
// depend on the context.
|
|
func validateEmbeddedTxBasic(etx types.EmbeddedTx) (err sdk.Error) {
|
|
sigs := etx.Signatures
|
|
if len(sigs) == 0 {
|
|
return sdk.ErrUnauthorized("transaction missing signatures")
|
|
}
|
|
|
|
signerAddrs := etx.GetRequiredSigners()
|
|
if len(sigs) != len(signerAddrs) {
|
|
return sdk.ErrUnauthorized("invalid number of transaction signers")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func validateSignature(
|
|
sdkCtx sdk.Context, etx types.EmbeddedTx, signer ethcmn.Address,
|
|
sig []byte, am auth.AccountMapper,
|
|
) (acc auth.Account, sdkErr sdk.Error) {
|
|
|
|
chainID := sdkCtx.ChainID()
|
|
|
|
acc = am.GetAccount(sdkCtx, signer.Bytes())
|
|
if acc == nil {
|
|
return nil, sdk.ErrUnknownAddress(fmt.Sprintf("no account with address %s found", signer))
|
|
}
|
|
|
|
signEtx := types.EmbeddedTxSign{
|
|
ChainID: chainID,
|
|
AccountNumber: acc.GetAccountNumber(),
|
|
Sequence: acc.GetSequence(),
|
|
Messages: etx.Messages,
|
|
Fee: etx.Fee,
|
|
}
|
|
|
|
err := acc.SetSequence(signEtx.Sequence + 1)
|
|
if err != nil {
|
|
return nil, sdk.ErrInternal(err.Error())
|
|
}
|
|
|
|
signBytes, err := signEtx.Bytes()
|
|
if err != nil {
|
|
return nil, sdk.ErrInternal(err.Error())
|
|
}
|
|
|
|
// consume gas for signature verification
|
|
sdkCtx.GasMeter().ConsumeGas(verifySigCost, "ante verify")
|
|
|
|
if err := types.ValidateSigner(signBytes, sig, signer); err != nil {
|
|
return nil, sdk.ErrUnauthorized(err.Error())
|
|
}
|
|
|
|
return
|
|
}
|