@account-kit/wallet-client 0.1.0-alpha.7 → 0.1.0-alpha.9

package/src/isomorphic/actions/prepareCalls.ts

@@ -9,6 +9,7 @@ import {
   ChainNotFoundError,
   custom,
   fromHex,
+  hashMessage,
   toHex,
   type Chain,
   type Transport,
@@ -17,7 +18,7 @@ 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 { createAuthorizationRequest, parseDelegation } from "../utils/7702.js";
+import { createAuthorizationRequest, isDelegated } from "../utils/7702.js";
 import { InvalidRequestError } from "ox/RpcResponse";
 import { assertNever } from "../../utils.js";
 import { assertValid7702AccountAddress } from "../utils/7702.js";
@@ -50,20 +51,23 @@ export async function prepareCalls(
   assertValid7702AccountAddress(params.from, params.capabilities?.eip7702Auth);
 
   // in local mode, we probably want some kind of caching for this
-  const { counterfactualInfo, delegation } = params.capabilities?.eip7702Auth
-    ? {
-        counterfactualInfo: undefined,
-        delegation: parseDelegation(params.capabilities.eip7702Auth),
-      }
-    : await client.request({
-        method: "wallet_requestAccount",
-        params: [
-          {
+  const { counterfactualInfo, delegation } = await client.request({
+    method: "wallet_requestAccount",
+    params: [
+      params.capabilities?.eip7702Auth
+        ? {
+            signerAddress: params.from,
+            creationHint: {
+              accountType: "7702",
+            },
+            includeCounterfactualInfo: true,
+          }
+        : {
             accountAddress: params.from,
             includeCounterfactualInfo: true,
           },
-        ],
-      });
+    ],
+  });
 
   if (!counterfactualInfo && !delegation) {
     throw new InvalidRequestError({
@@ -82,13 +86,26 @@ export async function prepareCalls(
     delegation,
   });
 
-  // If using 7702, we need an Authorization (unless it's already authorized).
-  const authorizationRequest = delegation
-    ? await createAuthorizationRequest(client, {
-        address: account.address,
-        delegation,
-      })
-    : undefined;
+  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
@@ -104,7 +121,12 @@ 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,
+    },
   });
 
   // The eip7702Auth field should never be included in the UO sig
@@ -117,6 +139,8 @@ export async function prepareCalls(
 
   const ep = account.getEntryPoint();
 
+  const uoHash = ep.getUserOperationHash(hexlifiedUo);
+
   const uoRequest = {
     type:
       ep.version === "0.7.0"
@@ -129,8 +153,11 @@ export async function prepareCalls(
     signatureRequest: {
       type: "personal_sign" as const,
       data: {
-        raw: ep.getUserOperationHash(hexlifiedUo),
+        raw: uoHash,
       },
+      rawPayload: hashMessage({
+        raw: uoHash,
+      }),
     },
   };
 

package/src/isomorphic/actions/sendPreparedCalls.ts

@@ -85,6 +85,12 @@ export async function sendPreparedCalls(
         })
       : [params];
 
+  if (!userOps.length) {
+    throw new InvalidRequestError({
+      message: "Calls must include at least one user operation",
+    });
+  }
+
   const authorizations =
     params.type === "array"
       ? params.data.filter((it) => it.type === "authorization")
@@ -120,19 +126,73 @@ export async function sendPreparedCalls(
         ? parseSignature(decodeSignature(authorization.signature).data)
         : undefined;
       const uoSigHex = decodeSignature(userOp.signature).data;
+
+      const { counterfactualInfo, delegation } = await client.request({
+        method: "wallet_requestAccount",
+        params: [
+          {
+            accountAddress: userOp.data.sender,
+            includeCounterfactualInfo: true,
+          },
+        ],
+      });
+
+      if (!counterfactualInfo && !delegation) {
+        throw new InvalidRequestError({
+          message:
+            "No counterfactual info or delegated implementation address found.",
+        });
+      }
+
+      const factoryType = counterfactualInfo?.factoryType;
+
+      // build signature based on account type
+      const signature = (() => {
+        switch (factoryType) {
+          // light accounts
+          case "LightAccountV1.0.1":
+          case "LightAccountV1.0.2":
+          case "LightAccountV1.1.0":
+          case "MAv1.0.0-MultiOwner":
+            // For LAv1 and MAv1-MultiOwner, we always just pass the signature.
+            return uoSigHex;
+          case "LightAccountV2.0.0":
+            // for LAv2, we need to prepend the "SignatureType.EOA" byte.
+            // TODO: Once we support nested smart accounts, switch this byte depending on the signature type.
+            return concat(["0x00", uoSigHex]);
+          case undefined: // undefined defaults to sma-b
+          case "MAv2.0.0-sma-b":
+            // For sma-b, we need to handle deferred actions if needed and prepend the "Reserved
+            // Signature Segment" and "SignatureType.EOA" bytes
+            return deferredAction != null
+              ? concatHex([
+                  `0x${deferredAction.slice(68)}`, // Cuts off stuff prepended to the digest (nonce, etc.).
+                  "0xFF",
+                  "0x00",
+                  uoSigHex,
+                ])
+              : concat(["0xFF", "0x00", uoSigHex]);
+          case "LightAccountV2.0.0-MultiOwner":
+            // for LAv2-MultiOwner, we need to prepend the "SignatureType.EOA" byte
+            // TODO: Once we support nested smart accounts, switch this byte depending on the signature type, and add the smart account signer's address.
+            return concat(["0x00", uoSigHex]);
+          case "MAv2.0.0-ma-ssv":
+          case "MAv2.0.0-ma-webauthn":
+          case "MAv1.0.0-MultiSig":
+          case "unknown":
+            throw new InvalidRequestError({
+              message: `Unsupported factory type: ${factoryType}`,
+            });
+          default:
+            return assertNever(factoryType, "Unsupported factory type");
+        }
+      })();
+
       return client
         .sendRawUserOperation(
           {
             ...userOp.data,
-            signature:
-              deferredAction != null
-                ? concatHex([
-                    `0x${deferredAction.slice(68)}`, // Cuts off stuff prepended to the digest (nonce, etc. that we had previously).
-                    "0xff",
-                    "0x00",
-                    uoSigHex,
-                  ])
-                : concat(["0xFF", "0x00", uoSigHex]),
+            signature,
             eip7702Auth:
               idx === 0 && authorization && authSig
                 ? {

package/src/isomorphic/utils/7702.ts

@@ -6,14 +6,17 @@ 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 (
+/** Checks if an address is actively delegated on-chain. */
+export const isDelegated = async (
   client: SmartAccountClient<
     Transport,
     Chain,
@@ -22,12 +25,22 @@ export const createAuthorizationRequest = async (
     WalletServerViemRpcSchema
   >,
   params: { address: Address; delegation: Address },
-): Promise<Static<typeof PreparedCall_Authorization> | undefined> => {
+): Promise<boolean> => {
   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 code.toLowerCase() === expectedCode.toLowerCase();
+};
+
+export const createAuthorizationRequest = async (
+  client: SmartAccountClient<
+    Transport,
+    Chain,
+    SmartContractAccount | undefined,
+    Record<string, unknown>,
+    WalletServerViemRpcSchema
+  >,
+  params: { address: Address; delegation: Address },
+): Promise<Static<typeof PreparedCall_Authorization>> => {
   const data = {
     address: params.delegation,
     nonce: numberToHex(
@@ -42,6 +55,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 +121,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,17 +1,20 @@
 import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
 import {
+  createLightAccount,
   createModularAccountV2,
+  createMultiOwnerLightAccount,
+  createMultiOwnerModularAccount,
   type ModularAccountV2,
 } from "@account-kit/smart-contracts";
 import type { StaticDecode } from "@sinclair/typebox";
 import type { Address, Chain, Transport } from "viem";
-import { concatHex, hexToNumber } from "viem";
+import { concatHex, hexToBigInt, hexToNumber, zeroAddress } from "viem";
 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 +36,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 +52,91 @@ 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 "MAv1.0.0-MultiOwner":
+      return createMultiOwnerModularAccount({
+        ...commonParams,
+      });
+    case "LightAccountV2.0.0-MultiOwner":
+      return createMultiOwnerLightAccount({
+        ...commonParams,
+        version: "v2.0.0",
+      });
+    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(
@@ -88,3 +144,27 @@ export function isModularAccountV2(
 ): account is ModularAccountV2 {
   return account.source === "ModularAccountV2";
 }
+
+// Performs basic checks on the initialOwners array and returns a new array with the signer address added if not present.
+// Pulled from MAv1 support in Account Kit.
+export function prepareInitialOwners(
+  initialOwners: Address[],
+  signerAddress: Address,
+): Address[] {
+  const preparedOwners = Array.from(
+    new Set([...initialOwners, signerAddress]),
+  ).sort((a, b) => {
+    const bigintA = hexToBigInt(a);
+    const bigintB = hexToBigInt(b);
+
+    return bigintA < bigintB ? -1 : bigintA > bigintB ? 1 : 0;
+  });
+
+  if (preparedOwners.some((x) => x === zeroAddress)) {
+    throw new InvalidRequestError({
+      message: "Initial owners cannot contain the zero address",
+    });
+  }
+
+  return preparedOwners;
+}

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/rpc/request.ts

@@ -218,6 +218,7 @@ export const wallet_createSession = Type.Object(
     }),
     ReturnType: Type.Object({
       sessionId: TypeHex(),
+      chainId: TypeHex(),
       signatureRequest: TypeTypedDataSignatureRequest,
     }),
   },

package/src/schemas.ts

@@ -16,6 +16,7 @@ import {
   parseSignature,
   numberToHex,
 } from "viem";
+import type { Expect } from "./utils.ts";
 
 const UUID_V4_REGEX =
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -24,6 +25,22 @@ 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-v2-multi-owner",
+  "la-v1.0.1",
+  "la-v1.0.2",
+  "la-v1.1.0",
+  "ma-v1-multi-owner",
+] 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,
@@ -275,7 +292,73 @@ export const TypeCreationOptions = Type.Optional(
         salt: Type.Optional(TypeHex()),
       },
       {
-        description: "SMA-B account type",
+        description: "Modular Account V2 SMA-B account type",
+      },
+    ),
+    Type.Object(
+      {
+        accountType: Type.Literal("la-v2"),
+        salt: Type.Optional(TypeHex()),
+      },
+      {
+        description: "Light Account V2 account type",
+      },
+    ),
+    Type.Object(
+      {
+        accountType: Type.Literal("la-v2-multi-owner"),
+        salt: Type.Optional(TypeHex()),
+        initialOwners: Type.Optional(
+          Type.Array(TypeAddress, {
+            description:
+              "The initial owners of the account. The signer address will be implicitly added if not specified in this list.",
+          }),
+        ),
+      },
+      {
+        description: "Light Account V2 Multi-Owner account type",
+      },
+    ),
+    Type.Object(
+      {
+        accountType: Type.Literal("la-v1.0.1"),
+        salt: Type.Optional(TypeHex()),
+      },
+      {
+        description: "Light Account V1.0.1 account type",
+      },
+    ),
+    Type.Object(
+      {
+        accountType: Type.Literal("la-v1.0.2"),
+        salt: Type.Optional(TypeHex()),
+      },
+      {
+        description: "Light Account V1.0.2 account type",
+      },
+    ),
+    Type.Object(
+      {
+        accountType: Type.Literal("la-v1.1.0"),
+        salt: Type.Optional(TypeHex()),
+      },
+      {
+        description: "Light Account V1.1.0 account type",
+      },
+    ),
+    Type.Object(
+      {
+        accountType: Type.Literal("ma-v1-multi-owner"),
+        salt: Type.Optional(TypeHex()),
+        initialOwners: Type.Optional(
+          Type.Array(TypeAddress, {
+            description:
+              "The initial owners of the account. The signer address will be implicitly added if not specified in this list.",
+          }),
+        ),
+      },
+      {
+        description: "Modular Account V1 Multi-Owner account type",
       },
     ),
     Type.Object(
@@ -295,10 +378,15 @@ export const TypeCreationOptions = Type.Optional(
 );
 export type TypeCreationOptions = Static<typeof TypeCreationOptions>;
 
-export type TypeAccountType = Exclude<
+type BaseAccountTypeExhaustive = BaseAccountType extends Exclude<
   Static<typeof TypeCreationOptions>,
   undefined
->["accountType"];
+>["accountType"]
+  ? true
+  : "BaseAccountType values not fully covered in TypeCreationOptions";
+
+// Compile-time assertion that TypeCreationOptions covers all BaseAccountType values.
+type _AssertBaseAccountTypeExhaustive = Expect<BaseAccountTypeExhaustive>;
 
 export const TypeSignatureType = Type.Union([
   Type.Literal("secp256k1", { description: "Secp256k1" }),
@@ -371,6 +459,7 @@ export const TypePersonalSignSignatureRequest = Type.Object(
         { description: "Raw message" },
       ),
     ]),
+    rawPayload: TypeHex(),
   },
   { description: "Personal sign" },
 );
@@ -379,6 +468,7 @@ export const TypeTypedDataSignatureRequest = Type.Object(
   {
     type: Type.Literal("eth_signTypedData_v4"),
     data: TTypedDataDefinition,
+    rawPayload: TypeHex(),
   },
   {
     description: "Typed data",
@@ -387,6 +477,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;