feat(accounts): re-introduce bundler

x/accounts/keeper.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 
+	txdecode "cosmossdk.io/x/tx/decode"
 	gogoproto "github.com/cosmos/gogoproto/proto"
 
 	"cosmossdk.io/collections"
@@ -78,6 +79,7 @@ func NewKeeper(
 type Keeper struct {
 	appmodule.Environment
 
+	txDecoder        *txdecode.Decoder
 	addressCodec     address.Codec
 	codec            codec.Codec
 	makeSendCoinsMsg coinsTransferMsgFunc
@@ -339,7 +341,6 @@ func (k Keeper) makeAccountContext(ctx context.Context, accountNumber uint64, ac
 
 // sendAnyMessages it a helper function that executes untyped codectypes.Any messages
 // The messages must all belong to a module.
-// nolint: unused // TODO: remove nolint when we bring back bundler payments
 func (k Keeper) sendAnyMessages(ctx context.Context, sender []byte, anyMessages []*implementation.Any) ([]*implementation.Any, error) {
 	anyResponses := make([]*implementation.Any, len(anyMessages))
 	for i := range anyMessages {
@@ -360,6 +361,37 @@ func (k Keeper) sendAnyMessages(ctx context.Context, sender []byte, anyMessages
 	return anyResponses, nil
 }
 
+func (k Keeper) sendManyMessagesReturnAnys(ctx context.Context, sender []byte, msgs []transaction.Msg) ([]*implementation.Any, error) {
+	resp, err := k.sendManyMessages(ctx, sender, msgs)
+	if err != nil {
+		return nil, err
+	}
+	anys := make([]*implementation.Any, len(resp))
+	for i := range resp {
+		anypb, err := implementation.PackAny(resp[i])
+		if err != nil {
+			return nil, err
+		}
+		anys[i] = anypb
+	}
+	return anys, nil
+}
+
+// sendManyMessages is a helper function that sends many untyped messages on behalf of the sender
+// then returns the respective results. Since the function calls into SendModuleMessage
+// it is guaranteed to disallow impersonation attacks from the sender.
+func (k Keeper) sendManyMessages(ctx context.Context, sender []byte, msgs []transaction.Msg) ([]transaction.Msg, error) {
+	resps := make([]transaction.Msg, len(msgs))
+	for i, msg := range msgs {
+		resp, err := k.SendModuleMessage(ctx, sender, msg)
+		if err != nil {
+			return nil, fmt.Errorf("failed to execute message %d: %s", i, err.Error())
+		}
+		resps[i] = resp
+	}
+	return resps, nil
+}
+
 // SendModuleMessage can be used to send a message towards a module.
 // It should be used when the response type is not known by the caller.
 func (k Keeper) SendModuleMessage(ctx context.Context, sender []byte, msg transaction.Msg) (transaction.Msg, error) {

x/accounts/keeper_account_abstraction.go

@@ -4,9 +4,15 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strings"
+	"time"
 
 	"cosmossdk.io/collections"
 	aa_interface_v1 "cosmossdk.io/x/accounts/interfaces/account_abstraction/v1"
+	"cosmossdk.io/x/accounts/internal/implementation"
+	v1 "cosmossdk.io/x/accounts/v1"
+	txdecode "cosmossdk.io/x/tx/decode"
+	gogoproto "github.com/cosmos/gogoproto/proto"
 
 	"github.com/cosmos/cosmos-sdk/types/address"
 	"github.com/cosmos/cosmos-sdk/types/tx"
@@ -38,6 +44,7 @@ func (k Keeper) IsAbstractedAccount(ctx context.Context, addr []byte) (bool, err
 	return impl.HasExec(&aa_interface_v1.MsgAuthenticate{}), nil
 }
 
+// AuthenticateAccount runs the authentication flow of an account.
 func (k Keeper) AuthenticateAccount(ctx context.Context, signer []byte, bundler string, rawTx *tx.TxRaw, protoTx *tx.Tx, signIndex uint32) error {
 	msg := &aa_interface_v1.MsgAuthenticate{
 		Bundler:     bundler,
@@ -51,3 +58,150 @@ func (k Keeper) AuthenticateAccount(ctx context.Context, signer []byte, bundler
 	}
 	return nil
 }
+
+// ExecuteBundledTx will execute the single bundled tx.
+func (k Keeper) ExecuteBundledTx(ctx context.Context, bundler string, txBytes []byte) *v1.BundledTxResponse {
+	resp, err := k.executeBundledTx(ctx, bundler, txBytes)
+	if err != nil {
+		if resp == nil {
+			return &v1.BundledTxResponse{
+				Error: err.Error(),
+			}
+		}
+		// ensure partial information is not discarded
+		resp.Error = err.Error()
+		return resp
+	}
+	return resp
+}
+
+func (k Keeper) executeBundledTx(ctx context.Context, bundler string, txBytes []byte) (*v1.BundledTxResponse, error) {
+	bundledTx, err := k.txDecoder.Decode(txBytes)
+	if err != nil {
+		return nil, fmt.Errorf("invalid tx bytes: %w", err)
+	}
+	blockInfo := k.HeaderService.HeaderInfo(ctx)
+	xt, err := verifyAndExtractAaXtFromTx(bundledTx, uint64(blockInfo.Height), blockInfo.Time)
+	if err != nil {
+		return nil, fmt.Errorf("tx failed validation check: %w", err)
+	}
+
+	resp := new(v1.BundledTxResponse)
+	// to execute a bundled tx the first step is authentication.
+	signer := bundledTx.Signers[0]
+	authGasUsed, err := k.BranchService.ExecuteWithGasLimit(ctx, xt.AuthenticationGasLimit, func(ctx context.Context) error {
+		return k.AuthenticateAccount(ctx, signer, bundler, protov2TxRawToProtoV1(bundledTx.TxRaw), protoV2TxToProtoV1(bundledTx.Tx), 0)
+	})
+	resp.AuthenticationGasUsed = authGasUsed // set independently of outcome
+	if err != nil {
+		return nil, err
+	}
+
+	// after authentication, we execute the bundler messages.
+	if len(xt.BundlerPaymentMessages) != 0 {
+		var paymentMsgResp []*implementation.Any
+		bundlerPaymentGasUsed, err := k.BranchService.ExecuteWithGasLimit(ctx, xt.BundlerPaymentGasLimit, func(ctx context.Context) error {
+			responses, err := k.sendAnyMessages(ctx, signer, xt.BundlerPaymentMessages)
+			if err != nil {
+				return err
+			}
+			paymentMsgResp = responses
+			return nil
+		})
+		resp.BundlerPaymentGasUsed = bundlerPaymentGasUsed // set independently of outcome
+		if err != nil {
+			return nil, fmt.Errorf("%w: %w", ErrBundlerPayment, err)
+		}
+		resp.BundlerPaymentResponses = paymentMsgResp
+	}
+
+	// finally execute the real messages
+	var execResponses []*implementation.Any
+	execGasUsed, err := k.BranchService.ExecuteWithGasLimit(ctx, xt.ExecutionGasLimit, func(ctx context.Context) error {
+		responses, err := k.sendManyMessagesReturnAnys(ctx, signer, bundledTx.Messages)
+		if err != nil {
+			return err
+		}
+		execResponses = responses
+		return nil
+	})
+	resp.ExecutionGasUsed = execGasUsed // set independently of outcome
+	if err != nil {
+		return nil, fmt.Errorf("%w: %w", ErrExecution, err)
+	}
+	resp.ExecutionResponses = execResponses
+
+	return resp, nil
+}
+
+var aaXtName = gogoproto.MessageName(&aa_interface_v1.MsgAuthenticate{})
+
+func verifyAndExtractAaXtFromTx(bundledTx *txdecode.DecodedTx, currentBlock uint64, currentTime time.Time) (*aa_interface_v1.TxExtension, error) {
+	// some basic things: we do not allow multi addresses in the bundled tx
+	// rationale: the bundler could simply bundle multiple txs in the same bundle
+	// with other accounts.
+	if len(bundledTx.Signers) != 1 {
+		return nil, fmt.Errorf("account abstraction bundled txs can only have one signer, got: %d", len(bundledTx.Signers))
+	}
+	// do not allow sign modes different from single
+	if len(bundledTx.Tx.AuthInfo.SignerInfos) != 1 {
+		return nil, fmt.Errorf("account abstraction tx must have one signer info")
+	}
+
+	// check sign mode is valid
+	if bundledTx.Tx.AuthInfo.SignerInfos[0].ModeInfo.GetSingle() == nil {
+		return nil, fmt.Errorf("account abstraction mode info must be single")
+	}
+
+	// we do not want the tx to have any fees set.
+	if bundledTx.Tx.AuthInfo.Fee != nil {
+		return nil, fmt.Errorf("account abstraction tx must not have the Fee field set")
+	}
+
+	// check timeouts TODO: do not like this much since it feels like we are adding repetition of logic.
+	if bundledTx.Tx.Body.TimeoutTimestamp != nil && currentTime.After(bundledTx.Tx.Body.TimeoutTimestamp.AsTime()) {
+		return nil, fmt.Errorf("block time is after tx timeout timestamp")
+	}
+	if bundledTx.Tx.Body.TimeoutHeight != 0 && currentBlock >= bundledTx.Tx.Body.TimeoutHeight {
+		return nil, fmt.Errorf("block height is after tx timeout height")
+	}
+
+	// extract extension
+	found := false
+	xt := new(aa_interface_v1.TxExtension)
+	for i, anyPb := range bundledTx.Tx.Body.ExtensionOptions {
+		if nameFromTypeURL(anyPb.TypeUrl) == aaXtName {
+			if found {
+				return nil, fmt.Errorf("multiple aa extensions on the same tx")
+			}
+			found = true
+			// unwrap
+			err := xt.Unmarshal(anyPb.Value)
+			if err != nil {
+				return nil, fmt.Errorf("unable to unmarshal tx extension at index %d: %w", i, err)
+			}
+		}
+	}
+	if !found {
+		return nil, fmt.Errorf("%w: did not have AA extension %s", ErrAuthentication, aaXtName)
+	}
+
+	err := verifyAaXt(xt)
+	if err != nil {
+		return nil, fmt.Errorf("invalid account abstraction tx extension: %w", err)
+	}
+
+	return xt, nil
+}
+
+func verifyAaXt(_ *aa_interface_v1.TxExtension) error {
+	return nil
+}
+
+func nameFromTypeURL(url string) string {
+	name := url
+	if i := strings.LastIndexByte(url, '/'); i >= 0 {
+		name = name[i+len("/"):]
+	}
+	return name
+}