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

package/src/client/index.ts

@@ -1,12 +1,6 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { AlchemyTransport } from "@account-kit/infra";
-import type {
-  Address,
-  Chain,
-  IsUndefined,
-  JsonRpcAccount,
-  Prettify,
-} from "viem";
+import type { Address, Chain, Prettify } from "viem";
 import { createLocalClient } from "../local/client.js";
 import { createRemoteClient } from "../remote/client.js";
 import type { InnerWalletApiClient } from "../types.ts";
@@ -16,40 +10,19 @@ import {
 } from "./decorator.js";
 
 export type SmartWalletClientParams<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
-> = Prettify<
-  {
-    transport: AlchemyTransport;
-    chain: Chain;
-    signer: SmartAccountSigner;
-    mode: "local" | "remote";
-    policyId?: string;
-  } & (IsUndefined<TAccount> extends true
-    ? {
-        account?: never;
-      }
-    : {
-        account: Address;
-      })
->;
+  TAccount extends Address | undefined = Address | undefined,
+> = Prettify<{
+  transport: AlchemyTransport;
+  chain: Chain;
+  signer: SmartAccountSigner;
+  mode: "local" | "remote";
+  policyId?: string;
+  account?: TAccount | Address | undefined;
+}>;
 
 export type SmartWalletClient<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
-> = InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
-
-export function createSmartWalletClient<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
->(params: SmartWalletClientParams<TAccount>): SmartWalletClient<TAccount>;
-
-export function createSmartWalletClient<
-  TAccount extends JsonRpcAccount<Address> = JsonRpcAccount<Address>,
->(params: SmartWalletClientParams<TAccount>): SmartWalletClient<TAccount>;
+  TAccount extends Address | undefined = Address | undefined,
+> = InnerWalletApiClient & SmartWalletActions<TAccount>;
 
 /**
  * Creates a smart wallet client that can be used to interact with a smart account.
@@ -80,6 +53,10 @@ export function createSmartWalletClient<
  *   signer,
  * });
  */
+export function createSmartWalletClient<
+  TAccount extends Address | undefined = undefined,
+>(params: SmartWalletClientParams<TAccount>): SmartWalletClient<TAccount>;
+
 export function createSmartWalletClient(
   params: SmartWalletClientParams,
 ): SmartWalletClient {

package/src/isomorphic/actions/createSession.ts

@@ -26,6 +26,10 @@ 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<
@@ -59,15 +63,26 @@ export async function createSession(
     throw new ChainNotFoundError();
   }
 
-  const { counterfactualInfo, delegation } = await client.request({
-    method: "wallet_requestAccount",
-    params: [
-      {
-        accountAddress: params.account,
-        includeCounterfactualInfo: true,
-      },
-    ],
-  });
+  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,
+          },
+        ],
+      });
+
   if (!counterfactualInfo && !delegation) {
     throw new InvalidRequestError({
       message:
@@ -104,7 +119,11 @@ export async function createSession(
   const { typedData, fullPreSignatureDeferredActionDigest } =
     await new PermissionBuilder({
       client: _client,
-      key: params.key,
+      key: {
+        ...params.key,
+        // Alias 'ecdsa' to 'secp256k1'
+        type: params.key.type === "ecdsa" ? "secp256k1" : params.key.type,
+      },
       entityId,
       nonce,
       deadline: params.expiry,

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,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 } from "../utils/7702.js";
+import { createAuthorization, parseDelegation } from "../utils/7702.js";
 import { InvalidRequestError } from "ox/RpcResponse";
+import { assertValid7702AccountAddress } from "../utils/7702.js";
 
 export type PrepareCallsParams = Omit<
   Static<
@@ -45,16 +46,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,7 +77,7 @@ export async function prepareCalls(
     signer: createDummySigner(params.from),
     accountAddress: params.from,
     counterfactualInfo,
-    capabilities: params.capabilities,
+    permissions: params.capabilities?.permissions,
     delegation,
   });
 

package/src/isomorphic/actions/sendPreparedCalls.ts

@@ -19,7 +19,7 @@ import { decodePermissionsContext } from "../../capabilities/permissions/mav2.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";
 
 export type SendPreparedCallsParams = Omit<
@@ -51,7 +51,7 @@ export async function sendPreparedCalls(
   // 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)
+    !isSupportedDelegationAddress7702(params.signedAuthorization.address)
   ) {
     throw new InvalidRequestError({
       message: `Unsupported 7702 delegation address: ${params.signedAuthorization.address}`,

package/src/isomorphic/utils/7702.ts

@@ -5,8 +5,12 @@ import {
   type Address,
   type Chain,
   type Transport,
+  isAddress,
 } from "viem";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
+import type { Eip7702AuthCapability } from "../../capabilities/eip7702Auth.ts";
+import type { Static } from "@sinclair/typebox";
+import { InvalidRequestError } from "ox/RpcResponse";
 
 export const createAuthorization = async (
   client: SmartAccountClient<
@@ -32,27 +36,71 @@ export const createAuthorization = async (
   };
 };
 
-type Supported7702AccountType = "ModularAccountV2";
+export const EIP_7702_ACCOUNT_TYPE = ["ModularAccountV2"] as const;
 
-const IMPLEMENTATION_ADDRESS_TO_ACCOUNT_TYPE: Record<
+type Supported7702AccountType = (typeof EIP_7702_ACCOUNT_TYPE)[number];
+
+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/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({

package/src/local/client.ts

@@ -1,6 +1,6 @@
 import { split } from "@aa-sdk/core";
 import { buildDeferredActionDigest } from "@account-kit/smart-contracts/experimental";
-import { createClient, custom, type Address, type JsonRpcAccount } from "viem";
+import { createClient, custom, type Address } from "viem";
 import {
   encodePermissionsContext,
   prefixSignatureKeyType,
@@ -28,10 +28,8 @@ const localMethods = [
 type LocalMethod = (typeof localMethods)[number];
 
 export function createLocalClient<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
->(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient<TAccount>;
+  TAccount extends Address | undefined = Address | undefined,
+>(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient;
 
 export function createLocalClient(
   params: CreateInnerClientParams,

package/src/remote/client.ts

@@ -1,11 +1,5 @@
 import { Provider } from "ox";
-import {
-  BaseError,
-  createClient,
-  custom,
-  type Address,
-  type JsonRpcAccount,
-} from "viem";
+import { BaseError, 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";
@@ -17,18 +11,16 @@ import type {
   InnerWalletApiClientBase,
 } from "../types.ts";
 
-export function createRemoteClient<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
->(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient<TAccount>;
-
 /**
  * This is a low-level client just used to make RPC requests in remote mode
  * This should be wrapped by a higher-level smart account client that provides actions
  * that uses this client under the hood
  * @returns
  */
+export function createRemoteClient<
+  TAccount extends Address | undefined = Address | undefined,
+>(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient;
+
 export function createRemoteClient(
   params: CreateInnerClientParams,
 ): InnerWalletApiClient {

package/src/rpc/request.ts

@@ -16,8 +16,10 @@ import {
   TypeUserOperationRequest_v6,
   TypeUserOperationRequest_v7,
   TypeUuid,
+  TypeSignatureType,
 } from "../schemas.js";
 import { Examples } from "./examples.js";
+import { Eip7702AuthCapability } from "../capabilities/eip7702Auth.js";
 
 export const wallet_sendPreparedCalls = Type.Object(
   {
@@ -43,15 +45,7 @@ export const wallet_sendPreparedCalls = Type.Object(
           ]),
           chainId: TypeHex(),
           signature: Type.Object({
-            type: Type.Transform(Type.Literal("ecdsa"))
-              .Decode((value) => {
-                if (value.toLowerCase() !== "ecdsa") {
-                  throw new Error("Invalid signature type, must be 'ecdsa'");
-                }
-
-                return "ecdsa" as const;
-              })
-              .Encode((value) => value),
+            type: Type.Exclude(TypeSignatureType, Type.Literal("contract")),
             signature: TypeHex(),
           }),
           signedAuthorization: Type.Optional(TypeEip7702AuthExtendedFields),
@@ -235,6 +229,11 @@ export const wallet_createSession = Type.Object(
           PermissionsData,
           Type.Object({
             account: TypeAddress,
+            capabilities: Type.Optional(
+              Type.Object({
+                eip7702Auth: Type.Optional(Eip7702AuthCapability),
+              }),
+            ),
           }),
         ]),
       ]),

package/src/schemas.ts

@@ -287,11 +287,15 @@ export type TypeAccountType = Exclude<
   undefined
 >["accountType"];
 
+export const TypeSignatureType = Type.Union([
+  Type.Literal("secp256k1", { title: "Secp256k1" }),
+  Type.Literal("ecdsa", { title: "ECDSA (alias for secp256k1)" }),
+  Type.Literal("contract", { title: "Contract" }),
+]);
+export type TypeSignatureType = Static<typeof TypeSignatureType>;
+
 export const KeySigner = Type.Object({
-  type: Type.Union([
-    Type.Literal("secp256k1", { title: "Secp256k1" }),
-    Type.Literal("contract", { title: "Contract" }),
-  ]),
+  type: TypeSignatureType,
   publicKey: TypeHex({}),
 });
 export type KeySigner = Static<typeof KeySigner>;