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

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,
+      }),
+    ),
   };
 }

package/src/isomorphic/utils/7702.ts

@@ -1,18 +1,19 @@
 import type { SmartAccountClient, SmartContractAccount } from "@aa-sdk/core";
 import {
   concatHex,
-  type Authorization,
+  numberToHex,
   type Address,
   type Chain,
   type Transport,
   isAddress,
 } from "viem";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
+import { PreparedCall_Authorization } from "../../schemas.js";
 import type { Eip7702AuthCapability } from "../../capabilities/eip7702Auth.ts";
 import type { Static } from "@sinclair/typebox";
 import { InvalidRequestError } from "ox/RpcResponse";
 
-export const createAuthorization = async (
+export const createAuthorizationRequest = async (
   client: SmartAccountClient<
     Transport,
     Chain,
@@ -21,18 +22,27 @@ export const createAuthorization = async (
     WalletServerViemRpcSchema
   >,
   params: { address: Address; delegation: Address },
-): Promise<Authorization<number, false> | undefined> => {
+): Promise<Static<typeof PreparedCall_Authorization> | undefined> => {
   const expectedCode = concatHex(["0xef0100", params.delegation]);
   const code = (await client.getCode({ address: params.address })) ?? "0x";
   if (code.toLowerCase() === expectedCode.toLowerCase()) {
     return undefined; // Already authorized.
   }
-  return {
-    chainId: client.chain.id,
+  const data = {
     address: params.delegation,
-    nonce: await client.getTransactionCount({
-      address: params.address,
-    }),
+    nonce: numberToHex(
+      await client.getTransactionCount({
+        address: params.address,
+      }),
+    ),
+  };
+  return {
+    type: "authorization" as const,
+    data,
+    chainId: numberToHex(client.chain.id),
+    signatureRequest: {
+      type: "eip7702Auth" as const,
+    },
   };
 };
 

package/src/isomorphic/utils/decodeSignature.ts

@@ -0,0 +1,18 @@
+import { Value } from "@sinclair/typebox/value";
+import type { Static, StaticDecode } from "@sinclair/typebox";
+import { TypeEcdsaSig } from "../../schemas.js";
+import { assertNever } from "../../utils.js";
+
+export const decodeSignature = (
+  signature: Static<typeof TypeEcdsaSig>["signature"],
+): StaticDecode<typeof TypeEcdsaSig>["signature"] => {
+  switch (signature.type) {
+    case "ecdsa":
+    case "secp256k1":
+      return Value.Decode(TypeEcdsaSig, { signature } satisfies Static<
+        typeof TypeEcdsaSig
+      >).signature;
+    default:
+      return assertNever(signature, "Unexpected signature type");
+  }
+};

package/src/local/client.ts

@@ -121,19 +121,15 @@ const innerClientActions = (
     grantPermissions: async (signer, params) => {
       const { signatureRequest, fullPreSignatureDeferredActionDigest } =
         await isomorphicClient.createSession(params);
-      const { signedAuthorization, signature } = await signSignatureRequest(
-        signer,
-        signatureRequest,
-      );
+      const signature = await signSignatureRequest(signer, signatureRequest);
       return {
         context: encodePermissionsContext({
           contextVersion: "LOCAL_MODE_DEFERRED_ACTION",
           deferredAction: buildDeferredActionDigest({
             fullPreSignatureDeferredActionDigest,
-            sig: prefixSignatureKeyType(signature, "secp256k1"),
+            sig: prefixSignatureKeyType(signature.data, signature.type),
           }),
         }),
-        signedAuthorization,
       };
     },
   };

package/src/remote/client.ts

@@ -1,5 +1,5 @@
 import { Provider } from "ox";
-import { BaseError, createClient, custom, type Address } from "viem";
+import { createClient, custom, type Address } from "viem";
 import { encodePermissionsContext } from "../capabilities/permissions/mav2.js";
 import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
 import { internalStateDecorator } from "../internal/decorator.js";
@@ -54,20 +54,13 @@ const innerClientActions = (
         method: "wallet_createSession",
         params: [params],
       });
-      if (signatureRequest.type !== "eth_signTypedData_v4") {
-        throw new BaseError("Unexpected signature request type");
-      }
-      const { signedAuthorization, signature } = await signSignatureRequest(
-        signer,
-        signatureRequest,
-      );
+      const signature = await signSignatureRequest(signer, signatureRequest);
       return {
         context: encodePermissionsContext({
           contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
           sessionId,
-          signature,
+          signature: signature.data,
         }),
-        signedAuthorization,
       };
     },
   };

package/src/rpc/examples.ts

@@ -82,9 +82,8 @@ const SendPreparedCalls = [
             },
             chainId: "0x66eee",
             signature: {
-              type: "ecdsa",
-              signature:
-                "0xb1a055089b1ba8387ed435f2bd0afe7ff69f22b928cdfdea1b5323c64d6af387164de3fa6febf031b544de46a84d6fb7f084b9798ddfaba820950c257139a7321b",
+              type: "secp256k1",
+              data: "0xb1a055089b1ba8387ed435f2bd0afe7ff69f22b928cdfdea1b5323c64d6af387164de3fa6febf031b544de46a84d6fb7f084b9798ddfaba820950c257139a7321b",
             },
           },
         ],
@@ -200,7 +199,7 @@ const CreateSession = [
                 type: "root",
               },
             ],
-            expiry: 1747969653,
+            expirySec: 1747969653,
           },
         ],
       },

package/src/rpc/request.ts

@@ -6,57 +6,43 @@ import {
   RemotePermission,
 } from "../capabilities/permissions/index.js";
 import {
+  TypeCallArray,
+  TypePrepareCall_UserOpV060_Signed,
+  TypePrepareCall_UserOpV070_Signed,
+  PreparedCall_Authorization,
+  PreparedCall_UserOpV060,
+  PreparedCall_UserOpV070,
   TypeAddress,
   TypeBase64UrlEncodedString,
   TypeCreationOptions,
-  TypeEip7702AuthExtendedFields,
   TypeHex,
   TypeSerializedInitcode,
-  TypeSignatureRequest,
-  TypeUserOperationRequest_v6,
-  TypeUserOperationRequest_v7,
+  TypeTypedDataSignatureRequest,
   TypeUuid,
-  TypeSignatureType,
 } from "../schemas.js";
 import { Examples } from "./examples.js";
-import { Eip7702AuthCapability } from "../capabilities/eip7702Auth.js";
 
 export const wallet_sendPreparedCalls = Type.Object(
   {
     Request: Type.Object({
       method: Type.Literal("wallet_sendPreparedCalls"),
       params: Type.Tuple([
-        Type.Object({
-          type: Type.Union([
-            Type.Literal("user-operation-v060", {
-              title: "User Operation (Entrypoint v0.6.0)",
-            }),
-            Type.Literal("user-operation-v070", {
-              title: "User Operation (Entrypoint v0.7.0)",
-            }),
-          ]),
-          data: Type.Union([
-            Type.Omit(TypeUserOperationRequest_v6, ["signature"], {
-              title: "Unsigned User Operation (Entrypoint v0.6.0)",
-            }),
-            Type.Omit(TypeUserOperationRequest_v7, ["signature"], {
-              title: "Unsigned User Operation (Entrypoint v0.7.0)",
-            }),
+        Type.Intersect([
+          Type.Union([
+            TypeCallArray,
+            TypePrepareCall_UserOpV060_Signed,
+            TypePrepareCall_UserOpV070_Signed,
           ]),
-          chainId: TypeHex(),
-          signature: Type.Object({
-            type: Type.Exclude(TypeSignatureType, Type.Literal("contract")),
-            signature: TypeHex(),
+          Type.Object({
+            capabilities: Type.Optional(
+              Type.Object({
+                permissions: Type.Optional(
+                  Type.Union([PermissionsContext, RemotePermission]),
+                ),
+              }),
+            ),
           }),
-          signedAuthorization: Type.Optional(TypeEip7702AuthExtendedFields),
-          capabilities: Type.Optional(
-            Type.Object({
-              permissions: Type.Optional(
-                Type.Union([PermissionsContext, RemotePermission]),
-              ),
-            }),
-          ),
-        }),
+        ]),
       ]),
     }),
     ReturnType: Type.Object({
@@ -89,26 +75,23 @@ export const wallet_prepareCalls = Type.Object(
         }),
       ]),
     }),
-    ReturnType: Type.Object({
-      type: Type.Union([
-        Type.Literal("user-operation-v060", {
-          title: "User Operation (Entrypoint v0.6.0)",
-        }),
-        Type.Literal("user-operation-v070", {
-          title: "User Operation (Entrypoint v0.7.0)",
-        }),
-      ]),
-      data: Type.Union([
-        Type.Omit(TypeUserOperationRequest_v6, ["signature"], {
-          title: "Unsigned User Operation (Entrypoint v0.6.0)",
-        }),
-        Type.Omit(TypeUserOperationRequest_v7, ["signature"], {
-          title: "Unsigned User Operation (Entrypoint v0.7.0)",
-        }),
-      ]),
-      chainId: TypeHex(),
-      signatureRequest: TypeSignatureRequest,
-    }),
+    ReturnType: Type.Union([
+      Type.Object(
+        {
+          type: Type.Literal("array"),
+          data: Type.Array(
+            Type.Union([
+              PreparedCall_UserOpV060,
+              PreparedCall_UserOpV070,
+              PreparedCall_Authorization,
+            ]),
+          ),
+        },
+        { description: "Array of prepared calls" },
+      ),
+      PreparedCall_UserOpV060,
+      PreparedCall_UserOpV070,
+    ]),
   },
   {
     description:
@@ -133,7 +116,7 @@ export const wallet_requestAccount = Type.Object(
               ),
             },
             {
-              title: "Using signer address",
+              description: "Using signer address",
             },
           ),
           Type.Object(
@@ -144,7 +127,7 @@ export const wallet_requestAccount = Type.Object(
               ),
             },
             {
-              title: "Using smart contract account address",
+              description: "Using smart contract account address",
             },
           ),
         ]),
@@ -229,18 +212,13 @@ export const wallet_createSession = Type.Object(
           PermissionsData,
           Type.Object({
             account: TypeAddress,
-            capabilities: Type.Optional(
-              Type.Object({
-                eip7702Auth: Type.Optional(Eip7702AuthCapability),
-              }),
-            ),
           }),
         ]),
       ]),
     }),
     ReturnType: Type.Object({
       sessionId: TypeHex(),
-      signatureRequest: TypeSignatureRequest,
+      signatureRequest: TypeTypedDataSignatureRequest,
     }),
   },
   {