@account-kit/wallet-client 0.1.0-alpha.4 → 0.1.0-alpha.6

package/src/capabilities/eip7702Auth.ts

@@ -0,0 +1,26 @@
+import { Type } from "@sinclair/typebox";
+import { TypeAddress } from "../schemas.js";
+import {
+  EIP_7702_ACCOUNT_TYPE,
+  SUPPORTED_DELEGATION_ADDRESSES,
+} from "../isomorphic/utils/7702.js";
+
+export const Eip7702AuthCapability = Type.Union([
+  Type.Object(
+    {
+      account: Type.Optional(TypeAddress),
+      // Wallet applications must maintain a strict shortlist of well-known accounts.
+      // https://github.com/ethereum/ERCs/pull/947/files#diff-dab085f963ca621595044bcbc0922705aa38b69f5bf8770dcb3d0496a633efcfR189
+      delegation: Type.Union([
+        ...SUPPORTED_DELEGATION_ADDRESSES.map((address) =>
+          Type.Literal(address),
+        ),
+        ...EIP_7702_ACCOUNT_TYPE.map((it) => Type.Literal(it)),
+      ]),
+    },
+    {
+      description: "Specify EIP-7702 delegation",
+    },
+  ),
+  Type.Literal(true, { description: "Default EIP-7702 delegation" }),
+]);

package/src/capabilities/index.ts

@@ -2,9 +2,11 @@ import { Type } from "@sinclair/typebox";
 import { GasParamsOverrideCapability } from "./overrides.js";
 import { PaymasterCapability } from "./paymaster.js";
 import { PermissionsCapability } from "./permissions/index.js";
+import { Eip7702AuthCapability } from "./eip7702Auth.js";
 
 export const Capabilities = Type.Object({
   permissions: Type.Optional(PermissionsCapability),
   paymasterService: Type.Optional(PaymasterCapability),
   gasParamsOverride: Type.Optional(GasParamsOverrideCapability),
+  eip7702Auth: Type.Optional(Eip7702AuthCapability),
 });

package/src/capabilities/overrides.ts

@@ -3,32 +3,32 @@ import { TypeHex } from "../schemas.js";
 
 export const Mutliplier = Type.Object(
   { multiplier: Type.Number() },
-  { title: "Multiplier" },
+  { description: "Multiplier" },
 );
 
 // This is still being defined in https://github.com/ethereum/ERCs/pull/947/files#diff-dab085f963ca621595044bcbc0922705aa38b69f5bf8770dcb3d0496a633efcfR158
 export const GasParamsOverrideCapability = Type.Object(
   {
     preVerificationGas: Type.Optional(
-      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
     ),
     verificationGasLimit: Type.Optional(
-      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
     ),
     callGasLimit: Type.Optional(
-      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
     ),
     paymasterVerificationGasLimit: Type.Optional(
-      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
     ),
     paymasterPostOpGasLimit: Type.Optional(
-      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
     ),
     maxFeePerGas: Type.Optional(
-      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
     ),
     maxPriorityFeePerGas: Type.Optional(
-      Type.Union([TypeHex({ title: "Absolute" }), Mutliplier]),
+      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
     ),
   },
   { minProperties: 1 },

package/src/capabilities/permissions/index.ts

@@ -129,7 +129,7 @@ export const PermissionsContext = Type.Object(
     context: TypeHex(),
   },
   {
-    title: "Permissions context",
+    description: "Permissions context",
   },
 );
 
@@ -139,13 +139,18 @@ export const RemotePermission = Type.Object(
     signature: TypeHex(),
   },
   {
-    title: "Remote permission",
+    description: "Remote permission",
   },
 );
 
 export const PermissionsData = Type.Object({
   chainId: TypeHex(),
-  expiry: Type.Optional(Type.Integer()),
+  expirySec: Type.Optional(
+    Type.Integer({
+      maximum: 9999999999, // This is valid until November 20, 2286.
+      description: "Unix timestamp in seconds (0 for no expiry)",
+    }),
+  ),
   key: KeySigner,
   permissions: PermissionsArray,
 });

package/src/capabilities/permissions/mav2.ts

@@ -121,6 +121,7 @@ export const prefixSignatureKeyType = (
   type: KeySigner["type"],
 ): Hex => {
   switch (type) {
+    case "ecdsa":
     case "secp256k1":
       return concatHex(["0x00", sig]);
     case "contract":

package/src/client/actions/getCallsStatus.ts

@@ -1,4 +1,3 @@
-import type { Address, JsonRpcAccount } from "viem";
 import type {
   GetCallsStatusParams as IsomorphicGetCallsStatusParams,
   GetCallsStatusResponse as IsomorphicGetCallsStatusResult,
@@ -28,15 +27,6 @@ export type GetCallsStatusResult = IsomorphicGetCallsStatusResult;
  * // 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>
-    | undefined,
->(
-  client: InnerWalletApiClient<TAccount>,
-  params: GetCallsStatusParams,
-): Promise<GetCallsStatusResult>;
-
 export async function getCallsStatus(
   client: InnerWalletApiClient,
   params: GetCallsStatusParams,

package/src/client/actions/grantPermissions.ts

@@ -1,20 +1,10 @@
-import {
-  type Address,
-  type Hex,
-  type IsUndefined,
-  type JsonRpcAccount,
-  toHex,
-} from "viem";
-import type { InnerWalletApiClient } from "../../types.ts";
-import type { SmartAccountSigner } from "@aa-sdk/core";
+import { AccountNotFoundError, type SmartAccountSigner } from "@aa-sdk/core";
+import { type Address, type Hex, type IsUndefined, toHex } from "viem";
 import type { CreateSessionParams } from "../../isomorphic/actions/createSession.ts";
-import { TypeEip7702AuthExtendedFields } from "../../schemas.js";
-import type { Static } from "@sinclair/typebox";
+import type { InnerWalletApiClient } from "../../types.ts";
 
 export type GrantPermissionsParams<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
+  TAccount extends Address | undefined = Address | undefined,
 > = Omit<CreateSessionParams, "account" | "chainId"> &
   (IsUndefined<TAccount> extends true
     ? { account: Address }
@@ -22,7 +12,6 @@ export type GrantPermissionsParams<
 
 export type GrantPermissionsResult = {
   context: Hex;
-  signedAuthorization?: Static<typeof TypeEip7702AuthExtendedFields>;
 };
 
 /**
@@ -33,14 +22,13 @@ export type GrantPermissionsResult = {
  * @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 {number} params.expirySec - 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
@@ -58,7 +46,7 @@ export type GrantPermissionsResult = {
  * });
  *
  * // Use the permissions to prepare a call
- * const preparedCall = await client.prepareCalls({
+ * const preparedCalls = await client.prepareCalls({
  *   calls: [{ to: zeroAddress, value: "0x0" }],
  *   from: account.address,
  *   capabilities: {
@@ -70,91 +58,35 @@ export type GrantPermissionsResult = {
  * });
  *
  * // Sign with the session key
- * const signature = await signSignatureRequest(
+ * const signedCalls = await client.signPreparedCalls(
  *   sessionKey,
- *   preparedCall.signatureRequest,
+ *   preparedCalls,
  * );
  *
  * // 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,
+ *   ...signedCalls,
  *   capabilities: {
  *     permissions,
  *   },
  * });
  */
 export async function grantPermissions<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
+  TAccount extends Address | undefined = Address | undefined,
 >(
-  client: InnerWalletApiClient<TAccount>,
-  signer: SmartAccountSigner,
-  params: GrantPermissionsParams<TAccount>,
-): Promise<GrantPermissionsResult>;
-
-export async function grantPermissions(
   client: InnerWalletApiClient,
   signer: SmartAccountSigner,
-  params: GrantPermissionsParams,
+  params: GrantPermissionsParams<TAccount>,
 ): Promise<GrantPermissionsResult> {
-  if (client.account && !params.account) {
-    params.account = client.account.address;
+  const account = params.account ?? client.account?.address;
+
+  if (!account) {
+    throw new AccountNotFoundError();
   }
 
   return client.grantPermissions(signer, {
     ...params,
+    account,
     chainId: toHex(client.chain.id),
   });
 }

package/src/client/actions/prepareCalls.ts

@@ -1,9 +1,5 @@
-import {
-  toHex,
-  type Address,
-  type IsUndefined,
-  type JsonRpcAccount,
-} from "viem";
+import { AccountNotFoundError } from "@aa-sdk/core";
+import { toHex, type Address, type IsUndefined } from "viem";
 import type {
   PrepareCallsParams as IsomorphicPrepareCallsParams,
   PrepareCallsResult as IsomorphicPrepareCallsResult,
@@ -13,12 +9,10 @@ import type { InnerWalletApiClient } from "../../types.ts";
 export type GetAccountParam<TAccount> =
   IsUndefined<TAccount> extends true
     ? { account: Address }
-    : { account?: never };
+    : { account?: Address };
 
 export type PrepareCallsParams<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
+  TAccount extends Address | undefined = Address | undefined,
 > = Omit<IsomorphicPrepareCallsParams, "from" | "chainId"> &
   (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });
 
@@ -51,18 +45,17 @@ export type PrepareCallsResult = IsomorphicPrepareCallsResult;
  * });
  */
 export async function prepareCalls<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
+  TAccount extends Address | undefined = Address | undefined,
 >(
-  client: InnerWalletApiClient<TAccount>,
-  params: PrepareCallsParams<TAccount>,
-): Promise<PrepareCallsResult>;
-
-export async function prepareCalls(
   client: InnerWalletApiClient,
-  params: PrepareCallsParams,
+  params: PrepareCallsParams<TAccount>,
 ): Promise<PrepareCallsResult> {
+  const from = params.from ?? client.account?.address;
+
+  if (!from) {
+    throw new AccountNotFoundError();
+  }
+
   if (client.policyId && !params.capabilities?.paymasterService) {
     params.capabilities = {
       ...params.capabilities,
@@ -70,12 +63,14 @@ export async function prepareCalls(
     };
   }
 
-  if (client.account && !params.from) {
-    params.from = client.account.address;
-  }
+  const params_ = {
+    ...params,
+    chainId: toHex(client.chain.id),
+    from,
+  };
 
   return await client.request({
     method: "wallet_prepareCalls",
-    params: [{ ...params, chainId: toHex(client.chain.id) }],
+    params: [params_],
   });
 }

package/src/client/actions/requestAccount.ts

@@ -5,27 +5,20 @@ import {
 import type { Static } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import type { Address } from "abitype";
-import { custom, type IsUndefined, type JsonRpcAccount } from "viem";
+import deepEqual from "deep-equal";
+import { custom } from "viem";
 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 =
-    | JsonRpcAccount<Address>
-    | undefined,
-> =
-  IsUndefined<TAccount> extends true
-    ? Omit<
-        Extract<
-          Static<typeof wallet_requestAccount>["Request"]["params"][0],
-          { signerAddress: Address }
-        >,
-        "signerAddress" | "includeCounterfactualInfo"
-      > & { accountAddress?: Address }
-    : never;
+export type RequestAccountParams = Omit<
+  Extract<
+    Static<typeof wallet_requestAccount>["Request"]["params"][0],
+    { signerAddress: Address }
+  >,
+  "signerAddress" | "includeCounterfactualInfo"
+> & { accountAddress?: Address };
 
 export type RequestAccountResult = SmartContractAccount;
 
@@ -46,16 +39,6 @@ export type RequestAccountResult = SmartContractAccount;
  * const signer = LocalAccountSigner.privateKeyToAccountSigner("0x...");
  * const account = await client.requestAccount(signer);
  */
-export function requestAccount<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
->(
-  client: InnerWalletApiClient<TAccount>,
-  signer: SmartAccountSigner,
-  params?: RequestAccountParams<TAccount>,
-): Promise<RequestAccountResult>;
-
 export async function requestAccount(
   client: InnerWalletApiClient,
   signer: SmartAccountSigner,

package/src/client/actions/sendPreparedCalls.ts

@@ -1,11 +1,12 @@
-import type { Static, StaticDecode } from "@sinclair/typebox";
+import type { Static } from "@sinclair/typebox";
 import { toHex } from "viem";
 import type { wallet_sendPreparedCalls } from "../../rpc/request.ts";
-import type { InnerWalletApiClient } from "../../types.ts";
+import type { InnerWalletApiClient, WithoutChainId } from "../../types.ts";
 
-export type SendPreparedCallsParams = Omit<
-  StaticDecode<typeof wallet_sendPreparedCalls>["Request"]["params"][0],
-  "chainId"
+export type SendPreparedCallsParams = WithoutChainId<
+  Static<
+    (typeof wallet_sendPreparedCalls)["properties"]["Request"]["properties"]["params"]
+  >[0]
 >;
 
 export type SendPreparedCallsResult = Static<
@@ -18,13 +19,6 @@ export type SendPreparedCallsResult = Static<
  *
  * @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
@@ -40,13 +34,12 @@ export type SendPreparedCallsResult = Static<
  *   }
  * });
  *
- * // Sign the signature request using signSignatureRequest with your signer
- * const signedRequest = await client.signSignatureRequest(preparedCalls.signatureRequest);
+ * // Then sign the calls
+ * const signedCalls = await client.signPreparedCalls(preparedCalls);
  *
  * // Then send the prepared calls with the signature
  * const result = await client.sendPreparedCalls({
- *   ...preparedCalls,
- *   signature: signedRequest.signature,
+ *   signedCalls,
  * });
  */
 export async function sendPreparedCalls(
@@ -55,6 +48,13 @@ export async function sendPreparedCalls(
 ): Promise<SendPreparedCallsResult> {
   return client.request({
     method: "wallet_sendPreparedCalls",
-    params: [{ ...params, chainId: toHex(client.chain.id) }],
+    params: [
+      params.type === "array"
+        ? params
+        : {
+            ...params,
+            chainId: toHex(client.chain.id),
+          },
+    ],
   });
 }

package/src/client/actions/signMessage.ts

@@ -1,10 +1,5 @@
-import type { SmartAccountSigner } from "@aa-sdk/core";
-import {
-  type Address,
-  type Hex,
-  type JsonRpcAccount,
-  type SignableMessage,
-} from "viem";
+import { type SmartAccountSigner } from "@aa-sdk/core";
+import { type Address, type Hex, type SignableMessage } from "viem";
 import type { InnerWalletApiClient } from "../../types.ts";
 import { requestAccount } from "./requestAccount.js";
 
@@ -29,16 +24,6 @@ export type SignMessageResult = Hex;
  * // Sign a raw hex message
  * const signature = await client.signMessage({ raw: "0x48656c6c6f2c20776f726c6421" });
  */
-export async function signMessage<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
->(
-  client: InnerWalletApiClient<TAccount>,
-  signer: SmartAccountSigner,
-  params: SignMessageParams,
-): Promise<SignMessageResult>;
-
 export async function signMessage(
   client: InnerWalletApiClient,
   signer: SmartAccountSigner,

package/src/client/actions/signPreparedCalls.ts

@@ -0,0 +1,71 @@
+import type { PrepareCallsResult } from "./prepareCalls.ts";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import { signSignatureRequest } from "./signSignatureRequest.js";
+import type { Static } from "@sinclair/typebox";
+import { wallet_sendPreparedCalls } from "../../rpc/request.js";
+import { assertNever } from "../../utils.js";
+
+export type SignPreparedCallsParams = PrepareCallsResult;
+
+export type SignPreparedCallsResult = Static<
+  (typeof wallet_sendPreparedCalls)["properties"]["Request"]["properties"]["params"]
+>[0];
+
+/**
+ * Signs prepared calls using the provided signer.
+ *
+ * @param {SmartAccountSigner} signer - The signer to use
+ * @param {SignPreparedCallsParams} params - The prepared calls with signature requests
+ * @returns {Promise<SignPreparedCallsResult>} A Promise that resolves to the signed calls
+ **/
+export async function signPreparedCalls(
+  signer: SmartAccountSigner,
+  params: SignPreparedCallsParams,
+): Promise<SignPreparedCallsResult> {
+  if (params.type !== "array") {
+    const { signatureRequest, ...call } = params;
+    const signature = await signSignatureRequest(signer, signatureRequest);
+    return {
+      ...call,
+      signature,
+    };
+  }
+
+  return {
+    type: "array" as const,
+    data: await Promise.all(
+      params.data.map(async (call) => {
+        switch (call.type) {
+          case "authorization": {
+            const signature = await signSignatureRequest(signer, {
+              type: "eip7702Auth",
+              data: {
+                ...call.data,
+                chainId: call.chainId,
+              },
+            });
+            return {
+              ...call,
+              signature,
+            };
+          }
+          case "user-operation-v060":
+          case "user-operation-v070": {
+            const { signatureRequest, ...rest } = call;
+            const signature = await signSignatureRequest(
+              signer,
+              signatureRequest,
+            );
+            return {
+              ...rest,
+              signature,
+            };
+          }
+          default: {
+            return assertNever(call, "Unexpected call type");
+          }
+        }
+      }),
+    ),
+  };
+}