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

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

@@ -15,507 +15,273 @@ describe("Client E2E Tests", () => {
           apiKey: process.env.TEST_ALCHEMY_API_KEY!,
         },
   );
-  describe("Local Mode Tests", () => {
-    const signer = LocalAccountSigner.privateKeyToAccountSigner(
-      "0xbaca22d9b6846ec09a4da378ffa07e2f14ce7d65675d135911b6fd281416bb03",
-    );
-
-    const client = createSmartWalletClient({
-      transport,
-      chain: arbitrumSepolia,
-      mode: "local",
-      signer,
-    });
-
-    const publicClient = createPublicClient({
-      chain: arbitrumSepolia,
-      transport,
-    });
 
-    it("should successfully get a counterfactual address", async () => {
-      const account = await client.requestAccount();
-      expect(account.address).toMatchInlineSnapshot(
-        `"0xa46944b7a39c35d931D514ACAc3ac77c226a81ff"`,
-      );
-    });
+  const signer = LocalAccountSigner.privateKeyToAccountSigner(
+    "0xd7b061ef04d29cf68b3c89356678eccec9988de8d5ed892c19461c4a9d65925d",
+  );
 
-    it("should successfully request account with different salt", async () => {
-      const account = await client.requestAccount({
-        id: "f4c1d956-24ef-4002-a141-2c9d6d92af1a",
-        creationHint: { salt: "0x1" },
-      });
+  const client = createSmartWalletClient({
+    transport,
+    chain: arbitrumSepolia,
+    signer,
+  });
 
-      expect(account.address).toMatchInlineSnapshot(
-        `"0xA692f0E5AfAD20F771443D89C635146C6A592f06"`,
-      );
-    });
+  const publicClient = createPublicClient({
+    chain: arbitrumSepolia,
+    transport,
+  });
 
-    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" },
-      });
+  it("should successfully get a counterfactual address", async () => {
+    const account = await client.requestAccount();
+    expect(account.address).toMatchInlineSnapshot(
+      `"0x76E765e80FFAC96ac10Aa8908a8267A3B80d606D"`,
+    );
+  });
 
-      expect(account.address).not.toEqual(account2.address);
+  it("should successfully request account with different salt", async () => {
+    const account = await client.requestAccount({
+      id: "26b375e3-c94a-4e98-b6b7-5a97121aa583",
+      creationHint: { salt: "0x1" },
     });
 
-    it("can correctly sign a message", async () => {
-      const account = await client.requestAccount();
-      const message = "hello world";
-      const signature = await client.signMessage({ message });
-      const isValid = await publicClient.verifyMessage({
-        address: account.address,
-        message,
-        signature,
-      });
-      expect(isValid).toBeTrue();
-    });
+    expect(account.address).toMatchInlineSnapshot(
+      `"0xdfdd407b9569D40BEFa503208753E59cAc9713fA"`,
+    );
+  });
 
-    it("can correctly sign typed data", async () => {
-      const account = await client.requestAccount();
-      const signature = await client.signTypedData(givenTypedData);
-      const isValid = await publicClient.verifyTypedData({
-        ...givenTypedData,
-        signature,
-        address: account.address,
-      });
-      expect(isValid).toBeTrue();
+  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" },
     });
 
-    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";
+    expect(account.address).not.toEqual(account2.address);
+  });
 
-      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 a message", async () => {
+    const account = await client.requestAccount();
+    const message = "hello world";
+    const signature = await client.signMessage({ message });
+    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: "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("can correctly sign typed data", async () => {
+    const account = await client.requestAccount();
+    const signature = await client.signTypedData(givenTypedData);
+    const isValid = await publicClient.verifyTypedData({
+      ...givenTypedData,
+      signature,
+      address: account.address,
     });
-
-    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 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 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);
-
-        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,
-      },
-    );
+    expect(isValid).toBeTrue();
   });
 
-  describe("Remote Mode Tests", () => {
-    const signer = LocalAccountSigner.privateKeyToAccountSigner(
-      "0xd7b061ef04d29cf68b3c89356678eccec9988de8d5ed892c19461c4a9d65925d",
-    );
-
-    const client = createSmartWalletClient({
-      transport,
-      chain: arbitrumSepolia,
-      mode: "remote",
-      signer,
+  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 publicClient = createPublicClient({
-      chain: arbitrumSepolia,
-      transport,
+    const message = "hello world";
+    const signature = await client.signMessage({
+      message,
+      account: account.address,
     });
-
-    it("should successfully get a counterfactual address", async () => {
-      const account = await client.requestAccount();
-      expect(account.address).toMatchInlineSnapshot(
-        `"0x76E765e80FFAC96ac10Aa8908a8267A3B80d606D"`,
-      );
+    const isValid = await publicClient.verifyMessage({
+      address: account.address,
+      message: "hello world",
+      signature,
     });
+    expect(isValid).toBeTrue();
+  });
 
-    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("can correctly sign typed data with a different account", async () => {
+    const account = await client.requestAccount({
+      id: "26b375e3-c94a-4e98-b6b7-5a97121aa583",
+      creationHint: { salt: "0x1" },
     });
 
-    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);
+    const signature = await client.signTypedData({
+      ...givenTypedData,
+      account: account.address,
     });
 
-    it("can correctly sign a message", async () => {
-      const account = await client.requestAccount();
-      const message = "hello world";
-      const signature = await client.signMessage({ message });
-      const isValid = await publicClient.verifyMessage({
-        address: account.address,
-        message: "hello world",
-        signature,
-      });
-      expect(isValid).toBeTrue();
+    const isValid = await publicClient.verifyTypedData({
+      ...givenTypedData,
+      signature,
+      address: account.address,
     });
+    expect(isValid).toBeTrue();
+  });
 
-    it("can correctly sign typed data", async () => {
+  it(
+    "should successfully send a UO with paymaster",
+    async () => {
       const account = await client.requestAccount();
-      const signature = await client.signTypedData(givenTypedData);
-      const isValid = await publicClient.verifyTypedData({
-        ...givenTypedData,
-        signature,
-        address: account.address,
+      const preparedCalls = await client.prepareCalls({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
+        },
       });
-      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 signedCalls = await client.signPreparedCalls(preparedCalls);
 
-      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();
-    });
+      const result = await client.sendPreparedCalls(signedCalls);
 
-    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" },
-      });
+      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();
-    });
+      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!,
-            },
+  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);
+      const signedCalls = await client.signPreparedCalls(preparedCalls);
+      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,
-      },
-    );
+      await waitForUserOpSuccess(client, result.preparedCallIds[0]);
 
-    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 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);
 
-        const signedCalls = await client.signPreparedCalls(preparedCalls);
-        const result = await client.sendPreparedCalls(signedCalls);
+      expect(result2.preparedCallIds).toBeArrayOfSize(1);
 
-        expect(result.preparedCallIds).toBeArrayOfSize(1);
+      await waitForUserOpSuccess(client, result2.preparedCallIds[0]);
+    },
+    {
+      timeout: 90_000,
+    },
+  );
 
-        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+  it(
+    "should successfully send a UO with paymaster using 7702",
+    async () => {
+      const _signer = LocalAccountSigner.privateKeyToAccountSigner(
+        "0x00d35c6d307b5cddeb70aeed96ee27a551fee58bf1a43858477e6c11f9172ba8",
+      );
 
-        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);
+      const _client = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        signer: _signer,
+      });
 
-        expect(result2.preparedCallIds).toBeArrayOfSize(1);
+      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!,
+          },
+        },
+      });
 
-        await waitForUserOpSuccess(client, result2.preparedCallIds[0]);
-      },
-      {
-        timeout: 90_000,
-      },
-    );
+      const signedCalls = await _client.signPreparedCalls(preparedCalls);
 
-    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 result = await _client.sendPreparedCalls(signedCalls);
 
-        const signedCalls = await _client.signPreparedCalls(preparedCalls);
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
 
-        const result = await _client.sendPreparedCalls(signedCalls);
+      await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+    },
+    { timeout: 45_000 },
+  );
 
-        expect(result.preparedCallIds).toBeArrayOfSize(1);
+  it(
+    "should successfully create a session with grantPermissions and send a UO",
+    async () => {
+      const account = await client.requestAccount();
 
-        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
-      },
-      { timeout: 45_000 },
-    );
+      const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
 
-    it(
-      "should successfully create a session with grantPermissions and send a UO",
-      async () => {
-        const account = await client.requestAccount();
+      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 sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+      const sessionKeyClient = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        signer: sessionKey,
+      });
 
-        const permissions = await client.grantPermissions({
-          account: account.address,
-          expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
-          key: {
-            publicKey: await sessionKey.getAddress(),
-            type: "secp256k1",
+      const preparedCalls = await sessionKeyClient.prepareCalls({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
           },
-          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,
-          },
-        });
+          permissions,
+        },
+      });
 
-        const signedCalls =
-          await sessionKeyClient.signPreparedCalls(preparedCalls);
+      const signedCalls =
+        await sessionKeyClient.signPreparedCalls(preparedCalls);
 
-        const result = await sessionKeyClient.sendPreparedCalls({
-          ...signedCalls,
-          capabilities: {
-            permissions,
-          },
-        });
+      const result = await sessionKeyClient.sendPreparedCalls({
+        ...signedCalls,
+        capabilities: {
+          permissions,
+        },
+      });
 
-        expect(result.preparedCallIds).toBeArrayOfSize(1);
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
 
-        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
-      },
-      {
-        timeout: 45_000,
-      },
-    );
-  });
+      await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+    },
+    {
+      timeout: 45_000,
+    },
+  );
 
   const givenTypedData = {
     types: {