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

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

@@ -1,8 +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 { 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(
@@ -119,105 +120,129 @@ describe("Client E2E Tests", () => {
       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: {
-          paymasterService: {
-            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+    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 signedCalls = await _client.signPreparedCalls(preparedCalls);
 
-      const result = await _client.sendPreparedCalls(signedCalls);
+        const result = await _client.sendPreparedCalls(signedCalls);
 
-      expect(result.preparedCallIds).toBeArrayOfSize(1);
-    });
+        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!,
-          },
-        },
-      });
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+      },
+      {
+        timeout: 45_000,
+      },
+    );
 
-      const signedCalls = await client.signPreparedCalls(preparedCalls);
+    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(signedCalls);
+        const signedCalls = await client.signPreparedCalls(preparedCalls);
 
-      expect(result.preparedCallIds).toBeArrayOfSize(1);
-    });
+        const result = await client.sendPreparedCalls(signedCalls);
 
-    it("should successfully create a session with grantPermissions and send a UO", async () => {
-      const account = await client.requestAccount();
+        expect(result.preparedCallIds).toBeArrayOfSize(1);
 
-      const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+      },
+      {
+        timeout: 45_000,
+      },
+    );
 
-      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 create a session with grantPermissions and send a UO",
+      async () => {
+        const account = await client.requestAccount();
 
-      const sessionKeyClient = createSmartWalletClient({
-        transport,
-        chain: arbitrumSepolia,
-        mode: "local",
-        signer: sessionKey,
-      });
+        const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
 
-      const preparedCalls = await sessionKeyClient.prepareCalls({
-        calls: [{ to: zeroAddress, value: "0x0" }],
-        from: account.address,
-        capabilities: {
-          paymasterService: {
-            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+        const permissions = await client.grantPermissions({
+          account: account.address,
+          expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
+          key: {
+            publicKey: await sessionKey.getAddress(),
+            type: "secp256k1",
           },
-          permissions,
-        },
-      });
+          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 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,
+      },
+    );
   });
 
   describe("Remote Mode Tests", () => {
@@ -326,138 +351,170 @@ describe("Client E2E Tests", () => {
       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!,
+    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 signedCalls = await client.signPreparedCalls(preparedCalls);
 
-      const result = await client.sendPreparedCalls(signedCalls);
+        const result = await client.sendPreparedCalls(signedCalls);
 
-      expect(result.preparedCallIds).toBeArrayOfSize(1);
-    });
+        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!,
+        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);
+        const signedCalls = await client.signPreparedCalls(preparedCalls);
+        const result = await client.sendPreparedCalls(signedCalls);
 
-      expect(result.preparedCallIds).toBeArrayOfSize(1);
+        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);
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
 
-      expect(result2.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);
 
-    it("should successfully send a UO with paymaster using 7702", async () => {
-      const _signer = LocalAccountSigner.privateKeyToAccountSigner(
-        "0x00d35c6d307b5cddeb70aeed96ee27a551fee58bf1a43858477e6c11f9172ba8",
-      );
+        expect(result2.preparedCallIds).toBeArrayOfSize(1);
 
-      const _client = createSmartWalletClient({
-        transport,
-        chain: arbitrumSepolia,
-        mode: "remote",
-        signer: _signer,
-      });
+        await waitForUserOpSuccess(client, result2.preparedCallIds[0]);
+      },
+      {
+        timeout: 90_000,
+      },
+    );
 
-      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!,
+    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",
           },
-        },
-      });
-
-      const signedCalls = await _client.signPreparedCalls(preparedCalls);
+        });
+        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);
 
-    it("should successfully create a session with grantPermissions and send a UO", async () => {
-      const account = await client.requestAccount();
+        expect(result.preparedCallIds).toBeArrayOfSize(1);
 
-      const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
+        await waitForUserOpSuccess(client, result.preparedCallIds[0]);
+      },
+      { timeout: 45_000 },
+    );
 
-      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 create a session with grantPermissions and send a UO",
+      async () => {
+        const account = await client.requestAccount();
 
-      const sessionKeyClient = createSmartWalletClient({
-        transport,
-        chain: arbitrumSepolia,
-        mode: "remote",
-        signer: sessionKey,
-      });
+        const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
 
-      const preparedCalls = await sessionKeyClient.prepareCalls({
-        calls: [{ to: zeroAddress, value: "0x0" }],
-        from: account.address,
-        capabilities: {
-          paymasterService: {
-            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+        const permissions = await client.grantPermissions({
+          account: account.address,
+          expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
+          key: {
+            publicKey: await sessionKey.getAddress(),
+            type: "secp256k1",
           },
-          permissions,
-        },
-      });
+          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 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,
+      },
+    );
   });
 
   const givenTypedData = {
@@ -493,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.");
+};

package/src/isomorphic/actions/createSession.ts

@@ -21,7 +21,7 @@ import {
 } from "viem";
 import { InvalidRequestError } from "ox/RpcResponse";
 import {
-  TypePermission,
+  Permission,
   isGlobalValidation,
 } from "@alchemy/wallet-api-types/capabilities";
 import type {
@@ -144,7 +144,7 @@ export async function createSession(
     })
       .addPermissions({
         permissions: params.permissions.map((permission) =>
-          Value.Encode(TypePermission, permission),
+          Value.Encode(Permission, permission),
         ),
       })
       .compileDeferred();

package/src/isomorphic/actions/getCallsStatus.ts

@@ -19,7 +19,7 @@ import {
   type wallet_getCallsStatus,
   type WalletServerViemRpcSchema,
 } from "@alchemy/wallet-api-types/rpc";
-import { TypeCallId } from "@alchemy/wallet-api-types";
+import { CallId } from "@alchemy/wallet-api-types";
 import { castToHex } from "../../utils.js";
 
 export type GetCallsStatusParams = Static<
@@ -43,7 +43,7 @@ export async function getCallsStatus(
   if (!client.chain) {
     throw new ChainNotFoundError();
   }
-  const { chainId, hash } = Value.Decode(TypeCallId, callId);
+  const { chainId, hash } = Value.Decode(CallId, callId);
 
   const baseResp = {
     id: callId,

package/src/isomorphic/actions/prepareSign.ts

@@ -15,10 +15,7 @@ import type {
   wallet_prepareSign,
   WalletServerViemRpcSchema,
 } from "@alchemy/wallet-api-types/rpc";
-import {
-  TypeSignableMessage,
-  jsonSafeTypedData,
-} from "@alchemy/wallet-api-types";
+import { SignableMessage, jsonSafeTypedData } from "@alchemy/wallet-api-types";
 import { createAccount } from "../utils/createAccount.js";
 import { createDummySigner } from "../utils/createDummySigner.js";
 import { Value } from "@sinclair/typebox/value";
@@ -74,7 +71,7 @@ export async function prepareSign(
       chainId: toHex(client.chain.id),
       signatureRequest: {
         type: signatureRequest.type,
-        data: Value.Encode(TypeSignableMessage, signatureRequest.data),
+        data: Value.Encode(SignableMessage, signatureRequest.data),
       },
     };
   } else {

package/src/isomorphic/actions/sendPreparedCalls.ts

@@ -9,6 +9,7 @@ import {
   ChainNotFoundError,
   concat,
   concatHex,
+  getContract,
   numberToHex,
   parseSignature,
   toHex,
@@ -22,7 +23,7 @@ import type {
   WalletServerViemRpcSchema,
 } from "@alchemy/wallet-api-types/rpc";
 import { decodePermissionsContext } from "@alchemy/wallet-api-types/capabilities";
-import { TypeCallId } from "@alchemy/wallet-api-types";
+import { CallId } from "@alchemy/wallet-api-types";
 import { isSupportedDelegationAddress7702 } from "../utils/7702.js";
 import { InvalidRequestError } from "ox/RpcResponse";
 import { assertNever } from "../../utils.js";
@@ -146,6 +147,47 @@ export async function sendPreparedCalls(
         });
       }
 
+      const deferredActionData: Hex | undefined = deferredAction
+        ? await (async () => {
+            // determine whether the data should be appended to the signature.
+            // logic ported from @account-kit/smart-contracts `modularAccountV2Base.ts`
+
+            const deferredActionNonce = BigInt(
+              `0x${deferredAction.slice(4, 68)}`,
+            );
+
+            const entryPoint = getEntryPoint(client.chain, {
+              version: "0.7.0",
+            });
+
+            const entryPointContract = getContract({
+              address: entryPoint.address,
+              abi: entryPoint.abi,
+              client,
+            });
+
+            // Set these values if the deferred action has not been consumed. We check this with the EP
+            const nextNonceForDeferredAction: bigint =
+              (await entryPointContract.read.getNonce([
+                userOp.data.sender,
+                deferredActionNonce >> 64n,
+              ])) as bigint;
+
+            if (deferredActionNonce === nextNonceForDeferredAction) {
+              return `0x${deferredAction.slice(68)}`;
+            } else if (deferredActionNonce > nextNonceForDeferredAction) {
+              // if nonce is greater than the next nonce, its invalid, so we throw
+              throw new InvalidRequestError({
+                message: "Invalid session nonce",
+              });
+            }
+
+            // In this case, the deferred action has already been consumed, so no data should be appended to the signature.
+            // The signer entity should already be accounted for in `userOp.nonce`.
+            return undefined;
+          })()
+        : undefined;
+
       const factoryType = counterfactualInfo?.factoryType;
 
       // build signature based on account type
@@ -166,13 +208,8 @@ export async function sendPreparedCalls(
           case "MAv2.0.0-sma-b":
             // For sma-b, we need to handle deferred actions if needed and prepend the "Reserved
             // Signature Segment" and "SignatureType.EOA" bytes
-            return deferredAction != null
-              ? concatHex([
-                  `0x${deferredAction.slice(68)}`, // Cuts off stuff prepended to the digest (nonce, etc.).
-                  "0xFF",
-                  "0x00",
-                  uoSigHex,
-                ])
+            return deferredActionData != null
+              ? concatHex([deferredActionData, "0xFF", "0x00", uoSigHex])
               : concat(["0xFF", "0x00", uoSigHex]);
           case "LightAccountV2.0.0-MultiOwner":
             // for LAv2-MultiOwner, we need to prepend the "SignatureType.EOA" byte
@@ -225,7 +262,7 @@ export async function sendPreparedCalls(
 
   return {
     preparedCallIds: hashes.map((hash) =>
-      Value.Encode(TypeCallId, {
+      Value.Encode(CallId, {
         chainId: toHex(client.chain.id),
         hash,
       }),