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

package/src/isomorphic/actions/getCallsStatus.ts

@@ -6,6 +6,7 @@ import type { Static } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import {
   ChainNotFoundError,
+  hexToNumber,
   isHex,
   type Chain,
   type Hex,
@@ -16,6 +17,21 @@ import type { wallet_getCallsStatus } from "../../rpc/request.js";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { TypeCallId } from "../../schemas.js";
 import { castToHex } from "../../utils.js";
+import { InternalError, BaseError } from "ox/RpcResponse";
+import {
+  polygon,
+  mainnet,
+  base,
+  worldchain,
+  optimism,
+  arbitrum,
+  sepolia,
+  polygonAmoy,
+  baseSepolia,
+  optimismSepolia,
+  worldchainSepolia,
+  arbitrumSepolia,
+} from "viem/chains";
 
 export type GetCallsStatusParams = Static<
   (typeof wallet_getCallsStatus)["properties"]["Request"]["properties"]["params"]
@@ -44,6 +60,29 @@ export const CallStatusCode = {
   PARTIAL_CHAIN_RULES_FAILURE: 600,
 } as const;
 
+// https://eips.ethereum.org/EIPS/eip-5792#error-codes
+const ErrorCode = {
+  UNKNOWN_BUNDLE_ID: 5730,
+};
+
+// "eth_getUserOperationByHash" is limited to the last 150 blocks
+//  for all networks except those in this list.
+// https://www.alchemy.com/docs/node/bundler-api/bundler-api-endpoints/eth-get-user-operation-by-hash
+const GET_USER_OP_BY_HASH_UNLIMITED_RANGE_NETWORKS: number[] = [
+  mainnet.id,
+  sepolia.id,
+  polygon.id,
+  polygonAmoy.id,
+  base.id,
+  baseSepolia.id,
+  optimism.id,
+  optimismSepolia.id,
+  worldchain.id,
+  worldchainSepolia.id,
+  arbitrum.id,
+  arbitrumSepolia.id,
+];
+
 export async function getCallsStatus(
   client: SmartAccountClient<
     Transport,
@@ -57,21 +96,54 @@ export async function getCallsStatus(
   if (!client.chain) {
     throw new ChainNotFoundError();
   }
-
   const { chainId, hash } = Value.Decode(TypeCallId, callId);
 
-  const result = await client.getUserOperationReceipt(hash);
-
-  return {
+  const baseResp = {
     id: callId,
     chainId,
     atomic: true,
-    status: !result?.receipt
-      ? CallStatusCode.PENDING
-      : result.success
-        ? CallStatusCode.CONFIRMED
-        : CallStatusCode.CHAIN_RULES_FAILURE,
-    receipts: !result?.receipt ? undefined : [transformReceipt(result.receipt)],
+  };
+
+  const result = await client.getUserOperationByHash(hash);
+  if (
+    !result &&
+    GET_USER_OP_BY_HASH_UNLIMITED_RANGE_NETWORKS.includes(hexToNumber(chainId))
+  ) {
+    // This network has unlimited range, so we should always have a result here if the callId is valid.
+    throw new BaseError({
+      message: `callId ${callId} not found`,
+      code: ErrorCode.UNKNOWN_BUNDLE_ID,
+    });
+  }
+  if (result && !result.transactionHash) {
+    // A result but no txn hash means it's valid but pending.
+    return {
+      ...baseResp,
+      status: CallStatusCode.PENDING,
+    };
+  }
+
+  const receipt = await client.getUserOperationReceipt(hash);
+  if (result?.transactionHash && !receipt) {
+    // This should never happen.
+    throw new InternalError({
+      message: `Failed to get receipt for callId ${callId}`,
+    });
+  }
+  if (!receipt) {
+    // This covers txns older than 150 blocks which were not retrievable by "eth_getUserOperationByHash".
+    throw new BaseError({
+      message: `callId ${callId} not found`,
+      code: ErrorCode.UNKNOWN_BUNDLE_ID,
+    });
+  }
+
+  return {
+    ...baseResp,
+    status: receipt.success
+      ? CallStatusCode.CONFIRMED
+      : CallStatusCode.CHAIN_RULES_FAILURE,
+    receipts: [transformReceipt(receipt.receipt)],
   };
 }
 

package/src/isomorphic/actions/prepareCalls.ts

@@ -17,8 +17,10 @@ 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 } 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<
   Static<
@@ -45,16 +47,23 @@ export async function prepareCalls(
     throw new ChainNotFoundError();
   }
 
+  assertValid7702AccountAddress(params.from, params.capabilities?.eip7702Auth);
+
   // in local mode, we probably want some kind of caching for this
-  const { counterfactualInfo, delegation } = await client.request({
-    method: "wallet_requestAccount",
-    params: [
-      {
-        accountAddress: params.from,
-        includeCounterfactualInfo: true,
-      },
-    ],
-  });
+  const { counterfactualInfo, delegation } = params.capabilities?.eip7702Auth
+    ? {
+        counterfactualInfo: undefined,
+        delegation: parseDelegation(params.capabilities.eip7702Auth),
+      }
+    : await client.request({
+        method: "wallet_requestAccount",
+        params: [
+          {
+            accountAddress: params.from,
+            includeCounterfactualInfo: true,
+          },
+        ],
+      });
 
   if (!counterfactualInfo && !delegation) {
     throw new InvalidRequestError({
@@ -69,13 +78,13 @@ export async function prepareCalls(
     signer: createDummySigner(params.from),
     accountAddress: params.from,
     counterfactualInfo,
-    capabilities: params.capabilities,
+    permissions: params.capabilities?.permissions,
     delegation,
   });
 
   // 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,
       })
@@ -99,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 { isSupportedImplementationAddress7702 } from "../utils/7702.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 &&
-    !isSupportedImplementationAddress7702(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,14 +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,
@@ -17,42 +22,95 @@ 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,
+    },
   };
 };
 
-type Supported7702AccountType = "ModularAccountV2";
+export const EIP_7702_ACCOUNT_TYPE = ["ModularAccountV2"] as const;
+
+type Supported7702AccountType = (typeof EIP_7702_ACCOUNT_TYPE)[number];
 
-const IMPLEMENTATION_ADDRESS_TO_ACCOUNT_TYPE: Record<
+const Eip7702AccountTypeToDelegationAddress = {
+  ModularAccountV2: "0x69007702764179f14F51cdce752f4f775d74E139",
+} as const satisfies Record<Supported7702AccountType, Address>;
+
+const DelegationAddressToAccountType: Record<
   Address,
   Supported7702AccountType
-> = {
-  "0x69007702764179f14F51cdce752f4f775d74E139": "ModularAccountV2",
+> = Object.fromEntries(
+  Object.entries(Eip7702AccountTypeToDelegationAddress).map(([key, value]) => [
+    value,
+    key,
+  ]),
+) as Record<Address, Supported7702AccountType>;
+
+export const SUPPORTED_DELEGATION_ADDRESSES = Object.values(
+  Eip7702AccountTypeToDelegationAddress,
+);
+
+export const isSupportedDelegationAddress7702 = (address: Address): boolean => {
+  return (SUPPORTED_DELEGATION_ADDRESSES as Address[]).includes(address);
 };
 
-export const getAccountTypeForImplementationAddress7702 = (
+export const getAccountTypeForDelegationAddress7702 = (
   address: Address,
 ): Supported7702AccountType | undefined => {
-  return IMPLEMENTATION_ADDRESS_TO_ACCOUNT_TYPE[address];
+  return DelegationAddressToAccountType[address];
 };
 
-const SUPPORTED_IMPLEMENTATION_ADDRESSES = Object.keys(
-  IMPLEMENTATION_ADDRESS_TO_ACCOUNT_TYPE,
-);
+const getDelegationAddressForAccountType7702 = (
+  accountType: Supported7702AccountType,
+): (typeof SUPPORTED_DELEGATION_ADDRESSES)[number] => {
+  return Eip7702AccountTypeToDelegationAddress[accountType];
+};
+
+const DEFAULT_7702_DELEGATION_ADDR =
+  Eip7702AccountTypeToDelegationAddress["ModularAccountV2"];
 
-export const isSupportedImplementationAddress7702 = (
-  address: string,
-): boolean => {
-  return SUPPORTED_IMPLEMENTATION_ADDRESSES.includes(address);
+export const parseDelegation = (
+  eip7702AuthCapability: Static<typeof Eip7702AuthCapability>,
+) => {
+  return eip7702AuthCapability === true
+    ? DEFAULT_7702_DELEGATION_ADDR
+    : isAddress(eip7702AuthCapability.delegation)
+      ? eip7702AuthCapability.delegation
+      : getDelegationAddressForAccountType7702(
+          eip7702AuthCapability.delegation,
+        );
+};
+
+export const assertValid7702AccountAddress = (
+  fromAddress: Address,
+  eip7702AuthCapability: Static<typeof Eip7702AuthCapability> | undefined,
+) => {
+  if (
+    eip7702AuthCapability &&
+    typeof eip7702AuthCapability === "object" &&
+    "account" in eip7702AuthCapability &&
+    eip7702AuthCapability?.account !== fromAddress
+  ) {
+    throw new InvalidRequestError({
+      message: `EIP-7702 delegation account ${eip7702AuthCapability.account} must match 'from' address ${fromAddress}.`,
+    });
+  }
 };

package/src/isomorphic/utils/createAccount.ts

@@ -6,12 +6,12 @@ import {
 import type { StaticDecode } from "@sinclair/typebox";
 import type { Address, Chain, Transport } from "viem";
 import { concatHex, hexToNumber } from "viem";
-import type { Capabilities } from "../../capabilities/index.js";
 import type { TypeSerializedInitcode } from "../../schemas.js";
 import { parsePermissionsContext } from "./parsePermissionsContext.js";
 import { assertNever } from "../../utils.js";
-import { getAccountTypeForImplementationAddress7702 } from "./7702.js";
+import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
 import { InternalError } from "ox/RpcResponse";
+import { PermissionsCapability } from "../../capabilities/permissions/index.js";
 
 type CreateAccountParams = {
   chain: Chain;
@@ -19,8 +19,8 @@ type CreateAccountParams = {
   signer: SmartAccountSigner;
   accountAddress: Address;
   counterfactualInfo?: StaticDecode<typeof TypeSerializedInitcode>; // undefined for 7702 accounts
+  permissions?: StaticDecode<typeof PermissionsCapability>;
   delegation?: Address;
-  capabilities?: StaticDecode<typeof Capabilities>;
 };
 
 /**
@@ -47,7 +47,7 @@ export async function createAccount(
       });
     }
   } else if (mode === "7702") {
-    const accountType = getAccountTypeForImplementationAddress7702(
+    const accountType = getAccountTypeForDelegationAddress7702(
       params.delegation!,
     );
     if (accountType !== "ModularAccountV2") {
@@ -60,7 +60,7 @@ export async function createAccount(
   }
 
   const parsedContext = parsePermissionsContext(
-    params.capabilities,
+    params.permissions,
     ci,
     params.delegation,
   );

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/isomorphic/utils/parsePermissionsContext.ts

@@ -2,33 +2,33 @@ import type { StaticDecode } from "@sinclair/typebox";
 import { InvalidRequestError } from "ox/RpcResponse";
 import { decodePermissionsContext } from "../../capabilities/permissions/mav2.js";
 import type { TypeSerializedInitcode } from "../../schemas.js";
-import type { PrepareCallsParams } from "../actions/prepareCalls.js";
 import type { Address } from "viem";
-import { getAccountTypeForImplementationAddress7702 } from "./7702.js";
+import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
+import { PermissionsCapability } from "../../capabilities/permissions/index.js";
 
 export function parsePermissionsContext(
-  capabilities: PrepareCallsParams["capabilities"],
-  parsedCi: StaticDecode<typeof TypeSerializedInitcode> | undefined,
+  permissions?: StaticDecode<typeof PermissionsCapability>,
+  parsedCi?: StaticDecode<typeof TypeSerializedInitcode> | undefined,
   delegation7702?: Address,
 ) {
-  if (!capabilities?.permissions) {
+  if (!permissions) {
     return undefined;
   }
 
-  if ("sessionId" in capabilities.permissions) {
+  if ("sessionId" in permissions) {
     throw new InvalidRequestError({
       message: "Remote permissions are not supported in isomorphic client",
     });
   }
 
-  if (!("context" in capabilities.permissions)) {
+  if (!("context" in permissions)) {
     return undefined;
   }
 
   const isMAV2 =
     (parsedCi && parsedCi.factoryType === "MAv2.0.0-sma-b") ||
     (delegation7702 &&
-      getAccountTypeForImplementationAddress7702(delegation7702) ===
+      getAccountTypeForDelegationAddress7702(delegation7702) ===
         "ModularAccountV2");
 
   if (!isMAV2) {
@@ -37,7 +37,7 @@ export function parsePermissionsContext(
     });
   }
 
-  const context = decodePermissionsContext(capabilities.permissions);
+  const context = decodePermissionsContext(permissions);
 
   if (context?.contextVersion === "REMOTE_MODE_DEFERRED_ACTION") {
     throw new InvalidRequestError({