@account-kit/wallet-client 0.1.0-alpha.6 → 0.1.0-alpha.8

package/src/isomorphic/utils/7702.ts

@@ -6,12 +6,14 @@ import {
   type Chain,
   type Transport,
   isAddress,
+  hexToNumber,
 } from "viem";
 import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
 import { PreparedCall_Authorization } from "../../schemas.js";
 import type { Eip7702AuthCapability } from "../../capabilities/eip7702Auth.ts";
 import type { Static } from "@sinclair/typebox";
 import { InvalidRequestError } from "ox/RpcResponse";
+import { hashAuthorization } from "viem/utils";
 
 export const createAuthorizationRequest = async (
   client: SmartAccountClient<
@@ -42,6 +44,11 @@ export const createAuthorizationRequest = async (
     chainId: numberToHex(client.chain.id),
     signatureRequest: {
       type: "eip7702Auth" as const,
+      rawPayload: hashAuthorization({
+        chainId: client.chain.id,
+        nonce: hexToNumber(data.nonce),
+        address: params.delegation,
+      }),
     },
   };
 };
@@ -103,14 +110,23 @@ 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}.`,
-    });
+  if (eip7702AuthCapability) {
+    if (
+      typeof eip7702AuthCapability === "object" &&
+      "account" in eip7702AuthCapability &&
+      eip7702AuthCapability?.account !== fromAddress
+    ) {
+      throw new InvalidRequestError({
+        message: `EIP-7702 delegation account ${eip7702AuthCapability.account} must match 'from' address ${fromAddress}.`,
+      });
+    }
+
+    const delegation = parseDelegation(eip7702AuthCapability);
+
+    if (!isSupportedDelegationAddress7702(delegation)) {
+      throw new InvalidRequestError({
+        message: `Unsupported 7702 delegation address: ${delegation}`,
+      });
+    }
   }
 };

package/src/isomorphic/utils/createAccount.ts

@@ -1,5 +1,6 @@
 import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
 import {
+  createLightAccount,
   createModularAccountV2,
   type ModularAccountV2,
 } from "@account-kit/smart-contracts";
@@ -10,8 +11,8 @@ import type { TypeSerializedInitcode } from "../../schemas.js";
 import { parsePermissionsContext } from "./parsePermissionsContext.js";
 import { assertNever } from "../../utils.js";
 import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
-import { InternalError } from "ox/RpcResponse";
 import { PermissionsCapability } from "../../capabilities/permissions/index.js";
+import { InternalError, InvalidRequestError } from "ox/RpcResponse";
 
 type CreateAccountParams = {
   chain: Chain;
@@ -33,32 +34,8 @@ export async function createAccount(
 ): Promise<SmartContractAccount> {
   const { counterfactualInfo: ci, ...accountParams } = params;
 
-  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 = getAccountTypeForDelegationAddress7702(
-      params.delegation!,
-    );
-    if (accountType !== "ModularAccountV2") {
-      throw new InternalError({
-        message: "7702 mode currently only supports ModularAccountV2",
-      });
-    }
-  } else {
-    assertNever(mode, "Unexpected mode in createAccount");
-  }
-
+  // This throws if we pass a permission context and the account is not MA-v2
+  // TODO: test that this edge case is handled correctly
   const parsedContext = parsePermissionsContext(
     params.permissions,
     ci,
@@ -73,14 +50,84 @@ export async function createAccount(
         }
       : undefined;
 
-  // TODO: clean this up to support different account types.
-  return createModularAccountV2({
+  const mode = params.delegation ? "7702" : "default";
+
+  if (mode === "7702") {
+    const accountType = getAccountTypeForDelegationAddress7702(
+      params.delegation!,
+    );
+    if (accountType !== "ModularAccountV2") {
+      throw new Error("7702 mode currently only supports ModularAccountV2");
+    }
+    return createModularAccountV2({
+      ...accountParams,
+      signerEntity,
+      deferredAction: parsedContext?.deferredAction,
+      mode,
+    });
+  }
+
+  if (mode !== "default") {
+    return assertNever(mode, "Unexpected mode in createAccount");
+  }
+
+  // At this point, we are guaranteed to be in default mode, where ci
+  // (counterfactualInfo) must be defined
+
+  if (!ci) {
+    throw new InternalError({
+      message: "Counterfactual info not found",
+    });
+  }
+
+  const factoryType = ci.factoryType;
+  const commonParams = {
     ...accountParams,
-    signerEntity,
-    deferredAction: parsedContext?.deferredAction,
-    initCode: ci ? concatHex([ci.factoryAddress, ci.factoryData]) : undefined,
-    mode,
-  });
+    initCode: concatHex([ci.factoryAddress, ci.factoryData]),
+  };
+
+  // Return the account created based on the factory type
+  switch (factoryType) {
+    case "MAv2.0.0-sma-b":
+      return createModularAccountV2({
+        ...commonParams,
+        signerEntity,
+        deferredAction: parsedContext?.deferredAction,
+        mode,
+      });
+    case "LightAccountV2.0.0":
+      return createLightAccount({
+        ...commonParams,
+        version: "v2.0.0",
+      });
+    case "LightAccountV1.0.1":
+      return createLightAccount({
+        ...commonParams,
+        version: "v1.0.1",
+      });
+    case "LightAccountV1.0.2":
+      return createLightAccount({
+        ...commonParams,
+        version: "v1.0.2",
+      });
+    case "LightAccountV1.1.0":
+      return createLightAccount({
+        ...commonParams,
+        version: "v1.1.0",
+      });
+    case "LightAccountV2.0.0-MultiOwner":
+    case "MAv1.0.0-MultiOwner":
+    case "MAv1.0.0-MultiSig":
+    case "MAv2.0.0-ma-ssv":
+    case "MAv2.0.0-ma-webauthn":
+    case "unknown":
+    case undefined:
+      throw new InvalidRequestError({
+        message: `Account type currently unsupported: ${factoryType}`,
+      });
+    default:
+      return assertNever(factoryType, "Unsupported factory type");
+  }
 }
 
 export function isModularAccountV2(

package/src/isomorphic/utils/supportsFeature.ts

@@ -0,0 +1,34 @@
+import type { StaticDecode } from "@sinclair/typebox";
+import type { TypeSerializedInitcode } from "../../schemas.ts";
+
+export type Feature = "permissions";
+
+type FactoryType = StaticDecode<typeof TypeSerializedInitcode>["factoryType"];
+
+const supportedFeatures: Record<FactoryType, Feature[]> = {
+  "LightAccountV1.0.1": [],
+  "LightAccountV1.0.2": [],
+  "LightAccountV1.1.0": [],
+  "LightAccountV2.0.0": [],
+  "LightAccountV2.0.0-MultiOwner": [],
+  "MAv1.0.0-MultiOwner": [],
+  "MAv1.0.0-MultiSig": [],
+  "MAv2.0.0-sma-b": ["permissions"],
+  "MAv2.0.0-ma-ssv": ["permissions"],
+  "MAv2.0.0-ma-webauthn": [],
+  unknown: [],
+};
+
+export function supportsFeature(
+  counterfactualInfo: StaticDecode<typeof TypeSerializedInitcode>,
+  feature: Feature,
+): boolean {
+  const factorySupportedFeatures =
+    supportedFeatures[counterfactualInfo.factoryType];
+  if (factorySupportedFeatures === undefined) {
+    throw new Error(
+      "Unsupported FactoryType: " + counterfactualInfo.factoryType,
+    );
+  }
+  return factorySupportedFeatures.includes(feature);
+}

package/src/schemas.ts

@@ -24,6 +24,20 @@ FormatRegistry.Set("uuid", (value) => UUID_V4_REGEX.test(value));
 const BASE_64_URL_REGEX = /^[A-Za-z0-9_-]+$/; // Matches base64url encoded strings (without padding)
 FormatRegistry.Set("base64url", (value) => BASE_64_URL_REGEX.test(value));
 
+export const baseAccountTypes = [
+  "sma-b",
+  "la-v2",
+  "la-v1.0.1",
+  "la-v1.0.2",
+  "la-v1.1.0",
+] as const;
+
+export type BaseAccountType = (typeof baseAccountTypes)[number];
+
+export const accountTypes = [...baseAccountTypes, "7702"] as const;
+
+export type AccountType = (typeof accountTypes)[number];
+
 export const TypeHex = (options?: SchemaOptions) =>
   Type.TemplateLiteral("0x${string}", {
     ...options,
@@ -271,7 +285,9 @@ export const TypeCreationOptions = Type.Optional(
     Type.Object(
       {
         // Optional b/c `sma-b` is the default if no accountType is specified.
-        accountType: Type.Optional(Type.Literal("sma-b")),
+        accountType: Type.Optional(
+          Type.Union(baseAccountTypes.map((lit) => Type.Literal(lit))),
+        ),
         salt: Type.Optional(TypeHex()),
       },
       {
@@ -371,6 +387,7 @@ export const TypePersonalSignSignatureRequest = Type.Object(
         { description: "Raw message" },
       ),
     ]),
+    rawPayload: TypeHex(),
   },
   { description: "Personal sign" },
 );
@@ -379,6 +396,7 @@ export const TypeTypedDataSignatureRequest = Type.Object(
   {
     type: Type.Literal("eth_signTypedData_v4"),
     data: TTypedDataDefinition,
+    rawPayload: TypeHex(),
   },
   {
     description: "Typed data",
@@ -387,6 +405,7 @@ export const TypeTypedDataSignatureRequest = Type.Object(
 
 export const TypeAuthorizationSignatureRequest = Type.Object({
   type: Type.Literal("eip7702Auth"),
+  rawPayload: TypeHex(),
 });
 
 export const TypeSignatureRequest = Type.Union([

package/src/types.ts

@@ -60,3 +60,7 @@ export type InnerWalletApiClient = InnerWalletApiClientBase<
 export type WithoutChainId<T> = T extends { chainId: Hex }
   ? Omit<T, "chainId">
   : T;
+
+export type WithoutRawPayload<T> = T extends { rawPayload: Hex }
+  ? Omit<T, "rawPayload">
+  : T;