feat(accounts): add interfaces and mock impls for account abstraction

proto/cosmos/accounts/interfaces/account_abstraction/v1/interface.proto

@@ -0,0 +1,66 @@
+syntax = "proto3";
+
+package cosmos.accounts.interfaces.account_abstraction.v1;
+
+import "google/protobuf/any.proto";
+import "cosmos/accounts/v1/account_abstraction.proto";
+
+// MsgAuthenticate is a message that an x/account account abstraction implementer
+// must handle to authenticate a state transition.
+message MsgAuthenticate {
+  // user_operation is the operation that the user is trying to perform.
+  // it also contains authentication information.
+  cosmos.accounts.v1.UserOperation user_operation = 1;
+  // chain_id defines the network identifier.
+  string chain_id = 2;
+  // account_number is the account number of the user_operation.
+  uint64 account_number = 3;
+}
+
+// MsgAuthenticateResponse is the response to MsgAuthenticate.
+// The authentication either fails or succeeds, this is why
+// there are no auxiliary fields to the response.
+message MsgAuthenticateResponse {}
+
+// MsgPayBundler is a message that an x/account account abstraction implementer
+// can optionally implement in case it wants to further refine control over
+// the bundler payment messages.
+// The account must ensure the caller of this message is the x/accounts module itself.
+message MsgPayBundler {
+  // bundler_payment_messages are the messages that the operation sender will execute.
+  // The account can modify the messages as it sees fit.
+  repeated google.protobuf.Any bundler_payment_messages = 1;
+}
+
+// MsgPayBundlerResponse is the response to MsgPayBundler.
+message MsgPayBundlerResponse {
+  // bundler_payment_messages_response are the messages that the bundler will pay for.
+  repeated google.protobuf.Any bundler_payment_messages_response = 1;
+}
+
+// MsgExecute is a message that an x/account account abstraction implementer
+// can optionally implement in case it wants to further refine control over
+// the execution messages. It can be used to extend the execution flow, possibly
+// block certain messages, or modify them.
+// The account must ensure the caller of this message is the x/accounts module itself.
+message MsgExecute {
+  // execution_messages are the messages that the operation sender will execute.
+  // The account can modify the messages as it sees fit.
+  repeated google.protobuf.Any execution_messages = 1;
+}
+
+// MsgExecuteResponse is the response to MsgExecute.
+message MsgExecuteResponse {
+  // execution_messages_response are the messages that the operation sender will execute.
+  repeated google.protobuf.Any execution_messages_response = 1;
+}
+
+// QueryAuthenticationMethods is a query that an x/account account abstraction implementer
+// must handle to return the authentication methods that the account supports.
+message QueryAuthenticationMethods {}
+
+// QueryAuthenticationMethodsResponse is the response to QueryAuthenticationMethods.
+message QueryAuthenticationMethodsResponse {
+  // authentication_methods are the authentication methods that the account supports.
+  repeated string authentication_methods = 1;
+}

proto/cosmos/accounts/testing/rotation/v1/partial.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package cosmos.accounts.testing.rotation.v1;
+
+// MsgInit is the init message used to create a new account
+// abstraction implementation that we use for testing, this account
+// also allows for rotating the public key.
+message MsgInit {
+  bytes pub_key_bytes = 1;
+}
+
+// MsgInitResponse is the init message response.
+message MsgInitResponse {}
+
+// MsgRotatePubKey is the message used to swap the public key
+// of the account.
+message MsgRotatePubKey {
+  bytes new_pub_key_bytes = 1;
+}
+
+// MsgRotatePubKeyResponse is the MsgRotatePubKey response.
+message MsgRotatePubKeyResponse {}

proto/cosmos/accounts/v1/account_abstraction.proto

@@ -0,0 +1,63 @@
+syntax = "proto3";
+
+package cosmos.accounts.v1;
+
+option go_package = "cosmossdk.io/x/accounts/v1";
+
+import "google/protobuf/any.proto";
+
+// UserOperation defines the type used to define a state transition that
+// an account wants to make.
+message UserOperation {
+  // sender defines the account that is sending the UserOperation.
+  string sender = 1;
+  // authentication_method defines the authentication strategy the account wants to use.
+  // since accounts can have multiple authentication methods, this field is used to
+  // instruct the account on what auth method to use.
+  string authentication_method = 2;
+  // authentication_data defines the authentication data associated with the authentication method.
+  // It is the account implementer duty to assess that the UserOperation is properly signed.
+  bytes authentication_data = 3;
+  // sequence defines the sequence number of the account, the authentication method might require this
+  // to ensure non-replayability.
+  uint64 sequence = 4;
+  // authentication_gas_limit expresses the gas limit to be used for the authentication part of the
+  // UserOperation.
+  uint64 authentication_gas_limit = 5;
+  // bundler_payment_messages expresses a list of messages that the account
+  // executes to pay the bundler for submitting the UserOperation.
+  // It can be empty if the bundler does not need any form of payment,
+  // the handshake for submitting the UserOperation might have happened off-chain.
+  // Bundlers and accounts are free to use any form of payment, in fact the payment can
+  // either be empty or be expressed as:
+  // - NFT payment
+  // - IBC Token payment.
+  // - Payment through delegations.
+  repeated google.protobuf.Any bundler_payment_messages = 6;
+  // bundler_payment_gas_limit defines the gas limit to be used for the bundler payment.
+  // This ensures that, since the bundler executes a list of UserOperations and there needs to
+  // be minimal trust between bundler and UserOperation sender, the sender cannot consume
+  // the whole bundle gas.
+  uint64 bundler_payment_gas_limit = 7;
+  // execution_messages expresses a list of messages that the account wants to execute.
+  // This concretely is the intent of the transaction expressed as a UserOperation.
+  repeated google.protobuf.Any execution_messages = 8;
+  // execution_gas_limit defines the gas limit to be used for the execution of the UserOperation's
+  // execution messages.
+  uint64 execution_gas_limit = 9;
+}
+
+// UserOperationResponse defines the response of a UserOperation.
+message UserOperationResponse {
+  // authentication_gas_used defines the gas used for the authentication part of the UserOperation.
+  uint64 authentication_gas_used = 1;
+  // bundler_payment_gas_used defines the gas used for the bundler payment part of the UserOperation.
+  uint64 bundler_payment_gas_used = 2;
+  // bundler_payment_responses defines the responses of the bundler payment messages.
+  // It can be empty if the bundler does not need any form of payment.
+  repeated google.protobuf.Any bundler_payment_responses = 3;
+  // execution_gas_used defines the gas used for the execution part of the UserOperation.
+  uint64 execution_gas_used = 4;
+  // execution_responses defines the responses of the execution messages.
+  repeated google.protobuf.Any execution_responses = 5;
+}

proto/cosmos/accounts/v1/tx.proto

@@ -5,6 +5,7 @@ package cosmos.accounts.v1;
 option go_package = "cosmossdk.io/x/accounts/v1";
 
 import "cosmos/msg/v1/msg.proto";
+import "cosmos/accounts/v1/account_abstraction.proto";
 
 // Msg defines the Msg service for the x/accounts module.
 service Msg {
@@ -15,6 +16,10 @@ service Msg {
 
   // Execute executes a message to the target account.
   rpc Execute(MsgExecute) returns (MsgExecuteResponse);
+
+  // ExecuteBundle pertains account abstraction, it is used by the bundler
+  // to execute multiple UserOperations in a single transaction message.
+  rpc ExecuteBundle(MsgExecuteBundle) returns (MsgExecuteBundleResponse);
 }
 
 // MsgInit defines the Create request type for the Msg/Create RPC method.
@@ -55,3 +60,21 @@ message MsgExecuteResponse {
   // response is the response returned by the account implementation.
   bytes response = 1;
 }
+
+// -------- Account Abstraction ---------
+
+// MsgExecuteBundle defines the ExecuteBundle request type for the Msg/ExecuteBundle RPC method.
+message MsgExecuteBundle {
+  option (cosmos.msg.v1.signer) = "bundler";
+  // bundler defines the entity going through the standard TX flow
+  // to execute one or multiple UserOperations on behalf of others.
+  string bundler = 1;
+  // operations is the list of operations to be executed.
+  repeated UserOperation operations = 2;
+}
+
+// MsgExecuteBundleResponse defines the ExecuteBundle response type for the Msg/ExecuteBundle RPC method.
+message MsgExecuteBundleResponse {
+  // responses is the list of responses returned by the account implementations.
+  repeated UserOperationResponse responses = 1;
+}

x/accounts/msg_server.go

@@ -3,6 +3,9 @@ package accounts
 import (
 	"context"
 
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
 	"cosmossdk.io/core/event"
 	v1 "cosmossdk.io/x/accounts/v1"
 )
@@ -116,3 +119,7 @@ func (m msgServer) Execute(ctx context.Context, execute *v1.MsgExecute) (*v1.Msg
 		Response: respBytes,
 	}, nil
 }
+
+func (m msgServer) ExecuteBundle(ctx context.Context, req *v1.MsgExecuteBundle) (*v1.MsgExecuteBundleResponse, error) {
+	return nil, status.New(codes.Unimplemented, "not implemented").Err()
+}

x/accounts/testing/account_abstraction/partial_account.go

@@ -0,0 +1,68 @@
+package account_abstraction
+
+import (
+	"context"
+	"fmt"
+
+	account_abstractionv1 "cosmossdk.io/api/cosmos/accounts/interfaces/account_abstraction/v1"
+	rotationv1 "cosmossdk.io/api/cosmos/accounts/testing/rotation/v1"
+	"cosmossdk.io/api/cosmos/crypto/secp256k1"
+	"cosmossdk.io/collections"
+	"cosmossdk.io/x/accounts/accountstd"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+)
+
+var (
+	PubKeyPrefix   = collections.NewPrefix(0)
+	SequencePrefix = collections.NewPrefix(1)
+)
+
+var _ accountstd.Interface = (*PartialAccount)(nil)
+
+func NewPartialAccount(d accountstd.Dependencies) (PartialAccount, error) {
+	return PartialAccount{
+		PubKey:   collections.NewItem(d.SchemaBuilder, PubKeyPrefix, "pubkey", codec.CollValueV2[secp256k1.PubKey]()),
+		Sequence: collections.NewItem(d.SchemaBuilder, SequencePrefix, "sequence", collections.Uint64Value),
+	}, nil
+}
+
+// PartialAccount implements the Account interface. It also
+// implements the account_abstraction interface, it only implements
+// the minimum methods required to be a valid account_abstraction
+// implementer.
+type PartialAccount struct {
+	PubKey   collections.Item[*secp256k1.PubKey]
+	Sequence collections.Item[uint64]
+}
+
+func (a PartialAccount) Init(ctx context.Context, msg *rotationv1.MsgInit) (*rotationv1.MsgInitResponse, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func (a PartialAccount) RotatePubKey(ctx context.Context, msg *rotationv1.MsgRotatePubKey) (*rotationv1.MsgRotatePubKeyResponse, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// Authenticate authenticates the account.
+func (a PartialAccount) Authenticate(ctx context.Context, msg *account_abstractionv1.MsgAuthenticate) (*account_abstractionv1.MsgAuthenticateResponse, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// QueryAuthenticateMethods queries the authentication methods of the account.
+func (a PartialAccount) QueryAuthenticateMethods(ctx context.Context, req *account_abstractionv1.QueryAuthenticationMethods) (*account_abstractionv1.QueryAuthenticationMethodsResponse, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func (a PartialAccount) RegisterInitHandler(builder *accountstd.InitBuilder) {
+	accountstd.RegisterInitHandler(builder, a.Init)
+}
+
+func (a PartialAccount) RegisterExecuteHandlers(builder *accountstd.ExecuteBuilder) {
+	accountstd.RegisterExecuteHandler(builder, a.RotatePubKey)
+	accountstd.RegisterExecuteHandler(builder, a.Authenticate) // implements account_abstraction
+}
+
+func (a PartialAccount) RegisterQueryHandlers(builder *accountstd.QueryBuilder) {
+	accountstd.RegisterQueryHandler(builder, a.QueryAuthenticateMethods) // implements account_abstraction
+}