@account-kit/wallet-client 0.1.0-alpha.5 → 0.1.0-alpha.7

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

@@ -2,7 +2,6 @@ import { LocalAccountSigner } from "@aa-sdk/core";
 import { alchemy, arbitrumSepolia } from "@account-kit/infra";
 import { describe, expect, it } from "bun:test";
 import { createPublicClient, zeroAddress, type Address } from "viem";
-import { signSignatureRequest } from "./actions/signSignatureRequest.js";
 import { createSmartWalletClient } from "./index.js";
 
 describe("Client E2E Tests", () => {
@@ -120,9 +119,44 @@ 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!,
+          },
+        },
+      });
+
+      const signedCalls = await _client.signPreparedCalls(preparedCalls);
+
+      const result = await _client.sendPreparedCalls(signedCalls);
+
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
+    });
+
     it("should successfully send a UO with paymaster", async () => {
       const account = await client.requestAccount();
-      const preparedCall = await client.prepareCalls({
+      const preparedCalls = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -132,14 +166,9 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      const signature = await client.signSignatureRequest(
-        preparedCall.signatureRequest,
-      );
+      const signedCalls = await client.signPreparedCalls(preparedCalls);
 
-      const result = await client.sendPreparedCalls({
-        ...preparedCall,
-        signature,
-      });
+      const result = await client.sendPreparedCalls(signedCalls);
 
       expect(result.preparedCallIds).toBeArrayOfSize(1);
     });
@@ -151,7 +180,7 @@ describe("Client E2E Tests", () => {
 
       const permissions = await client.grantPermissions({
         account: account.address,
-        expiry: Math.floor(Date.now() / 1000) + 60 * 60,
+        expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
         key: {
           publicKey: await sessionKey.getAddress(),
           type: "secp256k1",
@@ -159,7 +188,14 @@ describe("Client E2E Tests", () => {
         permissions: [{ type: "root" }],
       });
 
-      const preparedCall = await client.prepareCalls({
+      const sessionKeyClient = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        mode: "local",
+        signer: sessionKey,
+      });
+
+      const preparedCalls = await sessionKeyClient.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -170,14 +206,11 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      const signature = await signSignatureRequest(
-        sessionKey,
-        preparedCall.signatureRequest,
-      );
+      const signedCalls =
+        await sessionKeyClient.signPreparedCalls(preparedCalls);
 
-      const result = await client.sendPreparedCalls({
-        ...preparedCall,
-        signature,
+      const result = await sessionKeyClient.sendPreparedCalls({
+        ...signedCalls,
         capabilities: {
           permissions,
         },
@@ -295,7 +328,7 @@ describe("Client E2E Tests", () => {
 
     it("should successfully send a UO with paymaster", async () => {
       const account = await client.requestAccount();
-      const preparedCall = await client.prepareCalls({
+      const preparedCalls = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -305,15 +338,46 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      const signature = await client.signSignatureRequest(
-        preparedCall.signatureRequest,
+      const signedCalls = await client.signPreparedCalls(preparedCalls);
+
+      const result = await client.sendPreparedCalls(signedCalls);
+
+      expect(result.preparedCallIds).toBeArrayOfSize(1);
+    });
+
+    it("should successfully send a UO with paymaster using 7702", async () => {
+      const _signer = LocalAccountSigner.privateKeyToAccountSigner(
+        "0x00d35c6d307b5cddeb70aeed96ee27a551fee58bf1a43858477e6c11f9172ba8",
       );
 
-      const result = await client.sendPreparedCalls({
-        ...preparedCall,
-        signature,
+      const _client = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        mode: "remote",
+        signer: _signer,
+      });
+
+      const account = await _client.requestAccount({
+        creationHint: {
+          accountType: "7702",
+        },
+      });
+      expect(account.address).toBe(await _signer.getAddress());
+
+      const preparedCalls = await _client.prepareCalls({
+        calls: [{ to: zeroAddress, value: "0x0" }],
+        from: account.address,
+        capabilities: {
+          paymasterService: {
+            policyId: process.env.TEST_PAYMASTER_POLICY_ID!,
+          },
+        },
       });
 
+      const signedCalls = await _client.signPreparedCalls(preparedCalls);
+
+      const result = await _client.sendPreparedCalls(signedCalls);
+
       expect(result.preparedCallIds).toBeArrayOfSize(1);
     });
 
@@ -324,7 +388,7 @@ describe("Client E2E Tests", () => {
 
       const permissions = await client.grantPermissions({
         account: account.address,
-        expiry: Math.floor(Date.now() / 1000) + 60 * 60,
+        expirySec: Math.floor(Date.now() / 1000) + 60 * 60,
         key: {
           publicKey: await sessionKey.getAddress(),
           type: "secp256k1",
@@ -332,7 +396,14 @@ describe("Client E2E Tests", () => {
         permissions: [{ type: "root" }],
       });
 
-      const preparedCall = await client.prepareCalls({
+      const sessionKeyClient = createSmartWalletClient({
+        transport,
+        chain: arbitrumSepolia,
+        mode: "remote",
+        signer: sessionKey,
+      });
+
+      const preparedCalls = await sessionKeyClient.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -343,14 +414,11 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      const signature = await signSignatureRequest(
-        sessionKey,
-        preparedCall.signatureRequest,
-      );
+      const signedCalls =
+        await sessionKeyClient.signPreparedCalls(preparedCalls);
 
-      const result = await client.sendPreparedCalls({
-        ...preparedCall,
-        signature,
+      const result = await sessionKeyClient.sendPreparedCalls({
+        ...signedCalls,
         capabilities: {
           permissions,
         },

package/src/client/decorator.ts

@@ -1,9 +1,5 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { Address, Hex } from "viem";
-import type {
-  SendPreparedCallsParams,
-  SendPreparedCallsResult,
-} from "../isomorphic/actions/sendPreparedCalls.ts";
 import type { InnerWalletApiClient } from "../types.ts";
 import {
   createAccount,
@@ -35,7 +31,11 @@ import {
   type RequestAccountParams,
   type RequestAccountResult,
 } from "./actions/requestAccount.js";
-import { sendPreparedCalls } from "./actions/sendPreparedCalls.js";
+import {
+  sendPreparedCalls,
+  type SendPreparedCallsParams,
+  type SendPreparedCallsResult,
+} from "./actions/sendPreparedCalls.js";
 import { signMessage, type SignMessageParams } from "./actions/signMessage.js";
 import {
   signSignatureRequest,
@@ -46,6 +46,11 @@ import {
   signTypedData,
   type SignTypedDataParams,
 } from "./actions/signTypedData.js";
+import {
+  signPreparedCalls,
+  type SignPreparedCallsParams,
+  type SignPreparedCallsResult,
+} from "./actions/signPreparedCalls.js";
 
 export type SmartWalletActions<
   TAccount extends Address | undefined = Address | undefined,
@@ -67,6 +72,9 @@ export type SmartWalletActions<
   signSignatureRequest: (
     params: SignSignatureRequestParams,
   ) => Promise<SignSignatureRequestResult>;
+  signPreparedCalls: (
+    params: SignPreparedCallsParams,
+  ) => Promise<SignPreparedCallsResult>;
   signMessage: (params: SignMessageParams) => Promise<Hex>;
   signTypedData: (params: SignTypedDataParams) => Promise<Hex>;
   grantPermissions: (
@@ -88,6 +96,7 @@ export function smartWalletClientActions<
     sendPreparedCalls: (params) => sendPreparedCalls(client, params),
     getCallsStatus: (params) => getCallsStatus(client, params),
     signSignatureRequest: (params) => signSignatureRequest(signer, params),
+    signPreparedCalls: (params) => signPreparedCalls(signer, params),
     signMessage: (params) => signMessage(client, signer, params),
     signTypedData: (params) => signTypedData(client, signer, params),
     grantPermissions: (params) => grantPermissions(client, signer, params),

package/src/exports/index.ts

@@ -29,6 +29,7 @@ export { grantPermissions } from "../client/actions/grantPermissions.js";
 export { listAccounts } from "../client/actions/listAccounts.js";
 export { prepareCalls } from "../client/actions/prepareCalls.js";
 export { requestAccount } from "../client/actions/requestAccount.js";
-export { signMessage } from "../client/actions/signMessage.js";
 export { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
+export { signPreparedCalls } from "../client/actions/signPreparedCalls.js";
+export { signMessage } from "../client/actions/signMessage.js";
 export { signTypedData } from "../client/actions/signTypedData.js";

package/src/isomorphic/actions/createSession.ts

@@ -24,12 +24,7 @@ import type { wallet_createSession } from "../../rpc/request.js";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { createAccount, isModularAccountV2 } from "../utils/createAccount.js";
 import { createDummySigner } from "../utils/createDummySigner.js";
-import { createAuthorization } from "../utils/7702.js";
 import { InvalidRequestError } from "ox/RpcResponse";
-import {
-  parseDelegation,
-  assertValid7702AccountAddress,
-} from "../utils/7702.js";
 
 export type CreateSessionParams = Omit<
   Static<
@@ -63,30 +58,26 @@ export async function createSession(
     throw new ChainNotFoundError();
   }
 
-  assertValid7702AccountAddress(
-    params.account,
-    params.capabilities?.eip7702Auth,
-  );
-
-  const { counterfactualInfo, delegation } = params.capabilities?.eip7702Auth
-    ? {
-        counterfactualInfo: undefined,
-        delegation: parseDelegation(params.capabilities.eip7702Auth),
-      }
-    : await client.request({
-        method: "wallet_requestAccount",
-        params: [
-          {
-            accountAddress: params.account,
-            includeCounterfactualInfo: true,
-          },
-        ],
-      });
+  const { counterfactualInfo, delegation } = await client.request({
+    method: "wallet_requestAccount",
+    params: [
+      {
+        accountAddress: params.account,
+        includeCounterfactualInfo: true,
+      },
+    ],
+  });
 
-  if (!counterfactualInfo && !delegation) {
+  if (delegation) {
     throw new InvalidRequestError({
       message:
-        "No counterfactual info or delegated implementation address found.",
+        "'wallet_createSession' does not currently support 7702 accounts.",
+    });
+  }
+
+  if (!counterfactualInfo) {
+    throw new InvalidRequestError({
+      message: "No counterfactual info found.",
     });
   }
 
@@ -126,7 +117,7 @@ export async function createSession(
       },
       entityId,
       nonce,
-      deadline: params.expiry,
+      deadline: params.expirySec,
     })
       .addPermissions({
         permissions: params.permissions.map((permission) =>
@@ -135,25 +126,12 @@ export async function createSession(
       })
       .compileDeferred();
 
-  // If using 7702, we need an Authorization (unless it's already authorized).
-  const authorizationRequest = delegation
-    ? await createAuthorization(client, {
-        address: account.address,
-        delegation,
-      })
-    : undefined;
-
-  const signatureRequest = {
-    type: "eth_signTypedData_v4" as const,
-    data: typedData,
-  };
-
   return {
     sessionId: null, // In remote mode, the server will set this later.
     entityId: toHex(entityId),
     signatureRequest: {
-      ...signatureRequest,
-      ...(authorizationRequest ? { authorizationRequest } : {}),
+      type: "eth_signTypedData_v4" as const,
+      data: typedData,
     },
     fullPreSignatureDeferredActionDigest,
   };

package/src/isomorphic/actions/prepareCalls.ts

@@ -17,8 +17,9 @@ import type { wallet_prepareCalls } from "../../rpc/request.js";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { createAccount } from "../utils/createAccount.js";
 import { createDummySigner } from "../utils/createDummySigner.js";
-import { createAuthorization, parseDelegation } from "../utils/7702.js";
+import { createAuthorizationRequest, parseDelegation } from "../utils/7702.js";
 import { InvalidRequestError } from "ox/RpcResponse";
+import { assertNever } from "../../utils.js";
 import { assertValid7702AccountAddress } from "../utils/7702.js";
 
 export type PrepareCallsParams = Omit<
@@ -83,7 +84,7 @@ export async function prepareCalls(
 
   // If using 7702, we need an Authorization (unless it's already authorized).
   const authorizationRequest = delegation
-    ? await createAuthorization(client, {
+    ? await createAuthorizationRequest(client, {
         address: account.address,
         delegation,
       })
@@ -107,29 +108,36 @@ export async function prepareCalls(
   });
 
   // The eip7702Auth field should never be included in the UO sig
-  // request. It's handled by the separate authorization request.
+  // request. It's handled by a separate authorization request.
   if ("eip7702Auth" in builtUo) {
     builtUo.eip7702Auth = undefined;
   }
-  const uoRequest = deepHexlify(builtUo);
 
-  const signatureRequest = {
-    type: "personal_sign" as const,
-    data: {
-      raw: account.getEntryPoint().getUserOperationHash(uoRequest),
-    },
-  };
+  const hexlifiedUo = deepHexlify(builtUo);
+
+  const ep = account.getEntryPoint();
 
-  return {
+  const uoRequest = {
     type:
-      account.getEntryPoint().version === "0.7.0"
-        ? "user-operation-v070"
-        : "user-operation-v060",
-    data: uoRequest,
+      ep.version === "0.7.0"
+        ? ("user-operation-v070" as const)
+        : ep.version === "0.6.0"
+          ? ("user-operation-v060" as const)
+          : assertNever(ep.version, "Unexpected entry point version"),
+    data: hexlifiedUo,
     chainId: toHex(client.chain.id),
     signatureRequest: {
-      ...signatureRequest,
-      ...(authorizationRequest ? { authorizationRequest } : {}),
+      type: "personal_sign" as const,
+      data: {
+        raw: ep.getUserOperationHash(hexlifiedUo),
+      },
     },
   };
+
+  return authorizationRequest
+    ? {
+        type: "array" as const,
+        data: [authorizationRequest, uoRequest],
+      }
+    : uoRequest;
 }

package/src/isomorphic/actions/sendPreparedCalls.ts

@@ -3,31 +3,33 @@ import {
   type SmartAccountClient,
   type SmartContractAccount,
 } from "@aa-sdk/core";
-import type { Static, StaticDecode } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import {
   BaseError,
   ChainNotFoundError,
   concat,
   concatHex,
+  numberToHex,
+  parseSignature,
   toHex,
+  type Address,
   type Chain,
   type Hex,
   type Transport,
 } from "viem";
 import { decodePermissionsContext } from "../../capabilities/permissions/mav2.js";
-import type { wallet_sendPreparedCalls } from "../../rpc/request.js";
+import { type wallet_sendPreparedCalls } from "../../rpc/request.js";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { TypeCallId } from "../../schemas.js";
 import { isSupportedDelegationAddress7702 } from "../utils/7702.js";
 import { InvalidRequestError } from "ox/RpcResponse";
+import { assertNever } from "../../utils.js";
+import type { Static } from "@sinclair/typebox";
+import { decodeSignature } from "../utils/decodeSignature.js";
 
-export type SendPreparedCallsParams = Omit<
-  StaticDecode<
-    (typeof wallet_sendPreparedCalls)["properties"]["Request"]["properties"]["params"]
-  >[0],
-  "chainId"
->;
+export type SendPreparedCallsParams = Static<
+  (typeof wallet_sendPreparedCalls)["properties"]["Request"]["properties"]["params"]
+>[0];
 
 export type SendPreparedCallsResult = Static<
   (typeof wallet_sendPreparedCalls)["properties"]["ReturnType"]
@@ -48,16 +50,6 @@ export async function sendPreparedCalls(
     throw new ChainNotFoundError();
   }
 
-  // One last safety check to be sure the UO wasn't modified to include an unsupported 7702 delegation address.
-  if (
-    params.signedAuthorization &&
-    !isSupportedDelegationAddress7702(params.signedAuthorization.address)
-  ) {
-    throw new InvalidRequestError({
-      message: `Unsupported 7702 delegation address: ${params.signedAuthorization.address}`,
-    });
-  }
-
   const deferredAction: Hex | undefined = (() => {
     if (!params.capabilities?.permissions) {
       return;
@@ -77,46 +69,104 @@ export async function sendPreparedCalls(
     return decodedContext.deferredAction;
   })();
 
-  const entryPoint =
-    params.type === "user-operation-v060"
-      ? getEntryPoint(client.chain, { version: "0.6.0" })
-      : getEntryPoint(client.chain, { version: "0.7.0" });
+  const userOps =
+    params.type === "array"
+      ? params.data.filter((it) => {
+          const isUserOp =
+            it.type === "user-operation-v060" ||
+            it.type === "user-operation-v070";
+          if (isUserOp && it.chainId !== toHex(client.chain.id)) {
+            throw new InvalidRequestError({
+              message:
+                "Multiple chain IDs in a single request are not currently supported.",
+            });
+          }
+          return isUserOp;
+        })
+      : [params];
+
+  const authorizations =
+    params.type === "array"
+      ? params.data.filter((it) => it.type === "authorization")
+      : [];
 
-  const hash = await client
-    .sendRawUserOperation(
-      {
-        ...params.data,
-        signature:
-          deferredAction != null
-            ? concatHex([
-                `0x${deferredAction.slice(68)}`, // Cuts off stuff preprended to the digest (nonce, etc. that we had previously).
-                "0xff",
-                "0x00",
-                params.signature.signature,
-              ])
-            : concat(["0xFF", "0x00", params.signature.signature]),
-        eip7702Auth: params.signedAuthorization,
-      },
-      entryPoint.address,
-    )
-    .catch((err) => {
-      if (
-        err instanceof BaseError &&
-        err.details.endsWith("is not a contract and initCode is empty")
-      ) {
-        throw new BaseError(
-          `${err.details} (If using 7702, be sure you include the 'signedAuthorization' field in the request parameters)`,
-        );
-      }
-      throw err;
+  if (authorizations.length > 1) {
+    throw new InvalidRequestError({
+      message:
+        "Multiple authorizations in a single request are not currently supported",
     });
+  }
+  const [authorization] = authorizations;
+
+  // One last safety check to be sure the UO wasn't modified to include an unsupported 7702 delegation address.
+  if (
+    authorization &&
+    !isSupportedDelegationAddress7702(authorization.data.address)
+  ) {
+    throw new InvalidRequestError({
+      message: `Unsupported 7702 delegation address: ${authorization.data.address}`,
+    });
+  }
 
-  const callId = Value.Encode(TypeCallId, {
-    chainId: toHex(client.chain.id),
-    hash,
-  });
+  const hashes = await Promise.all(
+    userOps.map(async (userOp, idx) => {
+      const ep: { address: Address } =
+        userOp.type === "user-operation-v060"
+          ? getEntryPoint(client.chain, { version: "0.6.0" })
+          : userOp.type === "user-operation-v070"
+            ? getEntryPoint(client.chain, { version: "0.7.0" })
+            : assertNever(userOp, "Unexpected user op type");
+      const authSig = authorization
+        ? parseSignature(decodeSignature(authorization.signature).data)
+        : undefined;
+      const uoSigHex = decodeSignature(userOp.signature).data;
+      return client
+        .sendRawUserOperation(
+          {
+            ...userOp.data,
+            signature:
+              deferredAction != null
+                ? concatHex([
+                    `0x${deferredAction.slice(68)}`, // Cuts off stuff prepended to the digest (nonce, etc. that we had previously).
+                    "0xff",
+                    "0x00",
+                    uoSigHex,
+                  ])
+                : concat(["0xFF", "0x00", uoSigHex]),
+            eip7702Auth:
+              idx === 0 && authorization && authSig
+                ? {
+                    ...authorization.data,
+                    chainId: authorization.chainId,
+                    ...{
+                      ...authSig,
+                      yParity: numberToHex(authSig.yParity),
+                    },
+                  }
+                : undefined,
+          },
+          ep.address,
+        )
+        .catch((err) => {
+          if (
+            err instanceof BaseError &&
+            err.details.endsWith("is not a contract and initCode is empty")
+          ) {
+            throw new BaseError(
+              `${err.details} (If using 7702, be sure you include the signed authorization in the request parameters)`,
+            );
+          }
+          throw err;
+        });
+    }),
+  );
 
   return {
-    preparedCallIds: [callId],
+    preparedCallIds: hashes.map((hash) =>
+      Value.Encode(TypeCallId, {
+        chainId: toHex(client.chain.id),
+        hash,
+      }),
+    ),
   };
 }