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

package/src/client/client.e2e-test.ts

@@ -122,7 +122,7 @@ describe("Client E2E Tests", () => {
 
     it("should successfully send a UO with paymaster", async () => {
       const account = await client.requestAccount();
-      const preparedUO = await client.prepareCalls({
+      const preparedCall = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -132,20 +132,13 @@ describe("Client E2E Tests", () => {
         },
       });
 
-      if (preparedUO.signatureRequest.type !== "personal_sign") {
-        throw new Error("Invalid signature request type");
-      }
-
-      const signature = await signer.signMessage(
-        preparedUO.signatureRequest.data,
+      const signature = await client.signSignatureRequest(
+        preparedCall.signatureRequest,
       );
 
       const result = await client.sendPreparedCalls({
-        ...preparedUO,
-        signature: {
-          type: "ecdsa",
-          signature,
-        },
+        ...preparedCall,
+        signature,
       });
 
       expect(result.preparedCallIds).toBeArrayOfSize(1);
@@ -166,7 +159,7 @@ describe("Client E2E Tests", () => {
         permissions: [{ type: "root" }],
       });
 
-      const preparedUO = await client.prepareCalls({
+      const preparedCall = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -179,11 +172,11 @@ describe("Client E2E Tests", () => {
 
       const signature = await signSignatureRequest(
         sessionKey,
-        preparedUO.signatureRequest,
+        preparedCall.signatureRequest,
       );
 
       const result = await client.sendPreparedCalls({
-        ...preparedUO,
+        ...preparedCall,
         signature,
         capabilities: {
           permissions,
@@ -302,7 +295,7 @@ describe("Client E2E Tests", () => {
 
     it("should successfully send a UO with paymaster", async () => {
       const account = await client.requestAccount();
-      const preparedUO = await client.prepareCalls({
+      const preparedCall = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -313,11 +306,11 @@ describe("Client E2E Tests", () => {
       });
 
       const signature = await client.signSignatureRequest(
-        preparedUO.signatureRequest,
+        preparedCall.signatureRequest,
       );
 
       const result = await client.sendPreparedCalls({
-        ...preparedUO,
+        ...preparedCall,
         signature,
       });
 
@@ -339,7 +332,7 @@ describe("Client E2E Tests", () => {
         permissions: [{ type: "root" }],
       });
 
-      const preparedUO = await client.prepareCalls({
+      const preparedCall = await client.prepareCalls({
         calls: [{ to: zeroAddress, value: "0x0" }],
         from: account.address,
         capabilities: {
@@ -352,11 +345,11 @@ describe("Client E2E Tests", () => {
 
       const signature = await signSignatureRequest(
         sessionKey,
-        preparedUO.signatureRequest,
+        preparedCall.signatureRequest,
       );
 
       const result = await client.sendPreparedCalls({
-        ...preparedUO,
+        ...preparedCall,
         signature,
         capabilities: {
           permissions,

package/src/client/index.ts

@@ -1,4 +1,5 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { AlchemyTransport } from "@account-kit/infra";
 import type {
   Address,
   Chain,
@@ -13,7 +14,6 @@ import {
   smartWalletClientActions,
   type SmartWalletActions,
 } from "./decorator.js";
-import type { AlchemyTransport } from "@account-kit/infra";
 
 export type SmartWalletClientParams<
   TAccount extends JsonRpcAccount<Address> | undefined =
@@ -35,19 +35,21 @@ export type SmartWalletClientParams<
       })
 >;
 
+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>,
-): InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
+>(params: SmartWalletClientParams<TAccount>): SmartWalletClient<TAccount>;
 
 export function createSmartWalletClient<
   TAccount extends JsonRpcAccount<Address> = JsonRpcAccount<Address>,
->(
-  params: SmartWalletClientParams<TAccount>,
-): InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
+>(params: SmartWalletClientParams<TAccount>): SmartWalletClient<TAccount>;
 
 /**
  * Creates a smart wallet client that can be used to interact with a smart account.
@@ -59,13 +61,13 @@ export function createSmartWalletClient<
  * @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 {InnerWalletApiClient & SmartWalletActions} - A viem-compatible client
+ * @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-apis"; // TODO(jh): update this if we change the pkg name to `@account-kit/wallet-client`
+ * import { createSmartWalletClient } from "@account-kit/wallet-client";
  *
  * const signer = LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey());
  * const transport = alchemy({
@@ -80,7 +82,7 @@ export function createSmartWalletClient<
  */
 export function createSmartWalletClient(
   params: SmartWalletClientParams,
-): InnerWalletApiClient & SmartWalletActions {
+): SmartWalletClient {
   const { transport, chain, policyId, mode, account, signer } = params;
 
   const innerClient =

package/src/exports/index.ts

@@ -2,6 +2,7 @@
 // and we shouldn't export * for the sake of tree-shaking
 export {
   createSmartWalletClient,
+  type SmartWalletClient,
   type SmartWalletClientParams,
 } from "../client/index.js";
 
@@ -24,10 +25,10 @@ export {
 // 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 { signTypedData } from "../client/actions/signTypedData.js";
-export { grantPermissions } from "../client/actions/grantPermissions.js";

package/src/isomorphic/actions/createSession.ts

@@ -24,6 +24,8 @@ 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";
 
 export type CreateSessionParams = Omit<
   Static<
@@ -57,17 +59,20 @@ 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 (!counterfactualInfo && !delegation) {
+    throw new InvalidRequestError({
+      message:
+        "No counterfactual info or delegated implementation address found.",
+    });
   }
 
   const account = await createAccount({
@@ -76,10 +81,13 @@ export async function createSession(
     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({
@@ -108,12 +116,25 @@ 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: {
-      type: "eth_signTypedData_v4",
-      data: typedData,
+      ...signatureRequest,
+      ...(authorizationRequest ? { authorizationRequest } : {}),
     },
     fullPreSignatureDeferredActionDigest,
   };

package/src/isomorphic/actions/prepareCalls.ts

@@ -1,5 +1,6 @@
 import {
   deepHexlify,
+  default7702GasEstimator,
   type SmartAccountClient,
   type SmartContractAccount,
 } from "@aa-sdk/core";
@@ -9,7 +10,6 @@ import {
   custom,
   fromHex,
   toHex,
-  zeroAddress,
   type Chain,
   type Transport,
 } from "viem";
@@ -17,6 +17,8 @@ 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 { InvalidRequestError } from "ox/RpcResponse";
 
 export type PrepareCallsParams = Omit<
   Static<
@@ -29,7 +31,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,
@@ -45,7 +46,7 @@ export async function prepareCalls(
   }
 
   // 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: [
       {
@@ -54,19 +55,37 @@ export async function prepareCalls(
       },
     ],
   });
-  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,
+    delegation,
   });
 
+  // If using 7702, we need an Authorization (unless it's already authorized).
+  const authorizationRequest = delegation
+    ? await createAuthorization(client, {
+        address: account.address,
+        delegation,
+      })
+    : undefined;
+
+  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({
@@ -79,9 +98,19 @@ export async function prepareCalls(
     overrides: params.capabilities?.gasParamsOverride,
   });
 
+  // The eip7702Auth field should never be included in the UO sig
+  // request. It's handled by the separate authorization request.
+  if ("eip7702Auth" in builtUo) {
+    builtUo.eip7702Auth = undefined;
+  }
   const uoRequest = deepHexlify(builtUo);
 
-  const hash = account.getEntryPoint().getUserOperationHash(uoRequest);
+  const signatureRequest = {
+    type: "personal_sign" as const,
+    data: {
+      raw: account.getEntryPoint().getUserOperationHash(uoRequest),
+    },
+  };
 
   return {
     type:
@@ -91,10 +120,8 @@ export async function prepareCalls(
     data: uoRequest,
     chainId: toHex(client.chain.id),
     signatureRequest: {
-      type: "personal_sign",
-      data: {
-        raw: hash,
-      },
+      ...signatureRequest,
+      ...(authorizationRequest ? { authorizationRequest } : {}),
     },
   };
 }

package/src/isomorphic/actions/sendPreparedCalls.ts

@@ -6,6 +6,7 @@ import {
 import type { Static, StaticDecode } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import {
+  BaseError,
   ChainNotFoundError,
   concat,
   concatHex,
@@ -18,6 +19,8 @@ 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 { InvalidRequestError } from "ox/RpcResponse";
 
 export type SendPreparedCallsParams = Omit<
   StaticDecode<
@@ -45,19 +48,30 @@ 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?.context) {
+    if (!params.capabilities?.permissions) {
       return;
     }
 
     const decodedContext = decodePermissionsContext(
-      params.capabilities.permissions.context,
+      params.capabilities.permissions,
     );
 
     if (decodedContext.contextVersion === "REMOTE_MODE_DEFERRED_ACTION") {
-      throw new Error(
-        "Remote mode deferred action not supported in isomorphic client",
-      );
+      throw new InvalidRequestError({
+        message:
+          "Remote mode deferred action not supported in isomorphic client",
+      });
     }
 
     return decodedContext.deferredAction;
@@ -68,21 +82,34 @@ export async function sendPreparedCalls(
       ? getEntryPoint(client.chain, { version: "0.6.0" })
       : getEntryPoint(client.chain, { version: "0.7.0" });
 
-  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]),
-    },
-    entryPoint.address,
-  );
+  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;
+    });
 
   const callId = Value.Encode(TypeCallId, {
     chainId: toHex(client.chain.id),

package/src/isomorphic/utils/7702.ts

@@ -0,0 +1,58 @@
+import type { SmartAccountClient, SmartContractAccount } from "@aa-sdk/core";
+import {
+  concatHex,
+  type Authorization,
+  type Address,
+  type Chain,
+  type Transport,
+} from "viem";
+import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
+
+export const createAuthorization = async (
+  client: SmartAccountClient<
+    Transport,
+    Chain,
+    SmartContractAccount | undefined,
+    Record<string, unknown>,
+    WalletServerViemRpcSchema
+  >,
+  params: { address: Address; delegation: Address },
+): Promise<Authorization<number, false> | 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,
+    address: params.delegation,
+    nonce: await client.getTransactionCount({
+      address: params.address,
+    }),
+  };
+};
+
+type Supported7702AccountType = "ModularAccountV2";
+
+const IMPLEMENTATION_ADDRESS_TO_ACCOUNT_TYPE: Record<
+  Address,
+  Supported7702AccountType
+> = {
+  "0x69007702764179f14F51cdce752f4f775d74E139": "ModularAccountV2",
+};
+
+export const getAccountTypeForImplementationAddress7702 = (
+  address: Address,
+): Supported7702AccountType | undefined => {
+  return IMPLEMENTATION_ADDRESS_TO_ACCOUNT_TYPE[address];
+};
+
+const SUPPORTED_IMPLEMENTATION_ADDRESSES = Object.keys(
+  IMPLEMENTATION_ADDRESS_TO_ACCOUNT_TYPE,
+);
+
+export const isSupportedImplementationAddress7702 = (
+  address: string,
+): boolean => {
+  return SUPPORTED_IMPLEMENTATION_ADDRESSES.includes(address);
+};

package/src/isomorphic/utils/createAccount.ts

@@ -9,13 +9,17 @@ 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 { InternalError } from "ox/RpcResponse";
 
 type CreateAccountParams = {
   chain: Chain;
   transport: Transport;
   signer: SmartAccountSigner;
   accountAddress: Address;
-  counterfactualInfo: StaticDecode<typeof TypeSerializedInitcode>;
+  counterfactualInfo?: StaticDecode<typeof TypeSerializedInitcode>; // undefined for 7702 accounts
+  delegation?: Address;
   capabilities?: StaticDecode<typeof Capabilities>;
 };
 
@@ -28,12 +32,38 @@ export async function createAccount(
   params: CreateAccountParams,
 ): Promise<SmartContractAccount> {
   const { counterfactualInfo: ci, ...accountParams } = params;
-  // TODO: Implement support for other account types.
-  if (ci.factoryType !== "MAv2.0.0-sma-b") {
-    throw new Error("Only MAv2 SMA-B accounts are currently supported");
+
+  const mode = params.delegation ? "7702" : "default";
+
+  if (mode === "default") {
+    if (!ci) {
+      throw new InternalError({
+        message: "Counterfactual info not found",
+      });
+    }
+    if (ci.factoryType !== "MAv2.0.0-sma-b") {
+      throw new InternalError({
+        message: `Factory type ${ci.factoryType} is not currently supported.`,
+      });
+    }
+  } else if (mode === "7702") {
+    const accountType = getAccountTypeForImplementationAddress7702(
+      params.delegation!,
+    );
+    if (accountType !== "ModularAccountV2") {
+      throw new InternalError({
+        message: "7702 mode currently only supports ModularAccountV2",
+      });
+    }
+  } else {
+    assertNever(mode, "Unexpected mode in createAccount");
   }
 
-  const parsedContext = parsePermissionsContext(params.capabilities, ci);
+  const parsedContext = parsePermissionsContext(
+    params.capabilities,
+    ci,
+    params.delegation,
+  );
 
   const signerEntity =
     parsedContext?.contextVersion === "NON_DEFERRED_ACTION"
@@ -43,11 +73,13 @@ export async function createAccount(
         }
       : undefined;
 
+  // TODO: clean this up to support different account types.
   return createModularAccountV2({
     ...accountParams,
     signerEntity,
     deferredAction: parsedContext?.deferredAction,
-    initCode: concatHex([ci.factoryAddress, ci.factoryData]),
+    initCode: ci ? concatHex([ci.factoryAddress, ci.factoryData]) : undefined,
+    mode,
   });
 }
 

package/src/isomorphic/utils/createDummySigner.ts

@@ -1,6 +1,7 @@
 import { type SmartAccountSigner } from "@aa-sdk/core";
 import type { TypedData } from "abitype";
 import {
+  BaseError,
   type Address,
   type Hex,
   type SignableMessage,
@@ -15,12 +16,12 @@ export const createDummySigner = (address: Address): SmartAccountSigner => ({
   },
   // Not supported on the server
   signMessage: function (_message: SignableMessage): Promise<Hex> {
-    throw new Error("Function not implemented.");
+    throw new BaseError("signMessage not implemented by dummy signer.");
   },
   signTypedData: function <
     const TTypedData extends TypedData | Record<string, unknown>,
     TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData,
   >(_params: TypedDataDefinition<TTypedData, TPrimaryType>): Promise<Hex> {
-    throw new Error("Function not implemented.");
+    throw new BaseError("signTypedData not implemented by dummy signer.");
   },
 });