@account-kit/wallet-client 0.1.0-alpha.1 → 0.1.0-alpha.3

package/src/capabilities/permissions/index.ts

@@ -24,7 +24,7 @@ const Permission = <
         type: Type.Literal(typeEnum),
         data,
       },
-      { description },
+      { description, title: `${typeString}` },
     ),
   )
     .Decode((value) => ({
@@ -124,19 +124,35 @@ export const TypePermission = Type.Union([
 
 export const PermissionsArray = Type.Array(TypePermission, { minItems: 1 });
 
-export const PermissionsContext = Type.Object({
-  context: TypeHex(),
-});
+export const PermissionsContext = Type.Object(
+  {
+    context: TypeHex(),
+  },
+  {
+    title: "Permissions context",
+  },
+);
+
+export const RemotePermission = Type.Object(
+  {
+    sessionId: TypeHex(),
+    signature: TypeHex(),
+  },
+  {
+    title: "Remote permission",
+  },
+);
 
 export const PermissionsData = Type.Object({
   chainId: TypeHex(),
-  expiry: Type.Optional(Type.Number()),
+  expiry: Type.Optional(Type.Integer()),
   key: KeySigner,
   permissions: PermissionsArray,
 });
 
 export const PermissionsCapability = Type.Union([
   PermissionsContext,
+  RemotePermission,
   // TODO: support permissions object here instead of only context-encoded permissions
   // PermissionsData,
 ]);

package/src/capabilities/permissions/mav2.ts

@@ -1,9 +1,9 @@
 import { PermissionType } from "@account-kit/smart-contracts/experimental";
 import type { Static } from "@sinclair/typebox";
 import { concatHex, sliceHex, type Hex } from "viem";
-import type { PermissionsData } from ".";
-import type { KeySigner } from "../../schemas";
+import type { KeySigner } from "../../schemas.ts";
 import { assertNever } from "../../utils.js";
+import type { PermissionsCapability, PermissionsData } from "./index.ts";
 
 export const SESSION_ID_LENGTH_BYTES = 16;
 export const ENTITY_ID_LENGTH_BYTES = 4;
@@ -69,8 +69,18 @@ export const encodePermissionsContext = (
 };
 
 export const decodePermissionsContext = (
-  input: Hex,
+  capability: Static<typeof PermissionsCapability>,
 ): DecodedPermissionsContext => {
+  if (!("context" in capability)) {
+    return {
+      contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
+      sessionId: capability.sessionId,
+      signature: capability.signature,
+    };
+  }
+
+  const input = capability.context;
+
   const contextVersion = sliceHex(input, 0, 1) as ContextVersionHex;
   switch (contextVersion) {
     case "0x00": {

package/src/client/actions/createAccount.ts

@@ -1,8 +1,8 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { Static } from "@sinclair/typebox";
 import type { Address } from "abitype";
-import type { wallet_createAccount } from "../../rpc/request";
-import type { InnerWalletApiClient } from "../../types";
+import type { wallet_createAccount } from "../../rpc/request.ts";
+import type { InnerWalletApiClient } from "../../types.ts";
 
 export type CreateAccountParams = Omit<
   Extract<
@@ -16,6 +16,31 @@ export type CreateAccountResult = Static<
   typeof wallet_createAccount
 >["ReturnType"];
 
+/**
+ * Creates a new account for the provided signer using the wallet API client.
+ * This method is primarily used to import existing accounts.
+ * For most cases, you should use requestAccount instead.
+ * If the account already exists, an error will be thrown.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer that will be associated with the account
+ * @param {CreateAccountParams} params - Parameters for creating the account
+ * @param {string} [params.id] - Optional UUID v4 identifier for the account
+ * @param {object} params.creationOptions - Options for account creation
+ * @param {string} [params.creationOptions.accountType] - Currently only "sma-b" (Modular Account v2) is supported
+ * @param {string} [params.creationOptions.salt] - Optional hex string to use as salt for account creation
+ * @returns {Promise<CreateAccountResult>} A Promise that resolves to the created account information
+ *
+ * @example
+ * // Create a new account with a custom salt
+ * const account = await client.createAccount({
+ *   creationOptions: {
+ *     accountType: "sma-b",
+ *     salt: "0x04"
+ *   }
+ * });
+ * console.log(`Created account at address: ${account.accountAddress}`);
+ */
 export async function createAccount(
   client: InnerWalletApiClient,
   signer: SmartAccountSigner,

package/src/client/actions/getCallsStatus.ts

@@ -2,13 +2,32 @@ import type { Address, JsonRpcAccount } from "viem";
 import type {
   GetCallsStatusParams as IsomorphicGetCallsStatusParams,
   GetCallsStatusResponse as IsomorphicGetCallsStatusResult,
-} from "../../isomorphic/actions/getCallsStatus";
-import type { InnerWalletApiClient } from "../../types";
+} from "../../isomorphic/actions/getCallsStatus.ts";
+import type { InnerWalletApiClient } from "../../types.ts";
 
 export type GetCallsStatusParams = IsomorphicGetCallsStatusParams;
 
 export type GetCallsStatusResult = IsomorphicGetCallsStatusResult;
 
+/**
+ * Gets the status of a prepared call by its ID.
+ * This method is used to check the execution status of calls sent via sendPreparedCalls.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {GetCallsStatusParams} params - The ID of the prepared call to check
+ * @returns {Promise<GetCallsStatusResult>} A Promise that resolves to the status information including:
+ *   - id: The hex ID of the call
+ *   - chainId: The chain ID in hex format
+ *   - status: The current status of the batch execution
+ *   - receipts: Optional array of transaction receipts if the batch has been executed
+ *
+ * @example
+ * // After sending prepared calls
+ * const sendResult = await client.sendPreparedCalls({...});
+ *
+ * // Check the status of the first call ID
+ * const status = await client.getCallsStatus(sendResult.preparedCallIds[0]);
+ */
 export async function getCallsStatus<
   TAccount extends JsonRpcAccount<Address> | undefined =
     | JsonRpcAccount<Address>

package/src/client/actions/grantPermissions.ts

@@ -5,9 +5,11 @@ import {
   type JsonRpcAccount,
   toHex,
 } from "viem";
-import type { InnerWalletApiClient } from "../../types";
+import type { InnerWalletApiClient } from "../../types.ts";
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import type { CreateSessionParams } from "../../isomorphic/actions/createSession";
+import type { CreateSessionParams } from "../../isomorphic/actions/createSession.ts";
+import { TypeEip7702AuthExtendedFields } from "../../schemas.js";
+import type { Static } from "@sinclair/typebox";
 
 export type GrantPermissionsParams<
   TAccount extends JsonRpcAccount<Address> | undefined =
@@ -20,8 +22,118 @@ export type GrantPermissionsParams<
 
 export type GrantPermissionsResult = {
   context: Hex;
+  signedAuthorization?: Static<typeof TypeEip7702AuthExtendedFields>;
 };
 
+/**
+ * Grants permissions to a smart account by creating a session.
+ * This allows another key to perform operations on behalf of the account.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer of the smart account
+ * @param {GrantPermissionsParams} params - The parameters for granting permissions
+ * @param {Address} [params.account] - The account address (required if client was not initialized with an account)
+ * @param {number} params.expiry - Unix timestamp when the permissions expire
+ * @param {object} params.key - The session key information
+ * @param {string} params.key.publicKey - The public key of the session key
+ * @param {string} params.key.type - The type of the key (e.g., "secp256k1")
+ * @param {Array} params.permissions - Array of permission objects defining what the session key can do
+ * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier
+ * @returns {Hex} result.context - A hex identifier for the granted permissions context
+ * @returns {Static<typeof TypeEip7702AuthExtendedFields>} result.signedAuthorization - The EIP-7702 authorization fields, if applicable
+ *
+ * @example
+ * // Create a session key and grant root permissions
+ * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+ * const account = await client.requestAccount();
+ *
+ * const permissions = await client.grantPermissions({
+ *   account: account.address,
+ *   expiry: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
+ *   key: {
+ *     publicKey: await sessionKey.getAddress(),
+ *     type: "secp256k1",
+ *   },
+ *   permissions: [{ type: "root" }],
+ * });
+ *
+ * // Use the permissions to prepare a call
+ * const preparedCall = await client.prepareCalls({
+ *   calls: [{ to: zeroAddress, value: "0x0" }],
+ *   from: account.address,
+ *   capabilities: {
+ *     paymasterService: {
+ *       policyId: "your-paymaster-policy-id",
+ *     },
+ *     permissions,
+ *   },
+ * });
+ *
+ * // Sign with the session key
+ * const signature = await signSignatureRequest(
+ *   sessionKey,
+ *   preparedCall.signatureRequest,
+ * );
+ *
+ * // Send the prepared call using the session key
+ * const result = await client.sendPreparedCalls({
+ *   ...preparedCall,
+ *   signature,
+ *   capabilities: {
+ *     permissions,
+ *   },
+ * });
+ *
+ * @example
+ * // Create a session key and grant root permissions using a 7702 account
+ * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+ * const account = await client.requestAccount({
+ *   creationHint: {
+ *     accountType: "7702",
+ *   }
+ * });
+ *
+ * const permissions = await client.grantPermissions({
+ *   account: account.address,
+ *   expiry: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
+ *   key: {
+ *     publicKey: await sessionKey.getAddress(),
+ *     type: "secp256k1",
+ *   },
+ *   permissions: [{ type: "root" }],
+ * });
+ *
+ * // Use the permissions to prepare a call
+ * const preparedCall = await client.prepareCalls({
+ *   calls: [{ to: zeroAddress, value: "0x0" }],
+ *   from: account.address,
+ *   capabilities: {
+ *     paymasterService: {
+ *       policyId: "your-paymaster-policy-id",
+ *     },
+ *     permissions,
+ *   },
+ * });
+ *
+ * // Sign with the session key
+ * // If the 7702 account delegation is not yet installed, the result
+ * // here will include a `signedAuthorization` field that that
+ * // must be included when sending the account's first call.
+ * const { signedAuthorization, ...signature} = await signSignatureRequest(
+ *   sessionKey,
+ *   preparedCall.signatureRequest,
+ * );
+ *
+ * // Send the prepared call using the session key
+ * const result = await client.sendPreparedCalls({
+ *   ...preparedCall,
+ *   signature,
+ *   signedAuthorization,
+ *   capabilities: {
+ *     permissions,
+ *   },
+ * });
+ */
 export async function grantPermissions<
   TAccount extends JsonRpcAccount<Address> | undefined =
     | JsonRpcAccount<Address>

package/src/client/actions/listAccounts.ts

@@ -1,6 +1,6 @@
 import type { Static } from "@sinclair/typebox";
-import type { wallet_listAccounts } from "../../rpc/request";
-import type { InnerWalletApiClient } from "../../types";
+import type { wallet_listAccounts } from "../../rpc/request.ts";
+import type { InnerWalletApiClient } from "../../types.ts";
 
 export type ListAccountsParams = Static<
   typeof wallet_listAccounts
@@ -10,6 +10,30 @@ export type ListAccountsResult = Static<
   typeof wallet_listAccounts
 >["ReturnType"];
 
+/**
+ * Lists all smart accounts for a given signer using the wallet API client.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {ListAccountsParams} params - Parameters for listing accounts
+ * @param {string} params.signerAddress - The address of the signer to list accounts for
+ * @param {number} [params.limit] - Optional maximum number of accounts to return (default: 100, max: 100)
+ * @param {string} [params.after] - Optional pagination cursor for fetching subsequent pages
+ * @returns {Promise<ListAccountsResult>} A Promise that resolves to the list of accounts and pagination metadata
+ *
+ * @example
+ * // Fetch the first page of accounts
+ * const firstPage = await client.listAccounts({
+ *   signerAddress: "0x123...",
+ *   limit: 10
+ * });
+ *
+ * // If an 'after' cursor exists, use it to fetch the next page
+ * const nextPage = await client.listAccounts({
+ *   signerAddress: "0x123...",
+ *   limit: 10,
+ *   after: firstPage.meta.after
+ * });
+ */
 export async function listAccounts(
   client: InnerWalletApiClient,
   params: ListAccountsParams,

package/src/client/actions/prepareCalls.ts

@@ -7,8 +7,8 @@ import {
 import type {
   PrepareCallsParams as IsomorphicPrepareCallsParams,
   PrepareCallsResult as IsomorphicPrepareCallsResult,
-} from "../../isomorphic/actions/prepareCalls";
-import type { InnerWalletApiClient } from "../../types";
+} from "../../isomorphic/actions/prepareCalls.ts";
+import type { InnerWalletApiClient } from "../../types.ts";
 
 export type GetAccountParam<TAccount> =
   IsUndefined<TAccount> extends true
@@ -24,6 +24,32 @@ export type PrepareCallsParams<
 
 export type PrepareCallsResult = IsomorphicPrepareCallsResult;
 
+/**
+ * Prepares a set of contract calls for execution by building a user operation.
+ * Returns the built user operation and a signature request that needs to be signed
+ * before submitting to sendPreparedCalls.
+ *
+ * @param {InnerWalletApiClient<TAccount>} client - The wallet API client to use for the request
+ * @param {PrepareCallsParams<TAccount>} params - Parameters for preparing calls
+ * @param {Array<{to: Address, data?: Hex, value?: Hex}>} params.calls - Array of contract calls to execute
+ * @param {Address} [params.from] - The address to execute the calls from (required if the client wasn't initialized with an account)
+ * @param {object} [params.capabilities] - Optional capabilities to include with the request
+ * @returns {Promise<PrepareCallsResult>} A Promise that resolves to the prepared calls result containing
+ * the user operation data and signature request
+ *
+ * @example
+ * // Prepare a sponosored user operation call
+ * const result = await client.prepareCalls({
+ *   calls: [{
+ *     to: "0x1234...",
+ *     data: "0xabcdef...",
+ *     value: "0x0"
+ *   }],
+ *   capabilities: {
+ *     paymasterService: { policyId: "your-policy-id" }
+ *   }
+ * });
+ */
 export async function prepareCalls<
   TAccount extends JsonRpcAccount<Address> | undefined =
     | JsonRpcAccount<Address>

package/src/client/actions/requestAccount.ts

@@ -1,4 +1,7 @@
-import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
+import {
+  type SmartAccountSigner,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
 import type { Static } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import type { Address } from "abitype";
@@ -7,6 +10,7 @@ import { createAccount } from "../../isomorphic/utils/createAccount.js";
 import type { wallet_requestAccount } from "../../rpc/request.js";
 import { TypeSerializedInitcode } from "../../schemas.js";
 import type { InnerWalletApiClient } from "../../types.js";
+import deepEqual from "deep-equal";
 
 export type RequestAccountParams<
   TAccount extends JsonRpcAccount<Address> | undefined =
@@ -20,12 +24,28 @@ export type RequestAccountParams<
           { signerAddress: Address }
         >,
         "signerAddress" | "includeCounterfactualInfo"
-      >
+      > & { accountAddress?: Address }
     : never;
 
-// TODO: this could be more specific potentially :shrug:
 export type RequestAccountResult = SmartContractAccount;
 
+/**
+ * Requests an account for the provided signer using the wallet API client.
+ * If an account already exists for the signer, it will always return that account unless a new ID is specified.
+ * If an account already exists, the creationHint will be ignored.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer that will be associated with the account
+ * @param {RequestAccountParams} [params] - Optional parameters for requesting a specific account
+ * @param {string} [params.id] - Optional identifier for the account. If specified, a new account with this ID will be created even if one already exists for the signer
+ * @param {object} [params.creationHint] - Optional hints to guide account creation. These are ignored if an account already exists
+ * @returns {Promise<RequestAccountResult>} A Promise that resolves to a SmartContractAccount instance
+ *
+ * @example
+ * // Request an account with default parameters using a local signer
+ * const signer = LocalAccountSigner.privateKeyToAccountSigner("0x...");
+ * const account = await client.requestAccount(signer);
+ */
 export function requestAccount<
   TAccount extends JsonRpcAccount<Address> | undefined =
     | JsonRpcAccount<Address>
@@ -42,9 +62,9 @@ export async function requestAccount(
   params?: RequestAccountParams,
 ): Promise<RequestAccountResult> {
   const args =
-    client.account && !params
+    (client.account && !params) || params?.accountAddress
       ? {
-          accountAddress: client.account.address,
+          accountAddress: params?.accountAddress ?? client.account!.address,
           includeCounterfactualInfo: true,
         }
       : {
@@ -53,13 +73,23 @@ export async function requestAccount(
           includeCounterfactualInfo: true,
         };
 
+  const cachedAccount = client.internal.getAccount();
+  if (
+    cachedAccount &&
+    ((args.accountAddress &&
+      cachedAccount.account.address === args.accountAddress) ||
+      deepEqual(cachedAccount.requestParams, args, { strict: true }))
+  ) {
+    return cachedAccount.account;
+  }
+
   const { counterfactualInfo, accountAddress } = await client.request({
     method: "wallet_requestAccount",
     params: [args],
   });
 
-  return createAccount({
-    accountAddress: accountAddress,
+  const account = await createAccount({
+    accountAddress,
     counterfactualInfo: Value.Parse(
       TypeSerializedInitcode,
       counterfactualInfo!,
@@ -68,4 +98,8 @@ export async function requestAccount(
     transport: custom(client.transport),
     signer,
   });
+
+  client.internal.setAccount({ account, requestParams: args });
+
+  return account;
 }

package/src/client/actions/sendPreparedCalls.ts

@@ -1,7 +1,7 @@
 import type { Static, StaticDecode } from "@sinclair/typebox";
 import { toHex } from "viem";
-import type { wallet_sendPreparedCalls } from "../../rpc/request";
-import type { InnerWalletApiClient } from "../../types";
+import type { wallet_sendPreparedCalls } from "../../rpc/request.ts";
+import type { InnerWalletApiClient } from "../../types.ts";
 
 export type SendPreparedCallsParams = Omit<
   StaticDecode<typeof wallet_sendPreparedCalls>["Request"]["params"][0],
@@ -12,6 +12,43 @@ export type SendPreparedCallsResult = Static<
   typeof wallet_sendPreparedCalls
 >["ReturnType"];
 
+/**
+ * Sends prepared calls by submitting a signed user operation.
+ * This method is used after signing the signature request returned from prepareCalls.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SendPreparedCallsParams} params - Parameters for sending prepared calls
+ * @param {string} params.type - The user operation type ('user-operation-v060' or 'user-operation-v070')
+ * @param {object} params.data - The user operation data without signature
+ * @param {string} params.chainId - The chain ID in hex format
+ * @param {object} params.signature - The signature object
+ * @param {string} params.signature.type - The signature type (must be 'ecdsa')
+ * @param {string} params.signature.signature - The hex-encoded signature value
+ * @param {object} [params.capabilities] - Optional capabilities to include with the request
+ * @returns {Promise<SendPreparedCallsResult>} A Promise that resolves to the result containing the prepared call IDs
+ *
+ * @example
+ * // First prepare the calls
+ * const preparedCalls = await client.prepareCalls({
+ *   calls: [{
+ *     to: "0x1234...",
+ *     data: "0xabcdef...",
+ *     value: "0x0"
+ *   }],
+ *   capabilities: {
+ *     paymasterService: { policyId: "your-policy-id" }
+ *   }
+ * });
+ *
+ * // Sign the signature request using signSignatureRequest with your signer
+ * const signedRequest = await client.signSignatureRequest(preparedCalls.signatureRequest);
+ *
+ * // Then send the prepared calls with the signature
+ * const result = await client.sendPreparedCalls({
+ *   ...preparedCalls,
+ *   signature: signedRequest.signature,
+ * });
+ */
 export async function sendPreparedCalls(
   client: InnerWalletApiClient,
   params: SendPreparedCallsParams,

package/src/client/actions/signMessage.ts

@@ -5,13 +5,30 @@ import {
   type JsonRpcAccount,
   type SignableMessage,
 } from "viem";
-import type { InnerWalletApiClient } from "../../types";
+import type { InnerWalletApiClient } from "../../types.ts";
 import { requestAccount } from "./requestAccount.js";
 
-export type SignMessageParams = SignableMessage;
+export type SignMessageParams = { message: SignableMessage; account?: Address };
 
 export type SignMessageResult = Hex;
 
+/**
+ * Signs a message using the smart account.
+ * This method requests the account associated with the signer and uses it to sign the message.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer of the smart account
+ * @param {SignableMessage} message - The message to sign
+ * @returns {Promise<SignMessageResult>} A Promise that resolves to the signed message as a hex string
+ *
+ * @example
+ * // Sign a simple text message
+ * const signature = await client.signMessage("Hello, world!");
+ *
+ * @example
+ * // Sign a raw hex message
+ * const signature = await client.signMessage({ raw: "0x48656c6c6f2c20776f726c6421" });
+ */
 export async function signMessage<
   TAccount extends JsonRpcAccount<Address> | undefined =
     | JsonRpcAccount<Address>
@@ -27,6 +44,9 @@ export async function signMessage(
   signer: SmartAccountSigner,
   params: SignMessageParams,
 ): Promise<SignMessageResult> {
-  const account = await requestAccount(client, signer);
-  return account.signMessageWith6492({ message: params });
+  const account = await requestAccount(client, signer, {
+    accountAddress: params.account ?? client.account?.address,
+  });
+
+  return account.signMessageWith6492({ message: params.message });
 }

package/src/client/actions/signSignatureRequest.ts

@@ -1,16 +1,50 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { Static } from "@sinclair/typebox";
-import { type Hex } from "viem";
+import { type Hex, toHex } from "viem";
 import { TypeSignatureRequest } from "../../schemas.js";
 import { assertNever } from "../../utils.js";
+import type { Eip7702ExtendedFields } from "@aa-sdk/core";
 
 export type SignSignatureRequestParams = Static<typeof TypeSignatureRequest>;
 
 export type SignSignatureRequestResult = {
   type: "ecdsa";
   signature: Hex;
+  signedAuthorization?: Eip7702ExtendedFields["eip7702Auth"];
 };
 
+/**
+ * Signs a signature request using the provided signer.
+ * This method handles different types of signature requests including personal_sign and eth_signTypedData_v4.
+ *
+ * @param {SmartAccountSigner} signer - The signer to use for signing the request
+ * @param {SignSignatureRequestParams} params - The signature request parameters
+ * @param {string} params.type - The type of signature request ('personal_sign', 'eth_signTypedData_v4', or 'signature_with_authorization')
+ * @param {any} params.data - The data to sign, format depends on the signature type
+ * @returns {Promise<SignSignatureRequestResult>} A Promise that resolves to the signature result
+ * @returns {string} result.type - The signature type (currently only 'ecdsa' is supported)
+ * @returns {Hex} result.signature - The hex-encoded signature
+ * @returns {Eip7702ExtendedFields["eip7702Auth"]} result.signedAuthorization - The signed EIP-7702 authorization, if applicable
+ *
+ * @example
+ * // Sign a personal message
+ * const result = await client.signSignatureRequest({
+ *   type: 'personal_sign',
+ *   data: 'Hello, world!'
+ * });
+ *
+ * @example
+ * // Sign typed data (EIP-712)
+ * const result = await client.signSignatureRequest({
+ *   type: 'eth_signTypedData_v4',
+ *   data: {
+ *     domain: { ... },
+ *     types: { ... },
+ *     primaryType: '...',
+ *     message: { ... }
+ *   }
+ * });
+ */
 export function signSignatureRequest(
   signer: SmartAccountSigner,
   params: SignSignatureRequestParams,
@@ -27,8 +61,33 @@ export async function signSignatureRequest(
         ? await signer.signTypedData(params.data)
         : assertNever(params, "Unexpected signature request type");
 
+  if (!params.authorizationRequest) {
+    return {
+      type: "ecdsa" as const,
+      signature,
+    };
+  }
+
+  if (!signer.signAuthorization) {
+    throw new Error("Signer does not implement signAuthorization");
+  }
+
+  const authSig = await signer.signAuthorization(params.authorizationRequest);
+  const { r, s } = authSig;
+  const yParity = toHex(authSig.yParity ?? authSig.v - 27n);
+
+  const signedAuthorization = {
+    chainId: toHex(params.authorizationRequest.chainId),
+    nonce: toHex(params.authorizationRequest.nonce),
+    address: params.authorizationRequest.address,
+    r,
+    s,
+    yParity,
+  };
+
   return {
-    type: "ecdsa",
+    type: "ecdsa" as const,
     signature,
+    signedAuthorization,
   };
 }