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

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")
@@ -147,10 +153,12 @@ export async function sendPreparedCalls(
           case "LightAccountV1.0.1":
           case "LightAccountV1.0.2":
           case "LightAccountV1.1.0":
-            // For LAv1, we always just pass the signature.
+          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
+            // 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":
@@ -164,10 +172,12 @@ export async function sendPreparedCalls(
                   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 "LightAccountV2.0.0-MultiOwner":
-          case "MAv1.0.0-MultiOwner":
           case "MAv1.0.0-MultiSig":
           case "unknown":
             throw new InvalidRequestError({

package/src/isomorphic/utils/7702.ts

@@ -15,7 +15,8 @@ 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,
@@ -24,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(

package/src/isomorphic/utils/createAccount.ts

@@ -2,11 +2,13 @@ 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";
@@ -115,8 +117,15 @@ export async function createAccount(
         ...commonParams,
         version: "v1.1.0",
       });
-    case "LightAccountV2.0.0-MultiOwner":
     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":
@@ -135,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/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;
@@ -27,9 +28,11 @@ 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];
@@ -285,13 +288,77 @@ export const TypeCreationOptions = Type.Optional(
     Type.Object(
       {
         // Optional b/c `sma-b` is the default if no accountType is specified.
-        accountType: Type.Optional(
-          Type.Union(baseAccountTypes.map((lit) => Type.Literal(lit))),
+        accountType: Type.Optional(Type.Literal("sma-b")),
+        salt: Type.Optional(TypeHex()),
+      },
+      {
+        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: "SMA-B account type",
+        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(
@@ -311,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" }),

package/src/utils.ts

@@ -1,5 +1,7 @@
 import { isHex, toHex, type Hex } from "viem";
 
+export type Expect<T extends true> = T;
+
 export const assertNever = (_val: never, msg: string): never => {
   throw new Error(msg);
 };