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

package/src/client/actions/signTypedData.ts

@@ -5,13 +5,46 @@ import {
   type JsonRpcAccount,
   type TypedDataDefinition,
 } from "viem";
-import type { InnerWalletApiClient } from "../../types";
+import type { InnerWalletApiClient } from "../../types.ts";
 import { requestAccount } from "./requestAccount.js";
 
-export type SignTypedDataParams = TypedDataDefinition;
+export type SignTypedDataParams = TypedDataDefinition & {
+  account?: Address;
+};
 
 export type SignTypedDataResult = Hex;
 
+/**
+ * Signs typed data (EIP-712) using the smart account.
+ * This method requests the account associated with the signer and uses it to sign the typed data.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer of the smart account
+ * @param {TypedDataDefinition} params - The typed data to sign, following EIP-712 format
+ * @returns {Promise<SignTypedDataResult>} A Promise that resolves to the signature as a hex string
+ *
+ * @example
+ * // Sign typed data
+ * const signature = await client.signTypedData({
+ *   domain: {
+ *     name: 'Example DApp',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC'
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' }
+ *     ]
+ *   },
+ *   primaryType: 'Person',
+ *   message: {
+ *     name: 'John Doe',
+ *     wallet: '0xAaAaAaAaAaAaAaAaAaAAAAAAAAaaaAaAaAaaAaAa'
+ *   }
+ * });
+ */
 export async function signTypedData<
   TAccount extends JsonRpcAccount<Address> | undefined =
     | JsonRpcAccount<Address>
@@ -27,6 +60,9 @@ export async function signTypedData(
   signer: SmartAccountSigner,
   params: SignTypedDataParams,
 ): Promise<SignTypedDataResult> {
-  const account = await requestAccount(client, signer);
+  const account = await requestAccount(client, signer, {
+    accountAddress: params.account ?? client.account?.address,
+  });
+
   return account.signTypedDataWith6492(params);
 }

package/src/client/client.e2e-test.ts

@@ -32,6 +32,27 @@ describe("Client E2E Tests", () => {
       transport,
     });
 
+    it("should successfully request account with different salt", async () => {
+      const account = await client.requestAccount({
+        id: "2d00c64e-2e55-4925-832e-e288dbf1139e",
+        creationHint: { salt: "0x1" },
+      });
+
+      expect(account.address).toMatchInlineSnapshot(
+        `"0x569bCECaC47Ef9706c4b2370f2891bccd4cdE30c"`,
+      );
+    });
+
+    it("should not cache account if different inputs provided", async () => {
+      const account = await client.requestAccount();
+      const account2 = await client.requestAccount({
+        id: "2d00c64e-2e55-4925-832e-e288dbf1139e",
+        creationHint: { salt: "0x1" },
+      });
+
+      expect(account.address).not.toEqual(account2.address);
+    });
+
     it("should successfully get a counterfactual address", async () => {
       const account = await client.requestAccount();
       expect(account.address).toMatchInlineSnapshot(
@@ -42,14 +63,10 @@ describe("Client E2E Tests", () => {
     it("can correctly sign a message", async () => {
       const account = await client.requestAccount();
       const message = "hello world";
-      const signature = await client.signMessage(message);
-      const publicClient = createPublicClient({
-        chain: arbitrumSepolia,
-        transport,
-      });
+      const signature = await client.signMessage({ message });
       const isValid = await publicClient.verifyMessage({
         address: account.address,
-        message: "hello world",
+        message,
         signature,
       });
       expect(isValid).toBeTrue();
@@ -66,9 +83,46 @@ describe("Client E2E Tests", () => {
       expect(isValid).toBeTrue();
     });
 
+    it("can correctly sign a message with a different account", async () => {
+      const account = await client.requestAccount({
+        id: "2d00c64e-2e55-4925-832e-e288dbf1139e",
+        creationHint: { salt: "0x1" },
+      });
+      const message = "hello world";
+
+      const signature = await client.signMessage({
+        message,
+        account: account.address,
+      });
+      const isValid = await publicClient.verifyMessage({
+        address: account.address,
+        message,
+        signature,
+      });
+      expect(isValid).toBeTrue();
+    });
+
+    it("can correctly sign typed data with a different account", async () => {
+      const account = await client.requestAccount({
+        id: "2d00c64e-2e55-4925-832e-e288dbf1139e",
+        creationHint: { salt: "0x1" },
+      });
+
+      const signature = await client.signTypedData({
+        ...givenTypedData,
+        account: account.address,
+      });
+      const isValid = await publicClient.verifyTypedData({
+        ...givenTypedData,
+        signature,
+        address: account.address,
+      });
+      expect(isValid).toBeTrue();
+    });
+
     it("should successfully send a UO with paymaster", async () => {
       const account = await client.requestAccount();
-      const preparedUO = await client.prepareCalls({
+      const preparedCall = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -78,20 +132,13 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      if (preparedUO.signatureRequest.type !== "personal_sign") {
-        throw new Error("Invalid signature request type");
-      }
-
-      const signature = await signer.signMessage(
-        preparedUO.signatureRequest.data,
+      const signature = await client.signSignatureRequest(
+        preparedCall.signatureRequest,
       );
 
       const result = await client.sendPreparedCalls({
-        ...preparedUO,
-        signature: {
-          type: "ecdsa",
-          signature,
-        },
+        ...preparedCall,
+        signature,
       });
 
       expect(result.preparedCallIds).toBeArrayOfSize(1);
@@ -112,7 +159,7 @@ describe("Client E2E Tests", () => {
         permissions: [{ type: "root" }],
       });
 
-      const preparedUO = await client.prepareCalls({
+      const preparedCall = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -125,11 +172,11 @@ describe("Client E2E Tests", () => {
 
       const signature = await signSignatureRequest(
         sessionKey,
-        preparedUO.signatureRequest,
+        preparedCall.signatureRequest,
       );
 
       const result = await client.sendPreparedCalls({
-        ...preparedUO,
+        ...preparedCall,
         signature,
         capabilities: {
           permissions,
@@ -164,14 +211,31 @@ describe("Client E2E Tests", () => {
       );
     });
 
+    it("should successfully request account with different salt", async () => {
+      const account = await client.requestAccount({
+        id: "8670d2d8-2781-49e9-a75c-1eb980271ca9",
+        creationHint: { salt: "0x1" },
+      });
+
+      expect(account.address).toMatchInlineSnapshot(
+        `"0xC9B8271E44f14be83CecfDE1dDb325e9fa15e9Ff"`,
+      );
+    });
+
+    it("should not cache account if different inputs provided", async () => {
+      const account = await client.requestAccount();
+      const account2 = await client.requestAccount({
+        id: "8670d2d8-2781-49e9-a75c-1eb980271ca9",
+        creationHint: { salt: "0x1" },
+      });
+
+      expect(account.address).not.toEqual(account2.address);
+    });
+
     it("can correctly sign a message", async () => {
       const account = await client.requestAccount();
       const message = "hello world";
-      const signature = await client.signMessage(message);
-      const publicClient = createPublicClient({
-        chain: arbitrumSepolia,
-        transport,
-      });
+      const signature = await client.signMessage({ message });
       const isValid = await publicClient.verifyMessage({
         address: account.address,
         message: "hello world",
@@ -191,9 +255,47 @@ describe("Client E2E Tests", () => {
       expect(isValid).toBeTrue();
     });
 
+    it("can correctly sign a message with a different account", async () => {
+      const account = await client.requestAccount({
+        id: "8670d2d8-2781-49e9-a75c-1eb980271ca9",
+        creationHint: { salt: "0x1" },
+      });
+
+      const message = "hello world";
+      const signature = await client.signMessage({
+        message,
+        account: account.address,
+      });
+      const isValid = await publicClient.verifyMessage({
+        address: account.address,
+        message: "hello world",
+        signature,
+      });
+      expect(isValid).toBeTrue();
+    });
+
+    it("can correctly sign typed data with a different account", async () => {
+      const account = await client.requestAccount({
+        id: "8670d2d8-2781-49e9-a75c-1eb980271ca9",
+        creationHint: { salt: "0x1" },
+      });
+
+      const signature = await client.signTypedData({
+        ...givenTypedData,
+        account: account.address,
+      });
+
+      const isValid = await publicClient.verifyTypedData({
+        ...givenTypedData,
+        signature,
+        address: account.address,
+      });
+      expect(isValid).toBeTrue();
+    });
+
     it("should successfully send a UO with paymaster", async () => {
       const account = await client.requestAccount();
-      const preparedUO = await client.prepareCalls({
+      const preparedCall = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -204,11 +306,11 @@ describe("Client E2E Tests", () => {
       });
 
       const signature = await client.signSignatureRequest(
-        preparedUO.signatureRequest,
+        preparedCall.signatureRequest,
       );
 
       const result = await client.sendPreparedCalls({
-        ...preparedUO,
+        ...preparedCall,
         signature,
       });
 
@@ -230,7 +332,7 @@ describe("Client E2E Tests", () => {
         permissions: [{ type: "root" }],
       });
 
-      const preparedUO = await client.prepareCalls({
+      const preparedCall = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -243,11 +345,11 @@ describe("Client E2E Tests", () => {
 
       const signature = await signSignatureRequest(
         sessionKey,
-        preparedUO.signatureRequest,
+        preparedCall.signatureRequest,
       );
 
       const result = await client.sendPreparedCalls({
-        ...preparedUO,
+        ...preparedCall,
         signature,
         capabilities: {
           permissions,

package/src/client/decorator.ts

@@ -1,15 +1,10 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import type {
-  Hex,
-  JsonRpcAccount,
-  SignableMessage,
-  TypedDataDefinition,
-} from "viem";
+import type { Hex, JsonRpcAccount } from "viem";
 import type {
   SendPreparedCallsParams,
   SendPreparedCallsResult,
-} from "../isomorphic/actions/sendPreparedCalls";
-import type { InnerWalletApiClient } from "../types";
+} from "../isomorphic/actions/sendPreparedCalls.ts";
+import type { InnerWalletApiClient } from "../types.ts";
 import {
   createAccount,
   type CreateAccountParams,
@@ -41,13 +36,16 @@ import {
   type RequestAccountResult,
 } from "./actions/requestAccount.js";
 import { sendPreparedCalls } from "./actions/sendPreparedCalls.js";
-import { signMessage } from "./actions/signMessage.js";
+import { signMessage, type SignMessageParams } from "./actions/signMessage.js";
 import {
   signSignatureRequest,
   type SignSignatureRequestParams,
   type SignSignatureRequestResult,
 } from "./actions/signSignatureRequest.js";
-import { signTypedData } from "./actions/signTypedData.js";
+import {
+  signTypedData,
+  type SignTypedDataParams,
+} from "./actions/signTypedData.js";
 
 export type SmartWalletActions<
   TAccount extends JsonRpcAccount | undefined = JsonRpcAccount | undefined,
@@ -69,8 +67,8 @@ export type SmartWalletActions<
   signSignatureRequest: (
     params: SignSignatureRequestParams,
   ) => Promise<SignSignatureRequestResult>;
-  signMessage: (params: SignableMessage) => Promise<Hex>;
-  signTypedData: (params: TypedDataDefinition) => Promise<Hex>;
+  signMessage: (params: SignMessageParams) => Promise<Hex>;
+  signTypedData: (params: SignTypedDataParams) => Promise<Hex>;
   grantPermissions: (
     params: GrantPermissionsParams<TAccount>,
   ) => Promise<GrantPermissionsResult>;

package/src/client/index.ts

@@ -1,19 +1,19 @@
-import { type SmartAccountSigner } from "@aa-sdk/core";
-import { type AlchemyTransport } from "@account-kit/infra";
-import {
-  type Address,
-  type Chain,
-  type IsUndefined,
-  type JsonRpcAccount,
-  type Prettify,
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type {
+  Address,
+  Chain,
+  IsUndefined,
+  JsonRpcAccount,
+  Prettify,
 } from "viem";
 import { createLocalClient } from "../local/client.js";
 import { createRemoteClient } from "../remote/client.js";
-import type { InnerWalletApiClient } from "../types";
+import type { InnerWalletApiClient } from "../types.ts";
 import {
   smartWalletClientActions,
   type SmartWalletActions,
 } from "./decorator.js";
+import type { AlchemyTransport } from "@account-kit/infra";
 
 export type SmartWalletClientParams<
   TAccount extends JsonRpcAccount<Address> | undefined =
@@ -49,7 +49,38 @@ export function createSmartWalletClient<
   params: SmartWalletClientParams<TAccount>,
 ): InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
 
-export function createSmartWalletClient(params: SmartWalletClientParams) {
+/**
+ * Creates a smart wallet client that can be used to interact with a smart account.
+ *
+ * @param {SmartWalletClientParams} params - The parameters for creating the smart wallet client
+ * @param {AlchemyTransport} params.transport - The Alchemy transport to use
+ * @param {Chain} params.chain - The chain to use
+ * @param {SmartAccountSigner} params.signer - The signer to use for the smart account
+ * @param {"local" | "remote"} params.mode - The client's mode (local or remote).
+ * @param {string} [params.policyId] - The policy ID for gas sponsorship (optional)
+ * @param {Address} [params.account] - The smart account address to use (optional)
+ * @returns {InnerWalletApiClient & SmartWalletActions} - A viem-compatible client
+ *
+ * @example
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { alchemy, arbitrumSepolia } from "@account-kit/infra";
+ * import { generatePrivateKey } from "viem/accounts";
+ * import { createSmartWalletClient } from "@account-kit/wallet-client";
+ *
+ * const signer = LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey());
+ * const transport = alchemy({
+ *   apiKey: "your-alchemy-api-key",
+ * });
+ * const client = createSmartWalletClient({
+ *   transport,
+ *   chain: arbitrumSepolia,
+ *   mode: "remote",
+ *   signer,
+ * });
+ */
+export function createSmartWalletClient(
+  params: SmartWalletClientParams,
+): InnerWalletApiClient & SmartWalletActions {
   const { transport, chain, policyId, mode, account, signer } = params;
 
   const innerClient =

package/src/exports/index.ts

@@ -30,3 +30,4 @@ export { requestAccount } from "../client/actions/requestAccount.js";
 export { signMessage } from "../client/actions/signMessage.js";
 export { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
 export { signTypedData } from "../client/actions/signTypedData.js";
+export { grantPermissions } from "../client/actions/grantPermissions.js";

package/src/exports/internal.ts

@@ -12,5 +12,5 @@ export * from "../rpc/request.js";
 export * as RpcSchemas from "../rpc/request.js";
 export * from "../rpc/schema.js";
 export * from "../schemas.js";
-export type * from "../types";
+export type * from "../types.ts";
 export * from "../utils.js";

package/src/internal/decorator.ts

@@ -0,0 +1,12 @@
+import type { CachedAccount, InternalState } from "../types.ts";
+
+export function internalStateDecorator(): InternalState {
+  let account: CachedAccount | undefined = undefined;
+
+  return {
+    setAccount: (newAccount: CachedAccount) => {
+      account = newAccount;
+    },
+    getAccount: () => account,
+  };
+}

package/src/isomorphic/actions/createSession.ts

@@ -24,6 +24,8 @@ import type { wallet_createSession } from "../../rpc/request.js";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { createAccount, isModularAccountV2 } from "../utils/createAccount.js";
 import { createDummySigner } from "../utils/createDummySigner.js";
+import { createAuthorization } from "../utils/7702.js";
+import { InvalidRequestError } from "ox/RpcResponse";
 
 export type CreateSessionParams = Omit<
   Static<
@@ -57,17 +59,20 @@ export async function createSession(
     throw new ChainNotFoundError();
   }
 
-  const { counterfactualInfo } = await client.request({
+  const { counterfactualInfo, delegation } = await client.request({
     method: "wallet_requestAccount",
     params: [
       {
-        includeCounterfactualInfo: true,
         accountAddress: params.account,
+        includeCounterfactualInfo: true,
       },
     ],
   });
-  if (!counterfactualInfo) {
-    throw new Error("No counterfactual info found.");
+  if (!counterfactualInfo && !delegation) {
+    throw new InvalidRequestError({
+      message:
+        "No counterfactual info or delegated implementation address found.",
+    });
   }
 
   const account = await createAccount({
@@ -76,10 +81,13 @@ export async function createSession(
     signer: createDummySigner(params.account),
     accountAddress: params.account,
     counterfactualInfo,
+    delegation,
   });
 
   if (!isModularAccountV2(account)) {
-    throw new Error("Sessions are currently only supported by MAv2 accounts.");
+    throw new InvalidRequestError({
+      message: "Sessions are currently only supported by MAv2 accounts.",
+    });
   }
 
   const _client = createSmartAccountClient({
@@ -108,12 +116,25 @@ export async function createSession(
       })
       .compileDeferred();
 
+  // If using 7702, we need an Authorization (unless it's already authorized).
+  const authorizationRequest = delegation
+    ? await createAuthorization(client, {
+        address: account.address,
+        delegation,
+      })
+    : undefined;
+
+  const signatureRequest = {
+    type: "eth_signTypedData_v4" as const,
+    data: typedData,
+  };
+
   return {
     sessionId: null, // In remote mode, the server will set this later.
     entityId: toHex(entityId),
     signatureRequest: {
-      type: "eth_signTypedData_v4",
-      data: typedData,
+      ...signatureRequest,
+      ...(authorizationRequest ? { authorizationRequest } : {}),
     },
     fullPreSignatureDeferredActionDigest,
   };

package/src/isomorphic/actions/prepareCalls.ts

@@ -1,5 +1,6 @@
 import {
   deepHexlify,
+  default7702GasEstimator,
   type SmartAccountClient,
   type SmartContractAccount,
 } from "@aa-sdk/core";
@@ -9,7 +10,6 @@ import {
   custom,
   fromHex,
   toHex,
-  zeroAddress,
   type Chain,
   type Transport,
 } from "viem";
@@ -17,6 +17,8 @@ import type { wallet_prepareCalls } from "../../rpc/request.js";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { createAccount } from "../utils/createAccount.js";
 import { createDummySigner } from "../utils/createDummySigner.js";
+import { createAuthorization } from "../utils/7702.js";
+import { InvalidRequestError } from "ox/RpcResponse";
 
 export type PrepareCallsParams = Omit<
   Static<
@@ -29,7 +31,6 @@ export type PrepareCallsResult = Static<
   (typeof wallet_prepareCalls)["properties"]["ReturnType"]
 >;
 
-// TODO: handle capabilities like permissions and paymaster here
 export async function prepareCalls(
   client: SmartAccountClient<
     Transport,
@@ -45,7 +46,7 @@ export async function prepareCalls(
   }
 
   // in local mode, we probably want some kind of caching for this
-  const { counterfactualInfo } = await client.request({
+  const { counterfactualInfo, delegation } = await client.request({
     method: "wallet_requestAccount",
     params: [
       {
@@ -54,19 +55,37 @@ export async function prepareCalls(
       },
     ],
   });
-  if (!counterfactualInfo) {
-    throw new Error("No counterfactual info found.");
+
+  if (!counterfactualInfo && !delegation) {
+    throw new InvalidRequestError({
+      message:
+        "No counterfactual info or delegated implementation address found.",
+    });
   }
 
   const account = await createAccount({
     chain: client.chain,
     transport: custom(client.transport),
-    signer: createDummySigner(zeroAddress),
+    signer: createDummySigner(params.from),
     accountAddress: params.from,
     counterfactualInfo,
     capabilities: params.capabilities,
+    delegation,
   });
 
+  // If using 7702, we need an Authorization (unless it's already authorized).
+  const authorizationRequest = delegation
+    ? await createAuthorization(client, {
+        address: account.address,
+        delegation,
+      })
+    : undefined;
+
+  if (authorizationRequest) {
+    // @ts-expect-error - this is available but not typed as public
+    client.middleware.gasEstimator = default7702GasEstimator();
+  }
+
   // TODO: oops we don't actually support setting the policyId as an override here
   // if we assume that the the isomorphic client is never used directly, then we can assume that this is handled upstream correctly
   const builtUo = await client.buildUserOperation({
@@ -79,9 +98,19 @@ export async function prepareCalls(
     overrides: params.capabilities?.gasParamsOverride,
   });
 
+  // The eip7702Auth field should never be included in the UO sig
+  // request. It's handled by the separate authorization request.
+  if ("eip7702Auth" in builtUo) {
+    builtUo.eip7702Auth = undefined;
+  }
   const uoRequest = deepHexlify(builtUo);
 
-  const hash = account.getEntryPoint().getUserOperationHash(uoRequest);
+  const signatureRequest = {
+    type: "personal_sign" as const,
+    data: {
+      raw: account.getEntryPoint().getUserOperationHash(uoRequest),
+    },
+  };
 
   return {
     type:
@@ -91,10 +120,8 @@ export async function prepareCalls(
     data: uoRequest,
     chainId: toHex(client.chain.id),
     signatureRequest: {
-      type: "personal_sign",
-      data: {
-        raw: hash,
-      },
+      ...signatureRequest,
+      ...(authorizationRequest ? { authorizationRequest } : {}),
     },
   };
 }