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

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

@@ -2,7 +2,6 @@ import { LocalAccountSigner } from "@aa-sdk/core";
 import { alchemy, arbitrumSepolia } from "@account-kit/infra";
 import { describe, expect, it } from "bun:test";
 import { createPublicClient, zeroAddress, type Address } from "viem";
-import { signSignatureRequest } from "./actions/signSignatureRequest.js";
 import { createSmartWalletClient } from "./index.js";
 
 describe("Client E2E Tests", () => {
@@ -17,7 +16,7 @@ describe("Client E2E Tests", () => {
   );
   describe("Local Mode Tests", () => {
     const signer = LocalAccountSigner.privateKeyToAccountSigner(
-      "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff81",
+      "0xbaca22d9b6846ec09a4da378ffa07e2f14ce7d65675d135911b6fd281416bb03",
     );
 
     const client = createSmartWalletClient({
@@ -35,21 +34,38 @@ describe("Client E2E Tests", () => {
     it("should successfully get a counterfactual address", async () => {
       const account = await client.requestAccount();
       expect(account.address).toMatchInlineSnapshot(
-        `"0x26809de7733F9CcB5c0c61210a4f78d6F1daFc58"`,
+        `"0xa46944b7a39c35d931D514ACAc3ac77c226a81ff"`,
       );
     });
 
+    it("should successfully request account with different salt", async () => {
+      const account = await client.requestAccount({
+        id: "f4c1d956-24ef-4002-a141-2c9d6d92af1a",
+        creationHint: { salt: "0x1" },
+      });
+
+      expect(account.address).toMatchInlineSnapshot(
+        `"0xA692f0E5AfAD20F771443D89C635146C6A592f06"`,
+      );
+    });
+
+    it("should not cache account if different inputs provided", async () => {
+      const account = await client.requestAccount();
+      const account2 = await client.requestAccount({
+        id: "52ab44be-b03e-47ed-ad65-43014ea5fbfc",
+        creationHint: { salt: "0x2" },
+      });
+
+      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",
+        message,
         signature,
       });
       expect(isValid).toBeTrue();
@@ -66,9 +82,62 @@ describe("Client E2E Tests", () => {
       expect(isValid).toBeTrue();
     });
 
-    it("should successfully send a UO with paymaster", async () => {
-      const account = await client.requestAccount();
-      const preparedUO = await client.prepareCalls({
+    it("can correctly sign a message with a different account", async () => {
+      const account = await client.requestAccount({
+        id: "f4c1d956-24ef-4002-a141-2c9d6d92af1a",
+        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: "f4c1d956-24ef-4002-a141-2c9d6d92af1a",
+        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 using 7702", async () => {
+      const _signer = LocalAccountSigner.privateKeyToAccountSigner(
+        "0x49daf21e92c997093e9ffdf7e7ddbf8970e9eadc5d4847d0f690db25d5128e1f",
+      );
+
+      const _client = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        mode: "local",
+        signer: _signer,
+      });
+
+      const account = await _client.requestAccount({
+        creationHint: {
+          accountType: "7702",
+        },
+      });
+
+      const preparedCalls = await _client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -78,22 +147,29 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      if (preparedUO.signatureRequest.type !== "personal_sign") {
-        throw new Error("Invalid signature request type");
-      }
+      const signedCalls = await _client.signPreparedCalls(preparedCalls);
 
-      const signature = await signer.signMessage(
-        preparedUO.signatureRequest.data,
-      );
+      const result = await _client.sendPreparedCalls(signedCalls);
 
-      const result = await client.sendPreparedCalls({
-        ...preparedUO,
-        signature: {
-          type: "ecdsa",
-          signature,
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
+    });
+
+    it("should successfully send a UO with paymaster", async () => {
+      const account = await client.requestAccount();
+      const preparedCalls = await client.prepareCalls({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
         },
       });
 
+      const signedCalls = await client.signPreparedCalls(preparedCalls);
+
+      const result = await client.sendPreparedCalls(signedCalls);
+
       expect(result.preparedCallIds).toBeArrayOfSize(1);
     });
 
@@ -104,7 +180,7 @@ describe("Client E2E Tests", () => {
 
       const permissions = await client.grantPermissions({
         account: account.address,
-        expiry: Math.floor(Date.now() / 1000) + 60 * 60,
+        expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
         key: {
           publicKey: await sessionKey.getAddress(),
           type: "secp256k1",
@@ -112,7 +188,14 @@ describe("Client E2E Tests", () => {
         permissions: [{ type: "root" }],
       });
 
-      const preparedUO = await client.prepareCalls({
+      const sessionKeyClient = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        mode: "local",
+        signer: sessionKey,
+      });
+
+      const preparedCalls = await sessionKeyClient.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -123,14 +206,11 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      const signature = await signSignatureRequest(
-        sessionKey,
-        preparedUO.signatureRequest,
-      );
+      const signedCalls =
+        await sessionKeyClient.signPreparedCalls(preparedCalls);
 
-      const result = await client.sendPreparedCalls({
-        ...preparedUO,
-        signature,
+      const result = await sessionKeyClient.sendPreparedCalls({
+        ...signedCalls,
         capabilities: {
           permissions,
         },
@@ -142,7 +222,7 @@ describe("Client E2E Tests", () => {
 
   describe("Remote Mode Tests", () => {
     const signer = LocalAccountSigner.privateKeyToAccountSigner(
-      "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+      "0xd7b061ef04d29cf68b3c89356678eccec9988de8d5ed892c19461c4a9d65925d",
     );
 
     const client = createSmartWalletClient({
@@ -160,18 +240,35 @@ describe("Client E2E Tests", () => {
     it("should successfully get a counterfactual address", async () => {
       const account = await client.requestAccount();
       expect(account.address).toMatchInlineSnapshot(
-        `"0x65b5DE0251f553B2208762a4724303E750294D96"`,
+        `"0x76E765e80FFAC96ac10Aa8908a8267A3B80d606D"`,
+      );
+    });
+
+    it("should successfully request account with different salt", async () => {
+      const account = await client.requestAccount({
+        id: "26b375e3-c94a-4e98-b6b7-5a97121aa583",
+        creationHint: { salt: "0x1" },
+      });
+
+      expect(account.address).toMatchInlineSnapshot(
+        `"0xdfdd407b9569D40BEFa503208753E59cAc9713fA"`,
       );
     });
 
+    it("should not cache account if different inputs provided", async () => {
+      const account = await client.requestAccount();
+      const account2 = await client.requestAccount({
+        id: "2a3320b4-6ed2-4833-a488-5188e9bdd9d2",
+        creationHint: { salt: "0x2" },
+      });
+
+      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 +288,66 @@ describe("Client E2E Tests", () => {
       expect(isValid).toBeTrue();
     });
 
+    it("can correctly sign a message with a different account", async () => {
+      const account = await client.requestAccount({
+        id: "26b375e3-c94a-4e98-b6b7-5a97121aa583",
+        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: "26b375e3-c94a-4e98-b6b7-5a97121aa583",
+        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 preparedCalls = await client.prepareCalls({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
+        },
+      });
+
+      const signedCalls = await client.signPreparedCalls(preparedCalls);
+
+      const result = await client.sendPreparedCalls(signedCalls);
+
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
+    });
+
+    it("should successfully drop and replace a UO with repeat calls", async () => {
+      const account = await client.requestAccount();
+      const preparedCalls = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -203,15 +357,59 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      const signature = await client.signSignatureRequest(
-        preparedUO.signatureRequest,
+      const signedCalls = await client.signPreparedCalls(preparedCalls);
+      const result = await client.sendPreparedCalls(signedCalls);
+
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
+
+      const prepareCalls2 = await client.prepareCalls({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
+        },
+      });
+      const signedCalls2 = await client.signPreparedCalls(prepareCalls2);
+      const result2 = await client.sendPreparedCalls(signedCalls2);
+
+      expect(result2.preparedCallIds).toBeArrayOfSize(1);
+    });
+
+    it("should successfully send a UO with paymaster using 7702", async () => {
+      const _signer = LocalAccountSigner.privateKeyToAccountSigner(
+        "0x00d35c6d307b5cddeb70aeed96ee27a551fee58bf1a43858477e6c11f9172ba8",
       );
 
-      const result = await client.sendPreparedCalls({
-        ...preparedUO,
-        signature,
+      const _client = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        mode: "remote",
+        signer: _signer,
       });
 
+      const account = await _client.requestAccount({
+        creationHint: {
+          accountType: "7702",
+        },
+      });
+      expect(account.address).toBe(await _signer.getAddress());
+
+      const preparedCalls = await _client.prepareCalls({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
+        },
+      });
+
+      const signedCalls = await _client.signPreparedCalls(preparedCalls);
+
+      const result = await _client.sendPreparedCalls(signedCalls);
+
       expect(result.preparedCallIds).toBeArrayOfSize(1);
     });
 
@@ -222,7 +420,7 @@ describe("Client E2E Tests", () => {
 
       const permissions = await client.grantPermissions({
         account: account.address,
-        expiry: Math.floor(Date.now() / 1000) + 60 * 60,
+        expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
         key: {
           publicKey: await sessionKey.getAddress(),
           type: "secp256k1",
@@ -230,7 +428,14 @@ describe("Client E2E Tests", () => {
         permissions: [{ type: "root" }],
       });
 
-      const preparedUO = await client.prepareCalls({
+      const sessionKeyClient = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        mode: "remote",
+        signer: sessionKey,
+      });
+
+      const preparedCalls = await sessionKeyClient.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -241,14 +446,11 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      const signature = await signSignatureRequest(
-        sessionKey,
-        preparedUO.signatureRequest,
-      );
+      const signedCalls =
+        await sessionKeyClient.signPreparedCalls(preparedCalls);
 
-      const result = await client.sendPreparedCalls({
-        ...preparedUO,
-        signature,
+      const result = await sessionKeyClient.sendPreparedCalls({
+        ...signedCalls,
         capabilities: {
           permissions,
         },

package/src/client/decorator.ts

@@ -1,15 +1,6 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import type {
-  Hex,
-  JsonRpcAccount,
-  SignableMessage,
-  TypedDataDefinition,
-} from "viem";
-import type {
-  SendPreparedCallsParams,
-  SendPreparedCallsResult,
-} from "../isomorphic/actions/sendPreparedCalls";
-import type { InnerWalletApiClient } from "../types";
+import type { Address, Hex } from "viem";
+import type { InnerWalletApiClient } from "../types.ts";
 import {
   createAccount,
   type CreateAccountParams,
@@ -40,20 +31,32 @@ import {
   type RequestAccountParams,
   type RequestAccountResult,
 } from "./actions/requestAccount.js";
-import { sendPreparedCalls } from "./actions/sendPreparedCalls.js";
-import { signMessage } from "./actions/signMessage.js";
+import {
+  sendPreparedCalls,
+  type SendPreparedCallsParams,
+  type SendPreparedCallsResult,
+} from "./actions/sendPreparedCalls.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";
+import {
+  signPreparedCalls,
+  type SignPreparedCallsParams,
+  type SignPreparedCallsResult,
+} from "./actions/signPreparedCalls.js";
 
 export type SmartWalletActions<
-  TAccount extends JsonRpcAccount | undefined = JsonRpcAccount | undefined,
+  TAccount extends Address | undefined = Address | undefined,
 > = {
   requestAccount: (
-    params?: RequestAccountParams<TAccount>,
+    params?: RequestAccountParams,
   ) => Promise<RequestAccountResult>;
   prepareCalls: (
     params: PrepareCallsParams<TAccount>,
@@ -69,32 +72,31 @@ export type SmartWalletActions<
   signSignatureRequest: (
     params: SignSignatureRequestParams,
   ) => Promise<SignSignatureRequestResult>;
-  signMessage: (params: SignableMessage) => Promise<Hex>;
-  signTypedData: (params: TypedDataDefinition) => Promise<Hex>;
+  signPreparedCalls: (
+    params: SignPreparedCallsParams,
+  ) => Promise<SignPreparedCallsResult>;
+  signMessage: (params: SignMessageParams) => Promise<Hex>;
+  signTypedData: (params: SignTypedDataParams) => Promise<Hex>;
   grantPermissions: (
     params: GrantPermissionsParams<TAccount>,
   ) => Promise<GrantPermissionsResult>;
 };
 
 export function smartWalletClientActions<
-  TAccount extends JsonRpcAccount | undefined = JsonRpcAccount | undefined,
+  TAccount extends Address | undefined = Address | undefined,
 >(
-  client: InnerWalletApiClient<TAccount>,
-  signer: SmartAccountSigner,
-): SmartWalletActions<TAccount>;
-
-export function smartWalletClientActions(
   client: InnerWalletApiClient,
   signer: SmartAccountSigner,
-): SmartWalletActions {
+): SmartWalletActions<TAccount> {
   return {
     requestAccount: (params) => requestAccount(client, signer, params),
     createAccount: (params) => createAccount(client, signer, params),
     prepareCalls: (params) => prepareCalls(client, params),
-    listAccounts: (params) => listAccounts(client, params),
+    listAccounts: (params) => listAccounts(client, signer, params),
     sendPreparedCalls: (params) => sendPreparedCalls(client, params),
     getCallsStatus: (params) => getCallsStatus(client, params),
     signSignatureRequest: (params) => signSignatureRequest(signer, params),
+    signPreparedCalls: (params) => signPreparedCalls(signer, params),
     signMessage: (params) => signMessage(client, signer, params),
     signTypedData: (params) => signTypedData(client, signer, params),
     grantPermissions: (params) => grantPermissions(client, signer, params),

package/src/client/index.ts

@@ -1,55 +1,65 @@
-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,
-} from "viem";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { AlchemyTransport } from "@account-kit/infra";
+import type { Address, Chain, 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";
 
 export type SmartWalletClientParams<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
-> = Prettify<
-  {
-    transport: AlchemyTransport;
-    chain: Chain;
-    signer: SmartAccountSigner;
-    mode: "local" | "remote";
-    policyId?: string;
-  } & (IsUndefined<TAccount> extends true
-    ? {
-        account?: never;
-      }
-    : {
-        account: Address;
-      })
->;
+  TAccount extends Address | undefined = Address | undefined,
+> = Prettify<{
+  transport: AlchemyTransport;
+  chain: Chain;
+  signer: SmartAccountSigner;
+  mode: "local" | "remote";
+  policyId?: string;
+  account?: TAccount | Address | undefined;
+}>;
 
-export function createSmartWalletClient<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
->(
-  params: SmartWalletClientParams<TAccount>,
-): InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
+export type SmartWalletClient<
+  TAccount extends Address | undefined = Address | undefined,
+> = InnerWalletApiClient & SmartWalletActions<TAccount>;
 
+/**
+ * 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 {SmartWalletClient} - 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<
-  TAccount extends JsonRpcAccount<Address> = JsonRpcAccount<Address>,
->(
-  params: SmartWalletClientParams<TAccount>,
-): InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
+  TAccount extends Address | undefined = undefined,
+>(params: SmartWalletClientParams<TAccount>): SmartWalletClient<TAccount>;
 
-export function createSmartWalletClient(params: SmartWalletClientParams) {
+export function createSmartWalletClient(
+  params: SmartWalletClientParams,
+): SmartWalletClient {
   const { transport, chain, policyId, mode, account, signer } = params;
 
   const innerClient =

package/src/exports/index.ts

@@ -2,31 +2,23 @@
 // and we shouldn't export * for the sake of tree-shaking
 export {
   createSmartWalletClient,
+  type SmartWalletClient,
   type SmartWalletClientParams,
 } from "../client/index.js";
 
 export {
   WalletServerRpcSchema,
   type WalletServerRpcSchemaType,
-  type WalletServerViemRpcSchema,
-} from "../rpc/schema.js";
-
-// capabilities: TODO: should these actually just have the types exported?
-export { Capabilities } from "../capabilities/index.js";
-export { PaymasterCapability } from "../capabilities/paymaster.js";
-export {
-  PermissionsArray,
-  PermissionsCapability,
-  PermissionsContext,
-  PermissionsData,
-} from "../capabilities/permissions/index.js";
+} from "@alchemy/wallet-api-types/rpc";
 
 // client actions
 export { createAccount } from "../client/actions/createAccount.js";
 export { getCallsStatus } from "../client/actions/getCallsStatus.js";
+export { grantPermissions } from "../client/actions/grantPermissions.js";
 export { listAccounts } from "../client/actions/listAccounts.js";
 export { prepareCalls } from "../client/actions/prepareCalls.js";
 export { requestAccount } from "../client/actions/requestAccount.js";
-export { signMessage } from "../client/actions/signMessage.js";
 export { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
+export { signPreparedCalls } from "../client/actions/signPreparedCalls.js";
+export { signMessage } from "../client/actions/signMessage.js";
 export { signTypedData } from "../client/actions/signTypedData.js";