@alchemy/smart-accounts 0.0.0-alpha.9 → 5.0.0-beta.2

package/src/light-account/accounts/base.ts

@@ -1,5 +1,4 @@
 import {
-  concat,
   concatHex,
   encodeFunctionData,
   fromHex,
@@ -18,6 +17,7 @@ import {
 } from "viem";
 import {
   getUserOperationHash,
+  getUserOperationTypedData,
   toSmartAccount,
   type SmartAccountImplementation,
 } from "viem/account-abstraction";
@@ -28,7 +28,7 @@ import type {
   LightAccountVersion,
 } from "../registry.js";
 import { EIP1967_PROXY_IMPL_STORAGE_SLOT } from "../utils.js";
-import { AccountVersionRegistry } from "../registry.js";
+import { AccountVersionRegistry, isLightAccountVersion2 } from "../registry.js";
 import {
   encodeCallsLA as encodeCalls,
   decodeCallsLA as decodeCalls,
@@ -203,6 +203,8 @@ export async function toLightAccountBase<
           data: get1271Wrapper(messageHash, "1"),
         };
       case "v2.0.0":
+      case "v2.1.0":
+      case "v2.2.0":
         return {
           type: "eth_signTypedData_v4",
           data: get1271Wrapper(messageHash, "2"),
@@ -215,8 +217,10 @@ export async function toLightAccountBase<
   };
 
   const formatSignature = async (signature: Hex): Promise<Hex> => {
-    return version === "v2.0.0"
-      ? concat([SignaturePrefix.EOA, signature])
+    return isLightAccountVersion2(
+      version as LightAccountVersion<"LightAccount">,
+    )
+      ? concatHex([SignaturePrefix.EOA, signature])
       : signature;
   };
 
@@ -251,7 +255,9 @@ export async function toLightAccountBase<
         case "v1.1.0":
           return signature;
         case "v2.0.0":
-          return concat([SignaturePrefix.EOA, signature]);
+        case "v2.1.0":
+        case "v2.2.0":
+          return concatHex([SignaturePrefix.EOA, signature]);
         default:
           throw new BaseError(`Unknown version ${type} of ${String(version)}`);
       }
@@ -307,26 +313,59 @@ export async function toLightAccountBase<
 
     async signUserOperation(parameters) {
       const { chainId = client.chain.id, ...userOperation } = parameters;
-      const userOpHash = getUserOperationHash({
-        chainId,
-        entryPointAddress: entryPoint.address,
-        entryPointVersion: entryPoint.version,
-        userOperation: {
-          ...userOperation,
-          sender: accountAddress,
-        },
-      });
-
-      const signMessageAction = getAction(client, signMessage, "signMessage");
+      let signature: Hex;
 
-      const signature = await signMessageAction({
-        account: owner,
-        message: { raw: userOpHash },
-      });
+      switch (version) {
+        case "v1.0.1":
+        case "v1.0.2":
+        case "v1.1.0":
+        case "v2.0.0":
+          const userOpHash = getUserOperationHash({
+            chainId,
+            entryPointAddress: entryPoint.address,
+            entryPointVersion: entryPoint.version,
+            userOperation: {
+              ...userOperation,
+              sender: accountAddress,
+            },
+          });
+
+          const signMessageAction = getAction(
+            client,
+            signMessage,
+            "signMessage",
+          );
+
+          signature = await signMessageAction({
+            account: owner,
+            message: { raw: userOpHash },
+          });
+          break;
+        case "v2.1.0":
+        case "v2.2.0":
+          const signTypedDataAction = getAction(
+            client,
+            signTypedData,
+            "signTypedData",
+          );
+
+          signature = await signTypedDataAction({
+            account: owner,
+            ...getUserOperationTypedData({
+              chainId,
+              entryPointAddress: entryPoint.address,
+              userOperation: {
+                ...userOperation,
+                sender: accountAddress,
+              },
+            }),
+          });
+          break;
+        default:
+          throw new BaseError(`Unknown version ${type} of ${String(version)}`);
+      }
 
-      return version === "v2.0.0"
-        ? concatHex([SignaturePrefix.EOA, signature])
-        : signature;
+      return formatSignature(signature);
     },
 
     extend: {

package/src/light-account/accounts/calldataCodec.ts

@@ -6,6 +6,7 @@ import {
   type Hex,
 } from "viem";
 import { LightAccountAbi_v1 } from "../abis/LightAccountAbi_v1.js";
+import { BaseError } from "@alchemy/common";
 
 // Conveniently, all variants of LA up to v2.0.0 use the same function signatures for `execute` and `executeBatch`.
 
@@ -59,7 +60,7 @@ export function decodeCallsLA(data: Hex, accountAddress: Address): Call[] {
       const [targets, values, datas] = decoded.args;
 
       if (targets.length !== values.length || targets.length !== datas.length) {
-        throw new Error("Invalid arguments for executeBatch");
+        throw new BaseError("Invalid arguments for executeBatch");
       }
 
       return targets.map((to, index) => ({
@@ -73,7 +74,7 @@ export function decodeCallsLA(data: Hex, accountAddress: Address): Call[] {
     const [targets, datas] = decoded.args;
 
     if (targets.length !== datas.length) {
-      throw new Error("Invalid arguments for executeBatch");
+      throw new BaseError("Invalid arguments for executeBatch");
     }
 
     return targets.map((to, index) => ({

package/src/light-account/accounts/multi-owner-account.ts

@@ -13,7 +13,10 @@ import {
 import { readContract } from "viem/actions";
 import { MultiOwnerLightAccountAbi } from "../abis/MultiOwnerLightAccountAbi.js";
 import { MultiOwnerLightAccountFactoryAbi } from "../abis/MultiOwnerLightAccountFactoryAbi.js";
-import { predictMultiOwnerLightAccountAddress } from "../predictAddress.js";
+import {
+  getMultiOwnerLightAccountAddressFromFactoryData,
+  predictMultiOwnerLightAccountAddress,
+} from "../predictAddress.js";
 import { toLightAccountBase, type LightAccountBase } from "./base.js";
 import { BaseError, lowerAddress } from "@alchemy/common";
 import { getAction } from "viem/utils";
@@ -33,11 +36,12 @@ export type MultiOwnerLightAccount = LightAccountBase<
 export type ToMultiOwnerLightAccountParams = {
   client: Client<Transport, Chain, JsonRpcAccount | LocalAccount | undefined>;
   owners: [OneOf<JsonRpcAccount | LocalAccount>, ...{ address: Address }[]];
-  salt?: bigint;
   accountAddress?: Address;
   factory?: Address;
-  factoryData?: Hex;
-};
+} & (
+  | { salt?: bigint; factoryData?: never }
+  | { salt?: never; factoryData?: Hex }
+);
 
 /**
  * Creates a multi-owner light account.
@@ -68,11 +72,20 @@ export async function toMultiOwnerLightAccount({
 
   const accountAddress =
     accountAddress_ ??
-    predictMultiOwnerLightAccountAddress({
-      factoryAddress: factory,
-      salt,
-      ownerAddresses: sortedOwners,
-    });
+    (factoryData_
+      ? await getMultiOwnerLightAccountAddressFromFactoryData({
+          client,
+          factoryAddress: factory,
+          factoryData: factoryData_,
+          entryPoint:
+            AccountVersionRegistry["MultiOwnerLightAccount"]["v2.0.0"]
+              .entryPoint,
+        })
+      : predictMultiOwnerLightAccountAddress({
+          factoryAddress: factory,
+          salt,
+          ownerAddresses: sortedOwners,
+        }));
 
   const getFactoryArgs = async () => {
     const factoryData =

package/src/light-account/lightAccountStaticImpl.ts

@@ -4,6 +4,10 @@ import {
   entryPoint07Abi,
   entryPoint06Address,
   entryPoint07Address,
+  entryPoint08Abi,
+  entryPoint08Address,
+  entryPoint09Abi,
+  entryPoint09Address,
 } from "viem/account-abstraction";
 import { LightAccountAbi_v1 } from "./abis/LightAccountAbi_v1.js";
 import { LightAccountFactoryAbi_v1 } from "./abis/LightAccountFactoryAbi_v1.js";
@@ -96,15 +100,6 @@ export const lightAccountStaticImplV1_1_0: LightAccountV1StaticImpl = {
   },
 };
 
-// Shared type and fields for all light account v2 implementations
-const lightAccountV2Base = {
-  entryPoint: {
-    abi: entryPoint07Abi,
-    address: entryPoint07Address,
-    version: "0.7",
-  },
-} satisfies Partial<StaticSmartAccountImplementation<false, "0.7">>;
-
 export const lightAccountStaticImplV2_0_0: StaticSmartAccountImplementation<
   false,
   "0.7",
@@ -113,7 +108,11 @@ export const lightAccountStaticImplV2_0_0: StaticSmartAccountImplementation<
   typeof LightAccountAbi_v2,
   typeof LightAccountFactoryAbi_v2
 > = {
-  ...lightAccountV2Base,
+  entryPoint: {
+    abi: entryPoint07Abi,
+    address: entryPoint07Address,
+    version: "0.7",
+  },
   accountAbi: LightAccountAbi_v2,
   accountImplementation: lowerAddress(
     "0x8E8e658E22B12ada97B402fF0b044D6A325013C7",
@@ -149,7 +148,11 @@ export const multiOwnerLightAccountStaticImplV2_0_0: StaticSmartAccountImplement
   typeof MultiOwnerLightAccountAbi,
   typeof MultiOwnerLightAccountFactoryAbi
 > = {
-  ...lightAccountV2Base,
+  entryPoint: {
+    abi: entryPoint07Abi,
+    address: entryPoint07Address,
+    version: "0.7",
+  },
   accountAbi: MultiOwnerLightAccountAbi,
   accountImplementation: lowerAddress(
     "0xd2c27F9eE8E4355f71915ffD5568cB3433b6823D",
@@ -170,3 +173,73 @@ export const multiOwnerLightAccountStaticImplV2_0_0: StaticSmartAccountImplement
     });
   },
 };
+
+export const lightAccountStaticImplV2_1_0: StaticSmartAccountImplementation<
+  false,
+  "0.8",
+  LightAccountFactoryArgs,
+  typeof entryPoint08Abi,
+  typeof LightAccountAbi_v2,
+  typeof LightAccountFactoryAbi_v2
+> = {
+  entryPoint: {
+    abi: entryPoint08Abi,
+    address: entryPoint08Address,
+    version: "0.8",
+  },
+  accountAbi: LightAccountAbi_v2,
+  accountImplementation: lowerAddress(
+    "0x2c53D0bD33A60db8881c7b049Df6fd762A1f059C",
+  ),
+  factoryAbi: LightAccountFactoryAbi_v2,
+  factoryAddress: lowerAddress("0x000000000000B1c70Df4DC2CcF86372714e14154"),
+  getFactoryData: (factoryArgs) => {
+    return encodeFunctionData({
+      abi: LightAccountFactoryAbi_v2,
+      functionName: "createAccount",
+      args: [factoryArgs.owner, factoryArgs.salt],
+    });
+  },
+  predictAccountAddress: (factoryArgs) => {
+    return predictLightAccountAddress({
+      salt: factoryArgs.salt,
+      ownerAddress: factoryArgs.owner,
+      version: "v2.1.0",
+    });
+  },
+};
+
+export const lightAccountStaticImplV2_2_0: StaticSmartAccountImplementation<
+  false,
+  "0.9",
+  LightAccountFactoryArgs,
+  typeof entryPoint09Abi,
+  typeof LightAccountAbi_v2,
+  typeof LightAccountFactoryAbi_v2
+> = {
+  entryPoint: {
+    abi: entryPoint09Abi,
+    address: entryPoint09Address,
+    version: "0.9",
+  },
+  accountAbi: LightAccountAbi_v2,
+  accountImplementation: lowerAddress(
+    "0x05FF1bF6Ac15d4990Ea77Ae60394629bcB16640d",
+  ),
+  factoryAbi: LightAccountFactoryAbi_v2,
+  factoryAddress: lowerAddress("0x0000000000003805C662f84E42E446C96a446e82"),
+  getFactoryData: (factoryArgs) => {
+    return encodeFunctionData({
+      abi: LightAccountFactoryAbi_v2,
+      functionName: "createAccount",
+      args: [factoryArgs.owner, factoryArgs.salt],
+    });
+  },
+  predictAccountAddress: (factoryArgs) => {
+    return predictLightAccountAddress({
+      salt: factoryArgs.salt,
+      ownerAddress: factoryArgs.owner,
+      version: "v2.2.0",
+    });
+  },
+};

package/src/light-account/predictAddress.ts

@@ -1,18 +1,29 @@
 import {
   concatHex,
+  decodeFunctionData,
   encodeAbiParameters,
   encodeDeployData,
   encodeFunctionData,
   getContractAddress,
+  isAddressEqual,
   keccak256,
   toHex,
   type Address,
+  type Client,
   type Hex,
 } from "viem";
+import type { EntryPointVersion } from "viem/account-abstraction";
 import { LightAccountAbi_v1 } from "./abis/LightAccountAbi_v1.js";
+import { LightAccountFactoryAbi_v1 } from "./abis/LightAccountFactoryAbi_v1.js";
+import { LightAccountFactoryAbi_v2 } from "./abis/LightAccountFactoryAbi_v2.js";
+import { MultiOwnerLightAccountFactoryAbi } from "./abis/MultiOwnerLightAccountFactoryAbi.js";
 import { OZ_ERC1967Proxy_ConstructorAbi } from "./abis/OZ_ERC1967Proxy.js";
-import { AccountVersionRegistry } from "./registry.js";
+import {
+  AccountVersionRegistry,
+  type LightAccountVersion,
+} from "./registry.js";
 import { BaseError, lowerAddress } from "@alchemy/common";
+import { getSenderFromFactoryData } from "../utils.js";
 
 export type PredictLightAccountAddressParams = {
   version: keyof typeof AccountVersionRegistry.LightAccount;
@@ -73,7 +84,9 @@ export function predictLightAccountAddress({
       });
 
     case "v2.0.0":
-      // Logic ported from LA factory v2.0.0
+    case "v2.1.0":
+    case "v2.2.0":
+      // Logic ported from LA factory v2
       const combinedSalt = keccak256(
         encodeAbiParameters(
           [{ type: "address" }, { type: "uint256" }],
@@ -89,7 +102,6 @@ export function predictLightAccountAddress({
         salt: combinedSalt,
         bytecode: initCode,
       });
-
     default:
       assertNeverLightAccountVersion(version);
   }
@@ -172,3 +184,112 @@ function getLAv2ProxyBytecode(implementationAddress: Address): Hex {
 function assertNeverLightAccountVersion(version: never): never {
   throw new BaseError(`Unknown light account version: ${version}`);
 }
+
+export type GetLightAccountAddressFromFactoryDataParams = {
+  client: Client;
+  factoryAddress: Address;
+  factoryData: Hex;
+  entryPoint: {
+    version: EntryPointVersion;
+    address: Address;
+  };
+  version: LightAccountVersion<"LightAccount">;
+};
+
+/**
+ * Gets the light account address from factory data.
+ * If the factory is a known default, decodes the args and predicts without RPC.
+ * Otherwise falls back to calling the entry point's getSenderAddress.
+ *
+ * @param {GetLightAccountAddressFromFactoryDataParams} params - The parameters
+ * @returns {Promise<Address>} The account address
+ */
+export async function getLightAccountAddressFromFactoryData({
+  client,
+  factoryAddress,
+  factoryData,
+  entryPoint,
+  version,
+}: GetLightAccountAddressFromFactoryDataParams): Promise<Address> {
+  const defaultFactory =
+    AccountVersionRegistry["LightAccount"][version].factoryAddress;
+  if (isAddressEqual(factoryAddress, defaultFactory)) {
+    const factoryAbi =
+      version === "v2.0.0"
+        ? LightAccountFactoryAbi_v2
+        : LightAccountFactoryAbi_v1;
+    try {
+      const decoded = decodeFunctionData({
+        abi: factoryAbi,
+        data: factoryData,
+      });
+      if (decoded.functionName === "createAccount") {
+        const [decodedOwner, decodedSalt] = decoded.args;
+        return predictLightAccountAddress({
+          factoryAddress,
+          salt: decodedSalt,
+          ownerAddress: decodedOwner,
+          version,
+        });
+      }
+    } catch {
+      // Decode failed, fall through to RPC
+    }
+  }
+  return getSenderFromFactoryData(client, {
+    factory: factoryAddress,
+    factoryData,
+    entryPoint,
+  });
+}
+
+export type GetMultiOwnerLightAccountAddressFromFactoryDataParams = {
+  client: Client;
+  factoryAddress: Address;
+  factoryData: Hex;
+  entryPoint: {
+    version: EntryPointVersion;
+    address: Address;
+  };
+};
+
+/**
+ * Gets the multi-owner light account address from factory data.
+ * If the factory is a known default, decodes the args and predicts without RPC.
+ * Otherwise falls back to calling the entry point's getSenderAddress.
+ *
+ * @param {GetMultiOwnerLightAccountAddressFromFactoryDataParams} params - The parameters
+ * @returns {Promise<Address>} The account address
+ */
+export async function getMultiOwnerLightAccountAddressFromFactoryData({
+  client,
+  factoryAddress,
+  factoryData,
+  entryPoint,
+}: GetMultiOwnerLightAccountAddressFromFactoryDataParams): Promise<Address> {
+  const defaultFactory =
+    AccountVersionRegistry["MultiOwnerLightAccount"]["v2.0.0"].factoryAddress;
+  if (isAddressEqual(factoryAddress, defaultFactory)) {
+    try {
+      const decoded = decodeFunctionData({
+        abi: MultiOwnerLightAccountFactoryAbi,
+        data: factoryData,
+      });
+      if (decoded.functionName === "createAccount") {
+        const [decodedOwners, decodedSalt] = decoded.args;
+        return predictMultiOwnerLightAccountAddress({
+          factoryAddress,
+          salt: decodedSalt,
+          ownerAddresses: [...decodedOwners],
+        });
+      }
+    } catch {
+      // Decode failed, fall through to RPC
+    }
+  }
+  return getSenderFromFactoryData(client, {
+    factory: factoryAddress,
+    factoryData,
+    entryPoint,
+  });
+}

package/src/light-account/registry.ts

@@ -5,6 +5,8 @@ import {
   lightAccountStaticImplV1_0_2,
   lightAccountStaticImplV1_1_0,
   lightAccountStaticImplV2_0_0,
+  lightAccountStaticImplV2_1_0,
+  lightAccountStaticImplV2_2_0,
   multiOwnerLightAccountStaticImplV2_0_0,
 } from "./lightAccountStaticImpl.js";
 import type { StaticSmartAccountImplementation } from "../types.js";
@@ -20,6 +22,8 @@ export const AccountVersionRegistry = {
     "v1.0.2": lightAccountStaticImplV1_0_2,
     "v1.1.0": lightAccountStaticImplV1_1_0,
     "v2.0.0": lightAccountStaticImplV2_0_0,
+    "v2.1.0": lightAccountStaticImplV2_1_0,
+    "v2.2.0": lightAccountStaticImplV2_2_0,
   },
   MultiOwnerLightAccount: {
     "v2.0.0": multiOwnerLightAccountStaticImplV2_0_0,
@@ -34,6 +38,46 @@ export type LightAccountType = Extract<
 export type LightAccountVersion<TAccountType extends LightAccountType> =
   keyof (typeof AccountVersionRegistry)[TAccountType];
 
+/**
+ * Light Account v1 versions
+ */
+export const LightAccountV1Versions = [
+  "v1.0.1",
+  "v1.0.2",
+  "v1.1.0",
+] as const satisfies LightAccountVersion<"LightAccount">[];
+
+/**
+ * Light Account v2 versions
+ */
+export const LightAccountV2Versions = [
+  "v2.0.0",
+  "v2.1.0",
+  "v2.2.0",
+] as const satisfies LightAccountVersion<"LightAccount">[];
+
+/**
+ * Type guard to check if a version is a Light Account v1 version
+ *
+ * @param {LightAccountVersion<"LightAccount">} version - The version to check.
+ * @returns {boolean} True if the version is a v1 version.
+ */
+export const isLightAccountVersion1 = (
+  version: LightAccountVersion<"LightAccount">,
+): version is (typeof LightAccountV1Versions)[number] =>
+  (LightAccountV1Versions as readonly string[]).includes(version);
+
+/**
+ * Type guard to check if a version is a Light Account v2 version
+ *
+ * @param {LightAccountVersion<"LightAccount">} version - The version to check.
+ * @returns {boolean} True if the version is a v2 version.
+ */
+export const isLightAccountVersion2 = (
+  version: LightAccountVersion<"LightAccount">,
+): version is (typeof LightAccountV2Versions)[number] =>
+  (LightAccountV2Versions as readonly string[]).includes(version);
+
 export type GetLightAccountType<TAccount extends LightAccountBase> =
   TAccount["smartAccountType"] extends LightAccountType
     ? TAccount["smartAccountType"]

package/src/logger.ts

@@ -1,5 +1,5 @@
-import { createLogger } from "@alchemy/common";
-import type { DiagnosticsLogger } from "@alchemy/common";
+import { createLogger } from "@alchemy/common/internal";
+import type { DiagnosticsLogger } from "@alchemy/common/internal";
 import { VERSION } from "./version.js";
 
 export const LOGGER: DiagnosticsLogger = createLogger({

package/src/ma-v1/accounts/multi-owner-account.ts

@@ -1,26 +1,30 @@
 import {
+  encodeFunctionData,
   hexToBigInt,
   type Address,
   type Chain,
   type Client,
+  type Hash,
   type Hex,
   type JsonRpcAccount,
   type LocalAccount,
   type OneOf,
   type Transport,
-  encodeFunctionData,
-  type Hash,
   type TypedDataDefinition,
 } from "viem";
 import { toModularAccountV1Base, type ModularAccountV1Base } from "./base.js";
 import { lowerAddress, BaseError } from "@alchemy/common";
 import { DefaultMaV1Address, DefaultMaV1PluginAddress } from "../account.js";
 import { MultiOwnerModularAccountFactoryAbi } from "../abis/MultiOwnerModularAccountFactory.js";
-import { predictMultiOwnerModularAccountV1Address } from "../predictAddress.js";
+import {
+  getMultiOwnerModularAccountV1AddressFromFactoryData,
+  predictMultiOwnerModularAccountV1Address,
+} from "../predictAddress.js";
 import { MultiOwnerPluginExecutionFunctionAbi } from "../abis/MultiOwnerPluginExecutionFunction.js";
 import { readContract } from "viem/actions";
 import { getAction } from "viem/utils";
 import { MultiOwnerPluginAbi } from "../abis/MultiOwnerPlugin.js";
+import { entryPoint06Address } from "viem/account-abstraction";
 
 export type MultiOwnerModularAccountV1 = ModularAccountV1Base & {
   encodeUpdateOwners: (
@@ -33,11 +37,12 @@ export type MultiOwnerModularAccountV1 = ModularAccountV1Base & {
 export type ToMultiOwnerModularAccountV1Params = {
   client: Client<Transport, Chain, JsonRpcAccount | LocalAccount | undefined>;
   owners: [OneOf<JsonRpcAccount | LocalAccount>, ...{ address: Address }[]];
-  salt?: bigint;
   accountAddress?: Address;
   factory?: Address;
-  factoryData?: Hex;
-};
+} & (
+  | { salt?: bigint; factoryData?: never }
+  | { salt?: never; factoryData?: Hex }
+);
 
 /**
  * Creates a multi-owner MAv1 account.
@@ -67,11 +72,21 @@ export async function toMultiOwnerModularAccountV1({
 
   const accountAddress =
     accountAddress_ ??
-    predictMultiOwnerModularAccountV1Address({
-      factoryAddress: factory,
-      salt,
-      ownerAddresses: sortedOwners,
-    });
+    (factoryData_
+      ? await getMultiOwnerModularAccountV1AddressFromFactoryData({
+          client,
+          factoryAddress: factory,
+          factoryData: factoryData_,
+          entryPoint: {
+            version: "0.6",
+            address: entryPoint06Address,
+          },
+        })
+      : predictMultiOwnerModularAccountV1Address({
+          factoryAddress: factory,
+          salt,
+          ownerAddresses: sortedOwners,
+        }));
 
   const getFactoryArgs = async () => {
     const factoryData =