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

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.");
   },
 });

package/src/isomorphic/utils/parsePermissionsContext.ts

@@ -3,25 +3,41 @@ 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";
 
 export function parsePermissionsContext(
   capabilities: PrepareCallsParams["capabilities"],
-  parsedCi: StaticDecode<typeof TypeSerializedInitcode>,
+  parsedCi: StaticDecode<typeof TypeSerializedInitcode> | undefined,
+  delegation7702?: Address,
 ) {
-  if (!capabilities?.permissions?.context) {
+  if (!capabilities?.permissions) {
     return undefined;
   }
 
-  if (
-    capabilities?.permissions?.context &&
-    parsedCi.factoryType !== "MAv2.0.0-sma-b"
-  ) {
+  if ("sessionId" in capabilities.permissions) {
+    throw new InvalidRequestError({
+      message: "Remote permissions are not supported in isomorphic client",
+    });
+  }
+
+  if (!("context" in capabilities.permissions)) {
+    return undefined;
+  }
+
+  const isMAV2 =
+    (parsedCi && parsedCi.factoryType === "MAv2.0.0-sma-b") ||
+    (delegation7702 &&
+      getAccountTypeForImplementationAddress7702(delegation7702) ===
+        "ModularAccountV2");
+
+  if (!isMAV2) {
     throw new InvalidRequestError({
       message: "Permissions are currently only supported by MAv2 accounts",
     });
   }
 
-  const context = decodePermissionsContext(capabilities.permissions.context);
+  const context = decodePermissionsContext(capabilities.permissions);
 
   if (context?.contextVersion === "REMOTE_MODE_DEFERRED_ACTION") {
     throw new InvalidRequestError({

package/src/local/client.ts

@@ -6,7 +6,8 @@ import {
   prefixSignatureKeyType,
 } from "../capabilities/permissions/mav2.js";
 import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
-import type { PrepareCallsParams } from "../isomorphic/actions/prepareCalls";
+import { internalStateDecorator } from "../internal/decorator.js";
+import type { PrepareCallsParams } from "../isomorphic/actions/prepareCalls.ts";
 import {
   createIsomorphicClient,
   type IsomorphicClient,
@@ -15,7 +16,7 @@ import type {
   CreateInnerClientParams,
   InnerClientActions,
   InnerWalletApiClient,
-} from "../types";
+} from "../types.ts";
 import { assertNever } from "../utils.js";
 
 const localMethods = [
@@ -51,46 +52,51 @@ export function createLocalClient(
     overrides: [
       {
         methods: localMethods,
-        transport: custom({
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          async request(args: { method: LocalMethod; params: any }) {
-            switch (args.method) {
-              case "wallet_prepareCalls": {
-                const params = args.params[0] as PrepareCallsParams;
-                const capabilityPolicyId =
-                  params.capabilities?.paymasterService?.policyId;
+        transport: custom(
+          {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            async request(args: { method: LocalMethod; params: any }) {
+              switch (args.method) {
+                case "wallet_prepareCalls": {
+                  const params = args.params[0] as PrepareCallsParams;
+                  const capabilityPolicyId =
+                    params.capabilities?.paymasterService?.policyId;
 
-                if (
-                  capabilityPolicyId != null &&
-                  policyId !== capabilityPolicyId &&
-                  !clientMap[capabilityPolicyId]
-                ) {
-                  clientMap[capabilityPolicyId] = createIsomorphicClient({
-                    transport,
-                    chain,
-                    policyId: capabilityPolicyId,
-                  });
-                }
+                  if (
+                    capabilityPolicyId != null &&
+                    policyId !== capabilityPolicyId &&
+                    !clientMap[capabilityPolicyId]
+                  ) {
+                    clientMap[capabilityPolicyId] = createIsomorphicClient({
+                      transport,
+                      chain,
+                      policyId: capabilityPolicyId,
+                    });
+                  }
 
-                const client =
-                  clientMap[capabilityPolicyId ?? policyId ?? "default"];
-                return client.prepareCalls(params);
-              }
-              case "wallet_sendPreparedCalls":
-                return isomorphicClient.sendPreparedCalls(args.params[0]);
-              case "wallet_getCallsStatus":
-                return isomorphicClient.getCallsStatus(args.params[0]);
-              case "wallet_createSession": {
-                return isomorphicClient.createSession(args.params[0]);
+                  const client =
+                    clientMap[capabilityPolicyId ?? policyId ?? "default"];
+                  return client.prepareCalls(params);
+                }
+                case "wallet_sendPreparedCalls":
+                  return isomorphicClient.sendPreparedCalls(args.params[0]);
+                case "wallet_getCallsStatus":
+                  return isomorphicClient.getCallsStatus(args.params[0]);
+                case "wallet_createSession": {
+                  return isomorphicClient.createSession(args.params[0]);
+                }
+                default:
+                  return assertNever(
+                    args.method,
+                    `Unexpected method: ${args.method}`,
+                  );
               }
-              default:
-                return assertNever(
-                  args.method,
-                  `Unexpected method: ${args.method}`,
-                );
-            }
+            },
           },
-        }),
+          {
+            retryCount: 0,
+          },
+        ),
       },
     ],
     fallback: transport,
@@ -100,10 +106,14 @@ export function createLocalClient(
     transport: innerTransport,
     chain,
     account,
-  }).extend(() => ({
-    policyId,
-    ...innerClientActions(isomorphicClient),
-  }));
+  })
+    .extend(() => ({
+      policyId,
+      ...innerClientActions(isomorphicClient),
+    }))
+    .extend(() => ({
+      internal: internalStateDecorator(),
+    }));
 }
 
 const innerClientActions = (
@@ -113,12 +123,10 @@ const innerClientActions = (
     grantPermissions: async (signer, params) => {
       const { signatureRequest, fullPreSignatureDeferredActionDigest } =
         await isomorphicClient.createSession(params);
-
-      const { signature } = await signSignatureRequest(
+      const { signedAuthorization, signature } = await signSignatureRequest(
         signer,
         signatureRequest,
       );
-
       return {
         context: encodePermissionsContext({
           contextVersion: "LOCAL_MODE_DEFERRED_ACTION",
@@ -127,6 +135,7 @@ const innerClientActions = (
             sig: prefixSignatureKeyType(signature, "secp256k1"),
           }),
         }),
+        signedAuthorization,
       };
     },
   };

package/src/remote/client.ts

@@ -1,14 +1,21 @@
 import { Provider } from "ox";
-import { createClient, custom, type Address, type JsonRpcAccount } from "viem";
+import {
+  BaseError,
+  createClient,
+  custom,
+  type Address,
+  type JsonRpcAccount,
+} from "viem";
 import { encodePermissionsContext } from "../capabilities/permissions/mav2.js";
 import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
+import { internalStateDecorator } from "../internal/decorator.js";
 import { WalletServerRpcSchema } from "../rpc/schema.js";
 import type {
   CreateInnerClientParams,
   InnerClientActions,
   InnerWalletApiClient,
   InnerWalletApiClientBase,
-} from "../types";
+} from "../types.ts";
 
 export function createRemoteClient<
   TAccount extends JsonRpcAccount<Address> | undefined =
@@ -34,10 +41,14 @@ export function createRemoteClient(
       ),
     chain,
     account,
-  }).extend((_client) => ({
-    policyId: params.policyId,
-    ...innerClientActions(_client),
-  }));
+  })
+    .extend((_client) => ({
+      policyId: params.policyId,
+      ...innerClientActions(_client),
+    }))
+    .extend(() => ({
+      internal: internalStateDecorator(),
+    }));
 
   return client;
 }
@@ -51,7 +62,10 @@ const innerClientActions = (
         method: "wallet_createSession",
         params: [params],
       });
-      const { signature } = await signSignatureRequest(
+      if (signatureRequest.type !== "eth_signTypedData_v4") {
+        throw new BaseError("Unexpected signature request type");
+      }
+      const { signedAuthorization, signature } = await signSignatureRequest(
         signer,
         signatureRequest,
       );
@@ -61,6 +75,7 @@ const innerClientActions = (
           sessionId,
           signature,
         }),
+        signedAuthorization,
       };
     },
   };