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

package/src/client/decorator.ts

@@ -1,15 +1,6 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import type {
-  Hex,
-  JsonRpcAccount,
-  SignableMessage,
-  TypedDataDefinition,
-} from "viem";
-import type {
-  SendPreparedCallsParams,
-  SendPreparedCallsResult,
-} from "../isomorphic/actions/sendPreparedCalls";
-import type { InnerWalletApiClient } from "../types";
+import type { Address, Hex } from "viem";
+import type { InnerWalletApiClient } from "../types.ts";
 import {
   createAccount,
   type CreateAccountParams,
@@ -40,20 +31,32 @@ import {
   type RequestAccountParams,
   type RequestAccountResult,
 } from "./actions/requestAccount.js";
-import { sendPreparedCalls } from "./actions/sendPreparedCalls.js";
-import { signMessage } from "./actions/signMessage.js";
+import {
+  sendPreparedCalls,
+  type SendPreparedCallsParams,
+  type SendPreparedCallsResult,
+} from "./actions/sendPreparedCalls.js";
+import { signMessage, type SignMessageParams } from "./actions/signMessage.js";
 import {
   signSignatureRequest,
   type SignSignatureRequestParams,
   type SignSignatureRequestResult,
 } from "./actions/signSignatureRequest.js";
-import { signTypedData } from "./actions/signTypedData.js";
+import {
+  signTypedData,
+  type SignTypedDataParams,
+} from "./actions/signTypedData.js";
+import {
+  signPreparedCalls,
+  type SignPreparedCallsParams,
+  type SignPreparedCallsResult,
+} from "./actions/signPreparedCalls.js";
 
 export type SmartWalletActions<
-  TAccount extends JsonRpcAccount | undefined = JsonRpcAccount | undefined,
+  TAccount extends Address | undefined = Address | undefined,
 > = {
   requestAccount: (
-    params?: RequestAccountParams<TAccount>,
+    params?: RequestAccountParams,
   ) => Promise<RequestAccountResult>;
   prepareCalls: (
     params: PrepareCallsParams<TAccount>,
@@ -69,32 +72,31 @@ export type SmartWalletActions<
   signSignatureRequest: (
     params: SignSignatureRequestParams,
   ) => Promise<SignSignatureRequestResult>;
-  signMessage: (params: SignableMessage) => Promise<Hex>;
-  signTypedData: (params: TypedDataDefinition) => Promise<Hex>;
+  signPreparedCalls: (
+    params: SignPreparedCallsParams,
+  ) => Promise<SignPreparedCallsResult>;
+  signMessage: (params: SignMessageParams) => Promise<Hex>;
+  signTypedData: (params: SignTypedDataParams) => Promise<Hex>;
   grantPermissions: (
     params: GrantPermissionsParams<TAccount>,
   ) => Promise<GrantPermissionsResult>;
 };
 
 export function smartWalletClientActions<
-  TAccount extends JsonRpcAccount | undefined = JsonRpcAccount | undefined,
+  TAccount extends Address | undefined = Address | undefined,
 >(
-  client: InnerWalletApiClient<TAccount>,
-  signer: SmartAccountSigner,
-): SmartWalletActions<TAccount>;
-
-export function smartWalletClientActions(
   client: InnerWalletApiClient,
   signer: SmartAccountSigner,
-): SmartWalletActions {
+): SmartWalletActions<TAccount> {
   return {
     requestAccount: (params) => requestAccount(client, signer, params),
     createAccount: (params) => createAccount(client, signer, params),
     prepareCalls: (params) => prepareCalls(client, params),
-    listAccounts: (params) => listAccounts(client, params),
+    listAccounts: (params) => listAccounts(client, signer, params),
     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/client/index.ts

@@ -1,55 +1,65 @@
-import { type SmartAccountSigner } from "@aa-sdk/core";
-import { type AlchemyTransport } from "@account-kit/infra";
-import {
-  type Address,
-  type Chain,
-  type IsUndefined,
-  type JsonRpcAccount,
-  type Prettify,
-} from "viem";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { AlchemyTransport } from "@account-kit/infra";
+import type { Address, Chain, Prettify } from "viem";
 import { createLocalClient } from "../local/client.js";
 import { createRemoteClient } from "../remote/client.js";
-import type { InnerWalletApiClient } from "../types";
+import type { InnerWalletApiClient } from "../types.ts";
 import {
   smartWalletClientActions,
   type SmartWalletActions,
 } 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 function createSmartWalletClient<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
->(
-  params: SmartWalletClientParams<TAccount>,
-): InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
+export type SmartWalletClient<
+  TAccount extends Address | undefined = Address | undefined,
+> = InnerWalletApiClient & SmartWalletActions<TAccount>;
 
+/**
+ * Creates a smart wallet client that can be used to interact with a smart account.
+ *
+ * @param {SmartWalletClientParams} params - The parameters for creating the smart wallet client
+ * @param {AlchemyTransport} params.transport - The Alchemy transport to use
+ * @param {Chain} params.chain - The chain to use
+ * @param {SmartAccountSigner} params.signer - The signer to use for the smart account
+ * @param {"local" | "remote"} params.mode - The client's mode (local or remote).
+ * @param {string} [params.policyId] - The policy ID for gas sponsorship (optional)
+ * @param {Address} [params.account] - The smart account address to use (optional)
+ * @returns {SmartWalletClient} - A viem-compatible client
+ *
+ * @example
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { alchemy, arbitrumSepolia } from "@account-kit/infra";
+ * import { generatePrivateKey } from "viem/accounts";
+ * import { createSmartWalletClient } from "@account-kit/wallet-client";
+ *
+ * const signer = LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey());
+ * const transport = alchemy({
+ *   apiKey: "your-alchemy-api-key",
+ * });
+ * const client = createSmartWalletClient({
+ *   transport,
+ *   chain: arbitrumSepolia,
+ *   mode: "remote",
+ *   signer,
+ * });
+ */
 export function createSmartWalletClient<
-  TAccount extends JsonRpcAccount<Address> = JsonRpcAccount<Address>,
->(
-  params: SmartWalletClientParams<TAccount>,
-): InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
+  TAccount extends Address | undefined = undefined,
+>(params: SmartWalletClientParams<TAccount>): SmartWalletClient<TAccount>;
 
-export function createSmartWalletClient(params: SmartWalletClientParams) {
+export function createSmartWalletClient(
+  params: SmartWalletClientParams,
+): SmartWalletClient {
   const { transport, chain, policyId, mode, account, signer } = params;
 
   const innerClient =

package/src/exports/index.ts

@@ -2,31 +2,23 @@
 // and we shouldn't export * for the sake of tree-shaking
 export {
   createSmartWalletClient,
+  type SmartWalletClient,
   type SmartWalletClientParams,
 } from "../client/index.js";
 
 export {
   WalletServerRpcSchema,
   type WalletServerRpcSchemaType,
-  type WalletServerViemRpcSchema,
-} from "../rpc/schema.js";
-
-// capabilities: TODO: should these actually just have the types exported?
-export { Capabilities } from "../capabilities/index.js";
-export { PaymasterCapability } from "../capabilities/paymaster.js";
-export {
-  PermissionsArray,
-  PermissionsCapability,
-  PermissionsContext,
-  PermissionsData,
-} from "../capabilities/permissions/index.js";
+} from "@alchemy/wallet-api-types/rpc";
 
 // client actions
 export { createAccount } from "../client/actions/createAccount.js";
 export { getCallsStatus } from "../client/actions/getCallsStatus.js";
+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/exports/internal.ts

@@ -1,16 +1,8 @@
 // exports from this file are meant to be imported by our packages in the monorepo
 // we will expose this in the package.json as a named export like `this-pkg/internal`
 // TODO: name `this-pkg`
-export * from "../capabilities/index.js";
-export * from "../capabilities/paymaster.js";
-export * from "../capabilities/permissions/index.js";
-export * from "../capabilities/permissions/mav2.js";
 export type * from "../isomorphic/client.js";
 export { createIsomorphicClient } from "../isomorphic/client.js";
 export { createDummySigner } from "../isomorphic/utils/createDummySigner.js";
-export * from "../rpc/request.js";
-export * as RpcSchemas from "../rpc/request.js";
-export * from "../rpc/schema.js";
-export * from "../schemas.js";
-export type * from "../types";
-export * from "../utils.js";
+
+export type * from "../types.ts";

package/src/internal/decorator.ts

@@ -0,0 +1,12 @@
+import type { CachedAccount, InternalState } from "../types.ts";
+
+export function internalStateDecorator(): InternalState {
+  let account: CachedAccount | undefined = undefined;
+
+  return {
+    setAccount: (newAccount: CachedAccount) => {
+      account = newAccount;
+    },
+    getAccount: () => account,
+  };
+}

package/src/isomorphic/actions/createSession.ts

@@ -12,18 +12,26 @@ import { Value } from "@sinclair/typebox/value";
 import {
   ChainNotFoundError,
   custom,
+  hashTypedData,
   hexToNumber,
   toHex,
   type Chain,
   type Hex,
   type Transport,
 } from "viem";
-import { TypePermission } from "../../capabilities/permissions/index.js";
-import { isGlobalValidation } from "../../capabilities/permissions/mav2.js";
-import type { wallet_createSession } from "../../rpc/request.js";
-import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
+import { InvalidRequestError } from "ox/RpcResponse";
+import {
+  Permission,
+  isGlobalValidation,
+} from "@alchemy/wallet-api-types/capabilities";
+import type {
+  wallet_createSession,
+  WalletServerViemRpcSchema,
+} from "@alchemy/wallet-api-types/rpc";
 import { createAccount, isModularAccountV2 } from "../utils/createAccount.js";
 import { createDummySigner } from "../utils/createDummySigner.js";
+import { supportsFeature } from "../utils/supportsFeature.js";
+import { isDelegated } from "../utils/7702.js";
 
 export type CreateSessionParams = Omit<
   Static<
@@ -57,29 +65,58 @@ export async function createSession(
     throw new ChainNotFoundError();
   }
 
-  const { counterfactualInfo } = await client.request({
+  const { counterfactualInfo, delegation } = await client.request({
     method: "wallet_requestAccount",
     params: [
       {
-        includeCounterfactualInfo: true,
         accountAddress: params.account,
+        includeCounterfactualInfo: true,
       },
     ],
   });
-  if (!counterfactualInfo) {
-    throw new Error("No counterfactual info found.");
+
+  if (
+    delegation &&
+    !(await isDelegated(client, {
+      address: params.account,
+      delegation,
+    }))
+  ) {
+    throw new InvalidRequestError({
+      message:
+        "7702 account must be delegated before calling `wallet_createSession`",
+    });
   }
 
+  if (!delegation && !counterfactualInfo) {
+    throw new InvalidRequestError({
+      message: "No counterfactual info found.",
+    });
+  }
+
+  if (
+    counterfactualInfo &&
+    !supportsFeature(counterfactualInfo, "permissions")
+  ) {
+    throw new InvalidRequestError({
+      message: "Account type does not support createSession",
+    });
+  }
+
+  // At this point we know the account supports the permission feature
   const account = await createAccount({
     chain: client.chain,
     transport: custom(client.transport),
     signer: createDummySigner(params.account),
     accountAddress: params.account,
     counterfactualInfo,
+    delegation,
   });
 
   if (!isModularAccountV2(account)) {
-    throw new Error("Sessions are currently only supported by MAv2 accounts.");
+    throw new InvalidRequestError({
+      message: "Sessions are currently only supported by MAv2 accounts.",
+    });
   }
 
   const _client = createSmartAccountClient({
@@ -96,24 +133,30 @@ 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,
+      deadline: params.expirySec,
     })
       .addPermissions({
         permissions: params.permissions.map((permission) =>
-          Value.Encode(TypePermission, permission),
+          Value.Encode(Permission, permission),
         ),
       })
       .compileDeferred();
 
   return {
     sessionId: null, // In remote mode, the server will set this later.
+    chainId: toHex(client.chain.id),
     entityId: toHex(entityId),
     signatureRequest: {
-      type: "eth_signTypedData_v4",
+      type: "eth_signTypedData_v4" as const,
       data: typedData,
+      rawPayload: hashTypedData(typedData),
     },
     fullPreSignatureDeferredActionDigest,
   };

package/src/isomorphic/actions/formatSign.ts

@@ -0,0 +1,76 @@
+import type { Static } from "@sinclair/typebox";
+import type { wallet_formatSign } from "@alchemy/wallet-api-types/rpc";
+import type { SmartAccountClient, SmartContractAccount } from "@aa-sdk/core";
+import {
+  ChainNotFoundError,
+  concat,
+  custom,
+  encodeAbiParameters,
+  parseAbiParameters,
+  type Chain,
+  type Transport,
+} from "viem";
+import type { WalletServerViemRpcSchema } from "@alchemy/wallet-api-types/rpc";
+import { createAccount } from "../utils/createAccount.js";
+import { createDummySigner } from "../utils/createDummySigner.js";
+import { magicBytes } from "ox/erc6492/WrappedSignature";
+
+export type FormatSignParams = Static<
+  (typeof wallet_formatSign)["properties"]["Request"]["properties"]["params"]
+>[0];
+
+export type FormatSignResult = Static<
+  (typeof wallet_formatSign)["properties"]["ReturnType"]
+>;
+
+export async function formatSign(
+  client: SmartAccountClient<
+    Transport,
+    Chain,
+    SmartContractAccount | undefined,
+    Record<string, unknown>,
+    WalletServerViemRpcSchema
+  >,
+  params: FormatSignParams,
+): Promise<FormatSignResult> {
+  if (!client.chain) {
+    throw new ChainNotFoundError();
+  }
+
+  const { counterfactualInfo, delegation } = await client.request({
+    method: "wallet_requestAccount",
+    params: [
+      {
+        accountAddress: params.from,
+        includeCounterfactualInfo: true,
+      },
+    ],
+  });
+
+  const account = await createAccount({
+    chain: client.chain,
+    transport: custom(client.transport),
+    signer: createDummySigner(params.from),
+    accountAddress: params.from,
+    counterfactualInfo,
+    permissions: params.capabilities?.permissions,
+    delegation,
+  });
+
+  let formattedSignature = await account.formatSign(params.signature.data);
+
+  if (counterfactualInfo && !(await account.isAccountDeployed())) {
+    formattedSignature = concat([
+      encodeAbiParameters(parseAbiParameters("address, bytes, bytes"), [
+        counterfactualInfo.factoryAddress,
+        counterfactualInfo.factoryData,
+        formattedSignature,
+      ]),
+      magicBytes,
+    ]);
+  }
+
+  return {
+    signature: formattedSignature,
+  };
+}

package/src/isomorphic/actions/getCallsStatus.ts

@@ -12,9 +12,14 @@ import {
   type TransactionReceipt,
   type Transport,
 } from "viem";
-import type { wallet_getCallsStatus } from "../../rpc/request.js";
-import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
-import { TypeCallId } from "../../schemas.js";
+import { BaseError } from "ox/RpcResponse";
+import {
+  CallStatusCode,
+  CallStatusErrorCode,
+  type wallet_getCallsStatus,
+  type WalletServerViemRpcSchema,
+} from "@alchemy/wallet-api-types/rpc";
+import { CallId } from "@alchemy/wallet-api-types";
 import { castToHex } from "../../utils.js";
 
 export type GetCallsStatusParams = Static<
@@ -25,25 +30,6 @@ export type GetCallsStatusResponse = Static<
   (typeof wallet_getCallsStatus)["properties"]["ReturnType"]
 >;
 
-const ReceiptStatus: Record<TransactionReceipt["status"], Hex> = {
-  reverted: "0x0",
-  success: "0x1",
-};
-
-/** EIP-5792 call status codes */
-export const CallStatusCode = {
-  /** Batch has been received by the wallet but has not completed execution onchain */
-  PENDING: 100,
-  /** Batch has been included onchain without reverts, receipts array contains info of all calls */
-  CONFIRMED: 200,
-  /** Batch has not been included onchain and wallet will not retry */
-  OFFCHAIN_FAILURE: 400,
-  /** Batch reverted *completely* and only changes related to gas charge may have been included onchain */
-  CHAIN_RULES_FAILURE: 500,
-  /** Batch reverted *partially* and some changes related to batch calls may have been included onchain */
-  PARTIAL_CHAIN_RULES_FAILURE: 600,
-} as const;
-
 export async function getCallsStatus(
   client: SmartAccountClient<
     Transport,
@@ -57,24 +43,52 @@ export async function getCallsStatus(
   if (!client.chain) {
     throw new ChainNotFoundError();
   }
+  const { chainId, hash } = Value.Decode(CallId, callId);
 
-  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) {
+    throw new BaseError({
+      message: `callId ${callId} not found`,
+      code: CallStatusErrorCode.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 (!receipt) {
+    // Handles edge case of hash being retrieved immediately before the 150 block limit falloff.
+    throw new BaseError({
+      message: `callId ${callId} not found`,
+      code: CallStatusErrorCode.UNKNOWN_BUNDLE_ID,
+    });
+  }
+
+  return {
+    ...baseResp,
+    status: receipt.success
+      ? CallStatusCode.CONFIRMED
+      : CallStatusCode.CHAIN_RULES_FAILURE,
+    receipts: [transformReceipt(receipt.receipt)],
   };
 }
 
+const ReceiptStatus: Record<TransactionReceipt["status"], Hex> = {
+  reverted: "0x0",
+  success: "0x1",
+};
+
 function transformReceipt(
   receipt: TransactionReceipt,
 ): NonNullable<GetCallsStatusResponse["receipts"]>[number] {