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

package/dist/esm/client/client.e2e-test.js

@@ -3,6 +3,7 @@ import { alchemy, arbitrumSepolia } from "@account-kit/infra";
 import { describe, expect, it } from "bun:test";
 import { createPublicClient, zeroAddress } from "viem";
 import { createSmartWalletClient } from "./index.js";
+import { sleep } from "bun";
 describe("Client E2E Tests", () => {
     const transport = alchemy(process.env.ALCHEMY_PROXY_RPC_URL
         ? {
@@ -11,361 +12,203 @@ 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 signer = LocalAccountSigner.privateKeyToAccountSigner("0xd7b061ef04d29cf68b3c89356678eccec9988de8d5ed892c19461c4a9d65925d");
+    const client = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        signer,
+    });
+    const publicClient = createPublicClient({
+        chain: arbitrumSepolia,
+        transport,
+    });
+    it("should successfully get a counterfactual address", async () => {
+        const account = await client.requestAccount();
+        expect(account.address).toMatchInlineSnapshot(`"0x76E765e80FFAC96ac10Aa8908a8267A3B80d606D"`);
+    });
+    it("should successfully request account with different salt", async () => {
+        const account = await client.requestAccount({
+            id: "26b375e3-c94a-4e98-b6b7-5a97121aa583",
+            creationHint: { salt: "0x1" },
         });
-        const publicClient = createPublicClient({
-            chain: arbitrumSepolia,
-            transport,
+        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" },
         });
-        it("should successfully get a counterfactual address", async () => {
-            const account = await client.requestAccount();
-            expect(account.address).toMatchInlineSnapshot(`"0xa46944b7a39c35d931D514ACAc3ac77c226a81ff"`);
+        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 isValid = await publicClient.verifyMessage({
+            address: account.address,
+            message: "hello world",
+            signature,
         });
-        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"`);
+        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 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);
+        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" },
         });
-        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();
+        const message = "hello world";
+        const signature = await client.signMessage({
+            message,
+            account: account.address,
         });
-        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();
+        const isValid = await publicClient.verifyMessage({
+            address: account.address,
+            message: "hello world",
+            signature,
         });
-        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();
+        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" },
         });
-        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();
+        const signature = await client.signTypedData({
+            ...givenTypedData,
+            account: 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);
+        const isValid = await publicClient.verifyTypedData({
+            ...givenTypedData,
+            signature,
+            address: account.address,
         });
-        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,
-                    },
+        expect(isValid).toBeTrue();
+    });
+    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);
+            },
         });
-        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 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 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 sessionKeyClient.signPreparedCalls(preparedCalls);
-            const result = await sessionKeyClient.sendPreparedCalls({
-                ...signedCalls,
-                capabilities: {
-                    permissions,
+            },
+        });
+        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,
                 },
-            });
-            expect(result.preparedCallIds).toBeArrayOfSize(1);
+            },
         });
+        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,
     });
-    describe("Remote Mode Tests", () => {
-        const signer = LocalAccountSigner.privateKeyToAccountSigner("0xd7b061ef04d29cf68b3c89356678eccec9988de8d5ed892c19461c4a9d65925d");
-        const client = createSmartWalletClient({
+    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,
-        });
-        const publicClient = createPublicClient({
-            chain: arbitrumSepolia,
-            transport,
-        });
-        it("should successfully get a counterfactual address", async () => {
-            const account = await client.requestAccount();
-            expect(account.address).toMatchInlineSnapshot(`"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 isValid = await publicClient.verifyMessage({
-                address: account.address,
-                message: "hello world",
-                signature,
-            });
-            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,
-            });
-            expect(isValid).toBeTrue();
+            signer: _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 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();
+        const account = await _client.requestAccount({
+            creationHint: {
+                accountType: "7702",
+            },
         });
-        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,
-                    },
+        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);
+            },
         });
-        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);
-            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);
+        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" }],
         });
-        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);
+        const sessionKeyClient = createSmartWalletClient({
+            transport,
+            chain: arbitrumSepolia,
+            signer: sessionKey,
         });
-        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,
+        const preparedCalls = await sessionKeyClient.prepareCalls({
+            calls: [{ to: zeroAddress, value: "0x0" }],
+            from: account.address,
+            capabilities: {
+                paymasterService: {
+                    policyId: process.env.TEST_PAYMASTER_POLICY_ID,
                 },
-            });
-            expect(result.preparedCallIds).toBeArrayOfSize(1);
+                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 = {
         types: {
@@ -399,4 +242,22 @@ describe("Client E2E Tests", () => {
         },
     };
 });
+const waitForUserOpSuccess = async (client, preparedCallId) => {
+    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.");
+};
 //# sourceMappingURL=client.e2e-test.js.map