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

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 {
+  TypePermission,
+  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,10 +133,14 @@ 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) =>
@@ -110,10 +151,12 @@ export async function createSession(
 
   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 { TypeCallId } 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(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] {

package/src/isomorphic/actions/prepareCalls.ts

@@ -1,5 +1,6 @@
 import {
   deepHexlify,
+  default7702GasEstimator,
   type SmartAccountClient,
   type SmartContractAccount,
 } from "@aa-sdk/core";
@@ -8,15 +9,21 @@ import {
   ChainNotFoundError,
   custom,
   fromHex,
+  hashMessage,
   toHex,
-  zeroAddress,
   type Chain,
   type Transport,
 } from "viem";
-import type { wallet_prepareCalls } from "../../rpc/request.js";
-import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
+import type {
+  wallet_prepareCalls,
+  WalletServerViemRpcSchema,
+} from "@alchemy/wallet-api-types/rpc";
 import { createAccount } from "../utils/createAccount.js";
 import { createDummySigner } from "../utils/createDummySigner.js";
+import { createAuthorizationRequest, isDelegated } 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<
@@ -29,7 +36,6 @@ export type PrepareCallsResult = Static<
   (typeof wallet_prepareCalls)["properties"]["ReturnType"]
 >;
 
-// TODO: handle capabilities like permissions and paymaster here
 export async function prepareCalls(
   client: SmartAccountClient<
     Transport,
@@ -44,29 +50,70 @@ 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 } = await client.request({
+  const { counterfactualInfo, delegation } = await client.request({
     method: "wallet_requestAccount",
     params: [
-      {
-        accountAddress: params.from,
-        includeCounterfactualInfo: true,
-      },
+      params.capabilities?.eip7702Auth
+        ? {
+            signerAddress: params.from,
+            creationHint: {
+              accountType: "7702",
+            },
+            includeCounterfactualInfo: true,
+          }
+        : {
+            accountAddress: params.from,
+            includeCounterfactualInfo: true,
+          },
     ],
   });
-  if (!counterfactualInfo) {
-    throw new Error("No counterfactual info found.");
+
+  if (!counterfactualInfo && !delegation) {
+    throw new InvalidRequestError({
+      message:
+        "No counterfactual info or delegated implementation address found.",
+    });
   }
 
   const account = await createAccount({
     chain: client.chain,
     transport: custom(client.transport),
-    signer: createDummySigner(zeroAddress),
+    signer: createDummySigner(params.from),
     accountAddress: params.from,
     counterfactualInfo,
-    capabilities: params.capabilities,
+    permissions: params.capabilities?.permissions,
+    delegation,
   });
 
+  const authorizationRequest =
+    delegation &&
+    !(await isDelegated(client, {
+      address: account.address,
+      delegation,
+    }))
+      ? await createAuthorizationRequest(client, {
+          address: account.address,
+          delegation,
+        })
+      : undefined;
+
+  if (params.capabilities?.permissions && authorizationRequest) {
+    // The user shouldn't see this in most cases since we require
+    // the account to be delegated before creating the session.
+    throw new InvalidRequestError({
+      message:
+        "When using a 7702 account with a session key, the account must be delegated before preparing calls.",
+    });
+  }
+
+  if (authorizationRequest) {
+    // @ts-expect-error - this is available but not typed as public
+    client.middleware.gasEstimator = default7702GasEstimator();
+  }
+
   // TODO: oops we don't actually support setting the policyId as an override here
   // if we assume that the the isomorphic client is never used directly, then we can assume that this is handled upstream correctly
   const builtUo = await client.buildUserOperation({
@@ -76,25 +123,50 @@ export async function prepareCalls(
       value: x.value ? fromHex(x.value, "bigint") : undefined,
     })),
     account,
-    overrides: params.capabilities?.gasParamsOverride,
+    overrides: {
+      ...params.capabilities?.gasParamsOverride,
+      nonceKey: params.capabilities?.nonceOverride?.nonceKey
+        ? fromHex(params.capabilities.nonceOverride.nonceKey, "bigint")
+        : undefined,
+    },
   });
 
-  const uoRequest = deepHexlify(builtUo);
+  // The eip7702Auth field should never be included in the UO sig
+  // request. It's handled by a separate authorization request.
+  if ("eip7702Auth" in builtUo) {
+    builtUo.eip7702Auth = undefined;
+  }
+
+  const hexlifiedUo = deepHexlify(builtUo);
+
+  const ep = account.getEntryPoint();
 
-  const hash = account.getEntryPoint().getUserOperationHash(uoRequest);
+  const uoHash = ep.getUserOperationHash(hexlifiedUo);
 
-  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: {
-      type: "personal_sign",
+      type: "personal_sign" as const,
       data: {
-        raw: hash,
+        raw: uoHash,
       },
+      rawPayload: hashMessage({
+        raw: uoHash,
+      }),
     },
   };
+
+  return authorizationRequest
+    ? {
+        type: "array" as const,
+        data: [authorizationRequest, uoRequest],
+      }
+    : uoRequest;
 }

package/src/isomorphic/actions/prepareSign.ts

@@ -0,0 +1,91 @@
+import type { Static } from "@sinclair/typebox";
+import type {
+  SignatureRequest,
+  SmartAccountClient,
+  SmartContractAccount,
+} from "@aa-sdk/core";
+import {
+  ChainNotFoundError,
+  custom,
+  toHex,
+  type Chain,
+  type Transport,
+} from "viem";
+import type {
+  wallet_prepareSign,
+  WalletServerViemRpcSchema,
+} from "@alchemy/wallet-api-types/rpc";
+import {
+  TypeSignableMessage,
+  jsonSafeTypedData,
+} from "@alchemy/wallet-api-types";
+import { createAccount } from "../utils/createAccount.js";
+import { createDummySigner } from "../utils/createDummySigner.js";
+import { Value } from "@sinclair/typebox/value";
+
+export type PrepareSignParams = Static<
+  (typeof wallet_prepareSign)["properties"]["Request"]["properties"]["params"]
+>[0];
+
+export type PrepareSignResult = Static<
+  (typeof wallet_prepareSign)["properties"]["ReturnType"]
+>;
+
+export async function prepareSign(
+  client: SmartAccountClient<
+    Transport,
+    Chain,
+    SmartContractAccount | undefined,
+    Record<string, unknown>,
+    WalletServerViemRpcSchema
+  >,
+  params: PrepareSignParams,
+): Promise<PrepareSignResult> {
+  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,
+  });
+
+  const signatureRequest = await account.prepareSign(
+    params.signatureRequest as SignatureRequest,
+  );
+
+  if (signatureRequest.type === "personal_sign") {
+    return {
+      chainId: toHex(client.chain.id),
+      signatureRequest: {
+        type: signatureRequest.type,
+        data: Value.Encode(TypeSignableMessage, signatureRequest.data),
+      },
+    };
+  } else {
+    const typedData = signatureRequest.data;
+
+    return {
+      chainId: toHex(client.chain.id),
+      signatureRequest: {
+        type: signatureRequest.type,
+        data: jsonSafeTypedData(typedData),
+      },
+    };
+  }
+}