@account-kit/wallet-client 0.1.0-alpha.5 → 0.1.0-alpha.7

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/client/actions/grantPermissions.ts

@@ -1,8 +1,6 @@
 import { AccountNotFoundError, type SmartAccountSigner } from "@aa-sdk/core";
-import type { Static } from "@sinclair/typebox";
 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 { InnerWalletApiClient } from "../../types.ts";
 
 export type GrantPermissionsParams<
@@ -14,7 +12,6 @@ export type GrantPermissionsParams<
 
 export type GrantPermissionsResult = {
   context: Hex;
-  signedAuthorization?: Static<typeof TypeEip7702AuthExtendedFields>;
 };
 
 /**
@@ -25,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
@@ -50,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: {
@@ -62,65 +58,14 @@ 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,
  *   },

package/src/client/actions/requestAccount.ts

@@ -57,6 +57,7 @@ export async function requestAccount(
         };
 
   const cachedAccount = client.internal.getAccount();
+
   if (
     cachedAccount &&
     ((args.accountAddress &&
@@ -66,17 +67,18 @@ export async function requestAccount(
     return cachedAccount.account;
   }
 
-  const { counterfactualInfo, accountAddress } = await client.request({
-    method: "wallet_requestAccount",
-    params: [args],
-  });
+  const { accountAddress, counterfactualInfo, delegation } =
+    await client.request({
+      method: "wallet_requestAccount",
+      params: [args],
+    });
 
   const account = await createAccount({
     accountAddress,
-    counterfactualInfo: Value.Parse(
-      TypeSerializedInitcode,
-      counterfactualInfo!,
-    ),
+    counterfactualInfo: counterfactualInfo
+      ? Value.Parse(TypeSerializedInitcode, counterfactualInfo)
+      : undefined,
+    delegation,
     chain: client.chain,
     transport: custom(client.transport),
     signer,

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/signPreparedCalls.ts

@@ -0,0 +1,72 @@
+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 { signatureRequest: _signatureRequest, ...rest } = call;
+            const signature = await signSignatureRequest(signer, {
+              type: "eip7702Auth",
+              data: {
+                ...call.data,
+                chainId: call.chainId,
+              },
+            });
+            return {
+              ...rest,
+              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");
+          }
+        }
+      }),
+    ),
+  };
+}

package/src/client/actions/signSignatureRequest.ts

@@ -1,21 +1,30 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { Static } from "@sinclair/typebox";
-import { type Hex, toHex } from "viem";
-import { TypeSignatureRequest, type TypeSignatureType } from "../../schemas.js";
+import { type Hex, hexToNumber, serializeSignature } from "viem";
 import { assertNever } from "../../utils.js";
-import type { Eip7702ExtendedFields } from "@aa-sdk/core";
+import {
+  TypeAuthorizationSignatureRequest,
+  TypePersonalSignSignatureRequest,
+  TypeTypedDataSignatureRequest,
+} from "../../schemas.js";
+import { TypeEip7702UnsignedAuth } from "../../schemas.js";
+import { vToYParity } from "ox/Signature";
 
-export type SignSignatureRequestParams = Static<typeof TypeSignatureRequest>;
+export type SignSignatureRequestParams =
+  | Static<typeof TypePersonalSignSignatureRequest>
+  | Static<typeof TypeTypedDataSignatureRequest>
+  | (Static<typeof TypeAuthorizationSignatureRequest> & {
+      data: Static<typeof TypeEip7702UnsignedAuth>;
+    });
 
 export type SignSignatureRequestResult = {
-  type: Exclude<TypeSignatureType, "contract">; // TODO: Add support for identifying contract signatures
-  signature: Hex;
-  signedAuthorization?: Eip7702ExtendedFields["eip7702Auth"];
+  type: "secp256k1";
+  data: Hex;
 };
 
 /**
  * Signs a signature request using the provided signer.
- * This method handles different types of signature requests including personal_sign and eth_signTypedData_v4.
+ * This method handles different types of signature requests including personal_sign, eth_signTypedData_v4, and authorization.
  *
  * @param {SmartAccountSigner} signer - The signer to use for signing the request
  * @param {SignSignatureRequestParams} params - The signature request parameters
@@ -45,49 +54,44 @@ export type SignSignatureRequestResult = {
  *   }
  * });
  */
-export function signSignatureRequest(
-  signer: SmartAccountSigner,
-  params: SignSignatureRequestParams,
-): Promise<SignSignatureRequestResult>;
 
 export async function signSignatureRequest(
   signer: SmartAccountSigner,
   params: SignSignatureRequestParams,
 ): Promise<SignSignatureRequestResult> {
-  const signature =
-    params.type === "personal_sign"
-      ? await signer.signMessage(params.data)
-      : params.type === "eth_signTypedData_v4"
-        ? await signer.signTypedData(params.data)
-        : assertNever(params, "Unexpected signature request type");
-
-  if (!params.authorizationRequest) {
-    return {
-      type: "secp256k1" as const,
-      signature,
-    };
-  }
+  switch (params.type) {
+    case "personal_sign": {
+      return {
+        type: "secp256k1",
+        data: await signer.signMessage(params.data),
+      };
+    }
+    case "eth_signTypedData_v4": {
+      return {
+        type: "secp256k1",
+        data: await signer.signTypedData(params.data),
+      };
+    }
+    case "eip7702Auth": {
+      if (!signer.signAuthorization) {
+        throw new Error("Signer does not implement signAuthorization");
+      }
+      const { r, s, v, yParity } = await signer.signAuthorization({
+        ...params.data,
+        chainId: hexToNumber(params.data.chainId),
+        nonce: hexToNumber(params.data.nonce),
+      });
 
-  if (!signer.signAuthorization) {
-    throw new Error("Signer does not implement signAuthorization");
+      return {
+        type: "secp256k1",
+        data: serializeSignature({
+          r,
+          s,
+          yParity: yParity ?? vToYParity(Number(v)),
+        }),
+      };
+    }
+    default:
+      return assertNever(params, `Unexpected signature request type.`);
   }
-
-  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: "secp256k1" as const,
-    signature,
-    signedAuthorization,
-  };
 }