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

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

@@ -1,9 +1,9 @@
 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";
+import { createPublicClient, zeroAddress, type Address, type Hex } from "viem";
+import { createSmartWalletClient, type SmartWalletClient } from "./index.js";
+import { sleep } from "bun";
 
 describe("Client E2E Tests", () => {
   const transport = alchemy(
@@ -17,7 +17,7 @@ describe("Client E2E Tests", () => {
   );
   describe("Local Mode Tests", () => {
     const signer = LocalAccountSigner.privateKeyToAccountSigner(
-      "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff81",
+      "0xbaca22d9b6846ec09a4da378ffa07e2f14ce7d65675d135911b6fd281416bb03",
     );
 
     const client = createSmartWalletClient({
@@ -35,21 +35,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,83 +83,171 @@ 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({
-        calls: [{ to: zeroAddress, value: "0x0" }],
-        from: account.address,
-        capabilities: {
-          paymasterService: {
-            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
-          },
-        },
+    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";
 
-      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.signMessage({
+        message,
+        account: account.address,
+      });
+      const isValid = await publicClient.verifyMessage({
+        address: account.address,
+        message,
+        signature,
+      });
+      expect(isValid).toBeTrue();
+    });
 
-      const result = await client.sendPreparedCalls({
-        ...preparedUO,
-        signature: {
-          type: "ecdsa",
-          signature,
-        },
+    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" },
       });
 
-      expect(result.preparedCallIds).toBeArrayOfSize(1);
+      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 create a session with grantPermissions and send a UO", async () => {
-      const account = await client.requestAccount();
+    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: {
+            paymasterService: {
+              policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+            },
+          },
+        });
 
-      const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+        const signedCalls = await _client.signPreparedCalls(preparedCalls);
 
-      const permissions = await client.grantPermissions({
-        account: account.address,
-        expiry: Math.floor(Date.now() / 1000) + 60 * 60,
-        key: {
-          publicKey: await sessionKey.getAddress(),
-          type: "secp256k1",
-        },
-        permissions: [{ type: "root" }],
-      });
+        const result = await _client.sendPreparedCalls(signedCalls);
+
+        expect(result.preparedCallIds).toBeArrayOfSize(1);
 
-      const preparedUO = await client.prepareCalls({
-        calls: [{ to: zeroAddress, value: "0x0" }],
-        from: account.address,
-        capabilities: {
-          paymasterService: {
-            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+      },
+      {
+        timeout: 45_000,
+      },
+    );
+
+    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!,
+            },
           },
-          permissions,
-        },
-      });
+        });
 
-      const signature = await signSignatureRequest(
-        sessionKey,
-        preparedUO.signatureRequest,
-      );
+        const signedCalls = await client.signPreparedCalls(preparedCalls);
 
-      const result = await client.sendPreparedCalls({
-        ...preparedUO,
-        signature,
-        capabilities: {
-          permissions,
-        },
-      });
+        const result = await client.sendPreparedCalls(signedCalls);
 
-      expect(result.preparedCallIds).toBeArrayOfSize(1);
-    });
+        expect(result.preparedCallIds).toBeArrayOfSize(1);
+
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+      },
+      {
+        timeout: 45_000,
+      },
+    );
+
+    it(
+      "should successfully create a session with grantPermissions and send a UO",
+      async () => {
+        const account = await client.requestAccount();
+
+        const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+
+        const permissions = await client.grantPermissions({
+          account: account.address,
+          expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
+          key: {
+            publicKey: await sessionKey.getAddress(),
+            type: "secp256k1",
+          },
+          permissions: [{ type: "root" }],
+        });
+
+        const sessionKeyClient = createSmartWalletClient({
+          transport,
+          chain: arbitrumSepolia,
+          mode: "local",
+          signer: sessionKey,
+        });
+
+        const preparedCalls = await sessionKeyClient.prepareCalls({
+          calls: [{ to: zeroAddress, value: "0x0" }],
+          from: account.address,
+          capabilities: {
+            paymasterService: {
+              policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+            },
+            permissions,
+          },
+        });
+
+        const signedCalls =
+          await sessionKeyClient.signPreparedCalls(preparedCalls);
+
+        const result = await sessionKeyClient.sendPreparedCalls({
+          ...signedCalls,
+          capabilities: {
+            permissions,
+          },
+        });
+
+        expect(result.preparedCallIds).toBeArrayOfSize(1);
+
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+      },
+      {
+        timeout: 45_000,
+      },
+    );
   });
 
   describe("Remote Mode Tests", () => {
     const signer = LocalAccountSigner.privateKeyToAccountSigner(
-      "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+      "0xd7b061ef04d29cf68b3c89356678eccec9988de8d5ed892c19461c4a9d65925d",
     );
 
     const client = createSmartWalletClient({
@@ -160,18 +265,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,71 +313,208 @@ 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({
-        calls: [{ to: zeroAddress, value: "0x0" }],
-        from: account.address,
-        capabilities: {
-          paymasterService: {
-            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
-          },
-        },
+    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 signature = await client.signSignatureRequest(
-        preparedUO.signatureRequest,
-      );
-
-      const result = await client.sendPreparedCalls({
-        ...preparedUO,
+      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(result.preparedCallIds).toBeArrayOfSize(1);
+      expect(isValid).toBeTrue();
     });
 
-    it("should successfully create a session with grantPermissions and send a UO", async () => {
-      const account = await client.requestAccount();
-
-      const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+    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 permissions = await client.grantPermissions({
+      const signature = await client.signTypedData({
+        ...givenTypedData,
         account: account.address,
-        expiry: Math.floor(Date.now() / 1000) + 60 * 60,
-        key: {
-          publicKey: await sessionKey.getAddress(),
-          type: "secp256k1",
-        },
-        permissions: [{ type: "root" }],
       });
 
-      const preparedUO = await client.prepareCalls({
-        calls: [{ to: zeroAddress, value: "0x0" }],
-        from: account.address,
-        capabilities: {
-          paymasterService: {
-            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
-          },
-          permissions,
-        },
+      const isValid = await publicClient.verifyTypedData({
+        ...givenTypedData,
+        signature,
+        address: account.address,
       });
+      expect(isValid).toBeTrue();
+    });
 
-      const signature = await signSignatureRequest(
-        sessionKey,
-        preparedUO.signatureRequest,
-      );
+    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 result = await client.sendPreparedCalls({
-        ...preparedUO,
-        signature,
-        capabilities: {
-          permissions,
-        },
-      });
+        const signedCalls = await client.signPreparedCalls(preparedCalls);
 
-      expect(result.preparedCallIds).toBeArrayOfSize(1);
-    });
+        const result = await client.sendPreparedCalls(signedCalls);
+
+        expect(result.preparedCallIds).toBeArrayOfSize(1);
+
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+      },
+      {
+        timeout: 45_000,
+      },
+    );
+
+    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: {
+            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);
+
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+
+        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);
+
+        await waitForUserOpSuccess(client, result2.preparedCallIds[0]);
+      },
+      {
+        timeout: 90_000,
+      },
+    );
+
+    it(
+      "should successfully send a UO with paymaster using 7702",
+      async () => {
+        const _signer = LocalAccountSigner.privateKeyToAccountSigner(
+          "0x00d35c6d307b5cddeb70aeed96ee27a551fee58bf1a43858477e6c11f9172ba8",
+        );
+
+        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);
+
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+      },
+      { timeout: 45_000 },
+    );
+
+    it(
+      "should successfully create a session with grantPermissions and send a UO",
+      async () => {
+        const account = await client.requestAccount();
+
+        const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+
+        const permissions = await client.grantPermissions({
+          account: account.address,
+          expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
+          key: {
+            publicKey: await sessionKey.getAddress(),
+            type: "secp256k1",
+          },
+          permissions: [{ type: "root" }],
+        });
+
+        const sessionKeyClient = createSmartWalletClient({
+          transport,
+          chain: arbitrumSepolia,
+          mode: "remote",
+          signer: sessionKey,
+        });
+
+        const preparedCalls = await sessionKeyClient.prepareCalls({
+          calls: [{ to: zeroAddress, value: "0x0" }],
+          from: account.address,
+          capabilities: {
+            paymasterService: {
+              policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+            },
+            permissions,
+          },
+        });
+
+        const signedCalls =
+          await sessionKeyClient.signPreparedCalls(preparedCalls);
+
+        const result = await sessionKeyClient.sendPreparedCalls({
+          ...signedCalls,
+          capabilities: {
+            permissions,
+          },
+        });
+
+        expect(result.preparedCallIds).toBeArrayOfSize(1);
+
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+      },
+      {
+        timeout: 45_000,
+      },
+    );
   });
 
   const givenTypedData = {
@@ -291,3 +550,25 @@ describe("Client E2E Tests", () => {
     },
   } as const;
 });
+
+const waitForUserOpSuccess = async (
+  client: SmartWalletClient,
+  preparedCallId: Hex,
+) => {
+  const maxTimeoutMs = 1000 * 30;
+  const deadline = Date.now() + maxTimeoutMs;
+  while (Date.now() < deadline) {
+    const status = (await client.getCallsStatus(preparedCallId)).status;
+    if (status === 200) {
+      // Success.
+      return;
+    }
+    if (status !== 100) {
+      // Error.
+      throw new Error(`Get call status failed with status ${status}.`);
+    }
+    // Pending.
+    await sleep(5000);
+  }
+  throw new Error("Timed out waiting for successful call status.");
+};