@alchemy/smart-accounts 0.0.0-alpha.2 → 0.0.0-alpha.21

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,8 +38,50 @@ 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["source"] extends LightAccountType ? TAccount["source"] : never;
+  TAccount["smartAccountType"] extends LightAccountType
+    ? TAccount["smartAccountType"]
+    : never;
 
 export type LightAccountAbi<
   TAccountType extends LightAccountType,

package/src/light-account/utils.ts

@@ -61,7 +61,7 @@ export async function getLightAccountImplAddress<
     throw new ChainNotFoundError();
   }
   const version = account.getLightAccountVersion();
-  const type = account.source;
+  const type = account.smartAccountType;
 
   const expectedImplAddresses = Object.values(AccountVersionRegistry[type]).map(
     (x) => x.accountImplementation,

package/src/ma-v1/accounts/base.ts

@@ -13,12 +13,14 @@ import {
 import {
   entryPoint06Abi,
   toSmartAccount,
-  type SmartAccount,
   type SmartAccountImplementation,
   entryPoint06Address,
   getUserOperationHash,
 } from "viem/account-abstraction";
-import type { SignatureRequest } from "../../types.js";
+import type {
+  SignatureRequest,
+  SmartAccountWithDecodeCalls,
+} from "../../types.js";
 import { IStandardExecutorAbi } from "../abis/IStandardExecutor.js";
 import { signMessage, signTypedData } from "viem/actions";
 import {
@@ -36,14 +38,15 @@ export type BaseMaV1AccountImplementation = SmartAccountImplementation<
   typeof entryPoint06Abi,
   "0.6",
   {
-    source: MaV1AccountType;
+    smartAccountType: MaV1AccountType;
     prepareSignature: (request: SignatureRequest) => Promise<SignatureRequest>;
     formatSignature: (signature: Hex) => Promise<Hex>;
   },
   false
 >;
 
-export type ModularAccountV1Base = SmartAccount<BaseMaV1AccountImplementation>;
+export type ModularAccountV1Base =
+  SmartAccountWithDecodeCalls<BaseMaV1AccountImplementation>;
 
 export type ToModularAccountV1BaseParams<
   TTransport extends Transport = Transport,
@@ -237,7 +240,7 @@ export async function toModularAccountV1Base<
     },
 
     extend: {
-      source: type,
+      smartAccountType: type,
       prepareSignature,
       formatSignature,
     },

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,10 +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;
-  factoryAddress?: Address;
-};
+  factory?: Address;
+} & (
+  | { salt?: bigint; factoryData?: never }
+  | { salt?: never; factoryData?: Hex }
+);
 
 /**
  * Creates a multi-owner MAv1 account.
@@ -49,7 +55,8 @@ export async function toMultiOwnerModularAccountV1({
   salt = 0n,
   owners,
   accountAddress: accountAddress_,
-  factoryAddress = DefaultMaV1Address.MULTI_OWNER_MAV1_FACTORY,
+  factory = DefaultMaV1Address.MULTI_OWNER_MAV1_FACTORY,
+  factoryData: factoryData_,
 }: ToMultiOwnerModularAccountV1Params): Promise<MultiOwnerModularAccountV1> {
   const signer = owners[0];
 
@@ -65,21 +72,33 @@ export async function toMultiOwnerModularAccountV1({
 
   const accountAddress =
     accountAddress_ ??
-    predictMultiOwnerModularAccountV1Address({
-      factoryAddress,
-      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 = encodeFunctionData({
-      abi: MultiOwnerModularAccountFactoryAbi,
-      functionName: "createAccount",
-      args: [salt, sortedOwners],
-    });
+    const factoryData =
+      factoryData_ ??
+      encodeFunctionData({
+        abi: MultiOwnerModularAccountFactoryAbi,
+        functionName: "createAccount",
+        args: [salt, sortedOwners],
+      });
 
     return {
-      factory: factoryAddress,
+      factory,
       factoryData,
     };
   };

package/src/ma-v1/decorators/multiOwner.ts

@@ -21,7 +21,10 @@ export type MultiOwnerModularAccountV1Actions<
 function isMultiOwnerModularAccountV1(
   account: SmartAccount,
 ): account is MultiOwnerModularAccountV1 {
-  return "source" in account && account.source === "MultiOwnerModularAccountV1";
+  return (
+    "smartAccountType" in account &&
+    account.smartAccountType === "MultiOwnerModularAccountV1"
+  );
 }
 
 /**

package/src/ma-v1/predictAddress.ts

@@ -1,13 +1,19 @@
 import {
   type Address,
-  getContractAddress,
+  type Client,
+  concatHex,
+  decodeFunctionData,
   encodeAbiParameters,
+  getContractAddress,
+  isAddressEqual,
   keccak256,
-  concatHex,
   type Hex,
 } from "viem";
+import type { EntryPointVersion } from "viem/account-abstraction";
 import { DefaultMaV1Address } from "./account.js";
+import { MultiOwnerModularAccountFactoryAbi } from "./abis/MultiOwnerModularAccountFactory.js";
 import { BaseError } from "@alchemy/common";
+import { getSenderFromFactoryData } from "../utils.js";
 
 export type PredictMultiOwnerModularAccountV1AddressParams = {
   salt: bigint;
@@ -83,3 +89,54 @@ function getERC1967ProxyInitCodeHash(implementationAddress: Address): Hex {
 
   return keccak256(concatHex([ERC1967_PROXY_BYTECODE, constructorArgs]));
 }
+
+export type GetMultiOwnerModularAccountV1AddressFromFactoryDataParams = {
+  client: Client;
+  factoryAddress: Address;
+  factoryData: Hex;
+  entryPoint: {
+    version: EntryPointVersion;
+    address: Address;
+  };
+};
+
+/**
+ * Gets the multi-owner modular account v1 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 {GetMultiOwnerModularAccountV1AddressFromFactoryDataParams} params - The parameters
+ * @returns {Promise<Address>} The account address
+ */
+export async function getMultiOwnerModularAccountV1AddressFromFactoryData({
+  client,
+  factoryAddress,
+  factoryData,
+  entryPoint,
+}: GetMultiOwnerModularAccountV1AddressFromFactoryDataParams): Promise<Address> {
+  if (
+    isAddressEqual(factoryAddress, DefaultMaV1Address.MULTI_OWNER_MAV1_FACTORY)
+  ) {
+    try {
+      const decoded = decodeFunctionData({
+        abi: MultiOwnerModularAccountFactoryAbi,
+        data: factoryData,
+      });
+      if (decoded.functionName === "createAccount") {
+        const [decodedSalt, decodedOwners] = decoded.args;
+        return predictMultiOwnerModularAccountV1Address({
+          factoryAddress,
+          salt: decodedSalt,
+          ownerAddresses: [...decodedOwners],
+        });
+      }
+    } catch {
+      // Decode failed, fall through to RPC
+    }
+  }
+  return getSenderFromFactoryData(client, {
+    factory: factoryAddress,
+    factoryData,
+    entryPoint,
+  });
+}

package/src/ma-v2/accounts/account.ts

@@ -9,16 +9,17 @@ import {
   type PrivateKeyAccount,
   type Transport,
 } from "viem";
-import type {
-  WebAuthnAccount,
-  ToSmartAccountParameters,
+import {
+  type ToSmartAccountParameters,
+  entryPoint07Address,
 } from "viem/account-abstraction";
 import { toModularAccountV2Base, type ModularAccountV2Base } from "./base.js";
 import type { SignerEntity } from "../types.js";
-import { predictModularAccountV2Address } from "../predictAddress.js";
-import { parsePublicKey } from "webauthn-p256";
+import {
+  getModularAccountV2AddressFromFactoryData,
+  predictModularAccountV2Address,
+} from "../predictAddress.js";
 import { accountFactoryAbi } from "../abis/accountFactoryAbi.js";
-import { webAuthnFactoryAbi } from "../abis/webAuthnFactoryAbi.js";
 import { EntityIdOverrideError } from "../../errors/EntityIdOverrideError.js";
 import { InvalidOwnerError } from "../../errors/InvalidOwnerError.js";
 import { DEFAULT_OWNER_ENTITY_ID, DefaultAddress } from "../utils/account.js";
@@ -33,7 +34,7 @@ export type ToModularAccountV2Params<
   TMode extends Mode | undefined = Mode | undefined,
 > = {
   client: Client<Transport, Chain, JsonRpcAccount | LocalAccount | undefined>;
-  owner: JsonRpcAccount | LocalAccount | WebAuthnAccount;
+  owner: JsonRpcAccount | LocalAccount;
   deferredAction?: Hex;
   signerEntity?: SignerEntity;
   accountAddress?: Address;
@@ -41,16 +42,23 @@ export type ToModularAccountV2Params<
 } & (TMode extends "7702"
   ? {
       salt?: never;
-      factoryAddress?: never;
+      factory?: never;
       factoryData?: never;
       implementationAddress?: never;
     }
   : {
-      salt?: bigint;
-      factoryAddress?: Address;
-      factoryData?: Hex;
+      factory?: Address;
       implementationAddress?: Address;
-    });
+    } & (
+      | {
+          salt?: bigint;
+          factoryData?: never;
+        }
+      | {
+          salt?: never;
+          factoryData?: Hex;
+        }
+    ));
 
 /**
  * Creates a MAv2 account.
@@ -65,7 +73,7 @@ export async function toModularAccountV2<TMode extends Mode = Mode>({
   signerEntity,
   accountAddress: accountAddress_,
   salt = 0n,
-  factoryAddress: factoryAddress_,
+  factory,
   factoryData: factoryData_,
   implementationAddress: implementationAddress_,
   mode,
@@ -81,19 +89,11 @@ export async function toModularAccountV2<TMode extends Mode = Mode>({
 
   const entityId = signerEntity?.entityId ?? DEFAULT_OWNER_ENTITY_ID;
 
-  const factoryAddress =
-    factoryAddress_ ??
-    (owner.type === "webAuthn"
-      ? DefaultAddress.MAV2_FACTORY_WEBAUTHN
-      : DefaultAddress.MAV2_FACTORY);
+  const factoryAddress = factory ?? DefaultAddress.MAV2_FACTORY;
 
   const implementationAddress =
     implementationAddress_ ??
-    (is7702
-      ? DefaultAddress.SMAV2_7702
-      : owner.type === "webAuthn"
-        ? DefaultAddress.MAV2
-        : DefaultAddress.SMAV2_BYTECODE);
+    (is7702 ? DefaultAddress.SMAV2_7702 : DefaultAddress.SMAV2_BYTECODE);
 
   const getFactoryArgs = async () => {
     if (is7702) {
@@ -108,20 +108,6 @@ export async function toModularAccountV2<TMode extends Mode = Mode>({
       } as const;
     }
 
-    if (owner.type === "webAuthn") {
-      const { x, y } = parsePublicKey(owner.publicKey);
-      return {
-        factory: factoryAddress,
-        factoryData:
-          factoryData_ ??
-          encodeFunctionData({
-            abi: webAuthnFactoryAbi,
-            functionName: "createWebAuthnAccount",
-            args: [x, y, salt, entityId],
-          }),
-      };
-    }
-
     return {
       factory: factoryAddress,
       factoryData:
@@ -136,24 +122,26 @@ export async function toModularAccountV2<TMode extends Mode = Mode>({
 
   const accountAddress =
     accountAddress_ ??
-    (mode === "7702" && owner.type === "local"
+    (is7702
       ? owner.address
-      : predictModularAccountV2Address({
-          factoryAddress,
-          implementationAddress,
-          salt,
-          ...(owner.type === "webAuthn"
-            ? {
-                type: "WebAuthn",
-                ownerPublicKey: owner.publicKey,
-                entityId,
-              }
-            : {
-                type: "SMA", // `MA` is never used here since we only support deploying SMA & WebAuthn accounts.
-                ownerAddress: owner.address,
-                entityId,
-              }),
-        }));
+      : factoryData_
+        ? await getModularAccountV2AddressFromFactoryData({
+            client,
+            factoryAddress,
+            factoryData: factoryData_,
+            implementationAddress,
+            entryPoint: {
+              version: "0.7",
+              address: entryPoint07Address,
+            },
+          })
+        : predictModularAccountV2Address({
+            factoryAddress,
+            implementationAddress,
+            salt,
+            type: "SMA",
+            ownerAddress: owner.address,
+          }));
 
   LOGGER.debug("toModularAccountV2:address-resolved", {
     accountAddress,
@@ -163,7 +151,6 @@ export async function toModularAccountV2<TMode extends Mode = Mode>({
   let authorization: ToSmartAccountParameters["authorization"];
   if (is7702) {
     LOGGER.debug("toModularAccountV2:7702-mode");
-    // TODO(v5): Ensure this works w/ our signer types.
     if (owner.type !== "local") {
       LOGGER.error("toModularAccountV2:invalid-owner-type", {
         ownerType: owner.type,