@account-kit/smart-contracts 4.0.0-alpha.5 → 4.0.0-alpha.6

package/src/light-account/utils.ts

@@ -1,142 +1,71 @@
-import { DefaultFactoryNotDefinedError, toRecord } from "@aa-sdk/core";
-import {
-  arbitrum,
-  arbitrumGoerli,
-  arbitrumSepolia,
-  base,
-  baseGoerli,
-  baseSepolia,
-  fraxtal,
-  fraxtalSepolia,
-  goerli,
-  mainnet,
-  optimism,
-  optimismGoerli,
-  optimismSepolia,
-  polygon,
-  polygonAmoy,
-  polygonMumbai,
-  sepolia,
-  zora,
-  zoraSepolia,
-} from "@account-kit/infra";
+import type { GetEntryPointFromAccount } from "@aa-sdk/core";
 import { fromHex, type Address, type Chain } from "viem";
 import type { LightAccountBase } from "./accounts/base";
 import type {
-  AccountVersionDef,
-  GetLightAccountType,
-  GetLightAccountVersion,
-  GetLightAccountVersionFromAccount,
-  IAccountVersionRegistry,
   LightAccountType,
   LightAccountVersion,
-  LightAccountVersionDef,
+  LightAccountVersionConfig,
+  LightAccountVersionConfigs,
 } from "./types";
 
-/**
- * Light account deployed chains
- *
- */
-export const supportedChains: Chain[] = [
-  mainnet,
-  sepolia,
-  goerli,
-  polygon,
-  polygonAmoy,
-  polygonMumbai,
-  optimism,
-  optimismGoerli,
-  optimismSepolia,
-  arbitrum,
-  arbitrumGoerli,
-  arbitrumSepolia,
-  base,
-  baseGoerli,
-  baseSepolia,
-  fraxtal,
-  fraxtalSepolia,
-  zora,
-  zoraSepolia,
-];
-
 /**
  * Account version registry interface that defines the light account versions
  * and the version definition for each light account type
  *
  */
-export const AccountVersionRegistry: IAccountVersionRegistry = {
+export const AccountVersionRegistry: LightAccountVersionConfigs = {
   LightAccount: {
     "v1.0.1": {
-      type: "LightAccount",
-      version: "v1.0.1",
-      address: toRecord<Chain, "id", { factory: Address; impl: Address }>(
-        supportedChains,
-        "id",
-        () => ({
+      entryPointVersion: "0.6.0",
+      addresses: {
+        default: {
           factory:
             "0x000000893A26168158fbeaDD9335Be5bC96592E2".toLowerCase() as Address,
           impl: "0xc1b2fc4197c9187853243e6e4eb5a4af8879a1c0".toLowerCase() as Address,
-        })
-      ),
-      entryPointVersion: "0.6.0",
+        },
+      },
     },
     "v1.0.2": {
-      type: "LightAccount",
-      version: "v1.0.2",
-      address: toRecord<Chain, "id", { factory: Address; impl: Address }>(
-        supportedChains,
-        "id",
-        () => ({
+      entryPointVersion: "0.6.0",
+      addresses: {
+        default: {
           factory:
             "0x00000055C0b4fA41dde26A74435ff03692292FBD".toLowerCase() as Address,
           impl: "0x5467b1947F47d0646704EB801E075e72aeAe8113".toLowerCase() as Address,
-        })
-      ),
-      entryPointVersion: "0.6.0",
+        },
+      },
     },
     "v1.1.0": {
-      type: "LightAccount",
-      version: "v1.1.0",
-      address: toRecord<Chain, "id", { factory: Address; impl: Address }>(
-        supportedChains,
-        "id",
-        () => ({
+      entryPointVersion: "0.6.0",
+      addresses: {
+        default: {
           factory:
             "0x00004EC70002a32400f8ae005A26081065620D20".toLowerCase() as Address,
           impl: "0xae8c656ad28F2B59a196AB61815C16A0AE1c3cba".toLowerCase() as Address,
-        })
-      ),
-      entryPointVersion: "0.6.0",
+        },
+      },
     },
     "v2.0.0": {
-      type: "LightAccount",
-      version: "v2.0.0",
-      address: toRecord<Chain, "id", { factory: Address; impl: Address }>(
-        supportedChains,
-        "id",
-        () => ({
+      entryPointVersion: "0.7.0",
+      addresses: {
+        default: {
           factory:
             "0x0000000000400CdFef5E2714E63d8040b700BC24".toLowerCase() as Address,
           impl: "0x8E8e658E22B12ada97B402fF0b044D6A325013C7".toLowerCase() as Address,
-        })
-      ),
-      entryPointVersion: "0.7.0",
+        },
+      },
     },
   },
   MultiOwnerLightAccount: {
     "v2.0.0": {
-      type: "MultiOwnerLightAccount",
-      version: "v2.0.0",
-      address: toRecord<Chain, "id", { factory: Address; impl: Address }>(
-        supportedChains,
-        "id",
-        () => ({
+      entryPointVersion: "0.7.0",
+      addresses: {
+        default: {
           factory:
             "0x000000000019d2Ee9F2729A65AfE20bb0020AefC".toLowerCase() as Address,
           impl: "0xd2c27F9eE8E4355f71915ffD5568cB3433b6823D".toLowerCase() as Address,
-        })
-      ),
-      entryPointVersion: "0.7.0",
+        },
+      },
     },
   },
 };
@@ -145,60 +74,48 @@ export const AccountVersionRegistry: IAccountVersionRegistry = {
  * Get the default light account version for the given light account type
  *
  * @template {LightAccountType} TLightAccountType
- * @param type - the light account type to get the default version for
- * @returns the default version for the given light account type
+ * @returns {LightAccountVersion<TLightAccountType>} the default version for the given light account type
  */
 export const defaultLightAccountVersion = <
   TLightAccountType extends LightAccountType
->(
-  type: TLightAccountType
-): GetLightAccountVersion<TLightAccountType> =>
-  (type === "LightAccount"
-    ? "v1.1.0"
-    : "v2.0.0") as GetLightAccountVersion<TLightAccountType>;
+>(): LightAccountVersion<TLightAccountType> => "v2.0.0";
 
 /**
- * Utility method returning the default light account factory address given a {@link Chain} object
+ * Utility method returning the default light account factory address given a Chain object
  *
- * @param chain - a {@link Chain} object
- * @param version - the version of the light account to get the factory address for
- * @returns a {@link Address} for the given chain
+ * @param {Chain} chain - a Chain object
+ * @param {LightAccountVersion} version - the version of the light account to get the factory address for
+ * @returns {Address} an for the given chain
  * @throws if the chain doesn't have an address currently deployed
  */
 export const getDefaultLightAccountFactoryAddress = (
   chain: Chain,
-  version: GetLightAccountVersion<"LightAccount">
+  version: LightAccountVersion<"LightAccount">
 ): Address => {
-  const address =
-    AccountVersionRegistry.LightAccount[version].address[chain.id] ??
-    AccountVersionRegistry.LightAccount[version].address[supportedChains[0].id];
-  if (!address)
-    throw new DefaultFactoryNotDefinedError("LightAccount", chain, "0.6.0");
-  return address.factory;
+  return (
+    AccountVersionRegistry.LightAccount[version].addresses.overrides?.[chain.id]
+      ?.factory ??
+    AccountVersionRegistry.LightAccount[version].addresses.default.factory
+  );
 };
 
 /**
- * Utility method returning the default multi owner light account factory address given a {@link Chain} object
+ * Utility method returning the default multi owner light account factory address given a Chain object
  *
- * @param chain - a {@link Chain} object
- * @param version - the version of the light account to get the factory address for
- * @returns a {@link Address} for the given chain
- * @throws if the chain doesn't have an address currently deployed
+ * @param {Chain} chain - a Chain object
+ * @param {string} version - the version of the light account to get the factory address for
+ * @returns {Address} an Address for the given chain
  */
 export const getDefaultMultiOwnerLightAccountFactoryAddress = (
   chain: Chain,
-  version: GetLightAccountVersion<"MultiOwnerLightAccount">
+  version: LightAccountVersion<"MultiOwnerLightAccount">
 ) => {
-  const address =
-    AccountVersionRegistry.LightAccount[version].address[chain.id] ??
-    AccountVersionRegistry.LightAccount[version].address[supportedChains[0].id];
-  if (!address)
-    throw new DefaultFactoryNotDefinedError(
-      "MultiOwnerLightAccount",
-      chain,
-      "0.7.0"
-    );
-  return address.factory;
+  return (
+    AccountVersionRegistry.MultiOwnerLightAccount[version].addresses
+      .overrides?.[chain.id]?.factory ??
+    AccountVersionRegistry.MultiOwnerLightAccount[version].addresses.default
+      .factory
+  );
 };
 
 /**
@@ -219,98 +136,60 @@ export const LightAccountUnsupported1271Impls = [
  * Light accounts with versions v1.0.1 and v1.0.2 do not support 1271 signing.
  */
 export const LightAccountUnsupported1271Factories = new Set(
-  LightAccountUnsupported1271Impls.map((x) =>
-    Object.values(x.address).map((addr) => addr.factory)
-  ).flat()
+  LightAccountUnsupported1271Impls.map((x) => [
+    x.addresses.default.factory,
+    ...Object.values(x.addresses.overrides ?? {}).map((z) => z.factory),
+  ]).flat()
 );
 
 /**
  * Get the light account version definition for the given light account and chain
  *
  * @template {LightAccountBase} TAccount
- * @template {GetLightAccountType<TAccount>} TLightAccountType
- * @template {GetLightAccountVersion<TLightAccountType>} TLightAccountVersion
- * @param account - the light account to get the version for
- * @param chain - the chain to get the version for
- * @returns the light account version definition for the given light account and chain
- */
-export async function getLightAccountVersionDef<
-  TAccount extends LightAccountBase,
-  TLightAccountType extends GetLightAccountType<TAccount> = GetLightAccountType<TAccount>,
-  TLightAccountVersion extends GetLightAccountVersion<TLightAccountType> = GetLightAccountVersion<TLightAccountType>
->(
-  account: TAccount,
-  chain: Chain
-): Promise<LightAccountVersionDef<TLightAccountType, TLightAccountVersion>>;
-
-/**
- * Get the light account version definition for the given light account and chain
- *
- * @template {LightAccountBase} TAccount
- * @template {GetLightAccountType<TAccount>} TLightAccountType
- * @param account - the light account to get the version for
- * @param chain - the chain to get the version for
- * @returns the light account version definition for the given light account and chain
+ * @param {LightAccountBase} account the light account to get the version for
+ * @param {Chain} chain - the chain to get the version for
+ * @returns {Promise<LightAccountVersionConfig>} the light account version definition for the given light account and chain
  */
-export async function getLightAccountVersionDef<
-  TAccount extends LightAccountBase,
-  TLightAccountType extends GetLightAccountType<TAccount> = GetLightAccountType<TAccount>
->(
-  account: TAccount,
-  chain: Chain
-): Promise<
-  AccountVersionDef<
-    TLightAccountType,
-    GetLightAccountVersion<TLightAccountType>
-  >
->;
-
-/**
- * Get the light account version definition for the given light account and chain
- *
- * @template {LightAccountBase} TAccount
- * @param account - the light account to get the version for
- * @param chain - the chain to get the version for
- * @returns the light account version definition for the given light account and chain
- */
-export async function getLightAccountVersionDef<
+export async function getLightAccountVersionForAccount<
   TAccount extends LightAccountBase
->(account: TAccount, chain: Chain): Promise<AccountVersionDef> {
+>(account: TAccount, chain: Chain): Promise<LightAccountVersionConfig> {
   const accountType = account.source as LightAccountType;
   const factoryAddress = await account.getFactoryAddress();
   const implAddress = await account.getImplementationAddress();
   const implToVersion = new Map(
-    Object.entries(AccountVersionRegistry[accountType])
-      .map((pair) => {
-        const [version, def] = pair as [
-          GetLightAccountVersionFromAccount<TAccount>,
-          LightAccountVersionDef
-        ];
-        return chain.id in def.address
-          ? [def.address[chain.id].impl, version]
-          : [def.address[supportedChains[0].id].impl, version];
-      })
-      .filter(([impl]) => impl !== null) as [
-      Address,
-      keyof IAccountVersionRegistry[typeof accountType]
-    ][]
+    Object.entries(AccountVersionRegistry[accountType]).map((pair) => {
+      const [version, def] = pair as [
+        LightAccountVersion<LightAccountType>,
+        LightAccountVersionConfig<GetEntryPointFromAccount<TAccount>>
+      ];
+
+      if (
+        def.addresses.overrides != null &&
+        chain.id in def.addresses.overrides!
+      ) {
+        return [def.addresses.overrides[chain.id].impl, version];
+      }
+
+      return [def.addresses.default.impl, version];
+    })
   );
 
   const factoryToVersion = new Map(
-    Object.entries(AccountVersionRegistry[accountType])
-      .map((pair) => {
-        const [version, def] = pair as [
-          keyof IAccountVersionRegistry[typeof accountType],
-          LightAccountVersionDef
-        ];
-        return chain.id in def.address
-          ? [def.address[chain.id].factory, version]
-          : [def.address[supportedChains[0].id].factory, version];
-      })
-      .filter(([impl]) => impl !== null) as [
-      Address,
-      keyof IAccountVersionRegistry[typeof accountType]
-    ][]
+    Object.entries(AccountVersionRegistry[accountType]).map((pair) => {
+      const [version, def] = pair as [
+        LightAccountVersion<LightAccountType>,
+        LightAccountVersionConfig<GetEntryPointFromAccount<TAccount>>
+      ];
+
+      if (
+        def.addresses.overrides != null &&
+        chain.id in def.addresses.overrides!
+      ) {
+        return [def.addresses.overrides[chain.id].factory, version];
+      }
+
+      return [def.addresses.default.factory, version];
+    })
   );
 
   const version =
@@ -326,36 +205,3 @@ export async function getLightAccountVersionDef<
 
   return AccountVersionRegistry[accountType][version];
 }
-
-/**
- * @param account - the light account to get the version for
- * @param chain - the chain to get the version for
- *
- * @deprecated don't use this function as this function is replaced with getLightAccountVersionDef.
- *             Migrate to using getLightAccountVersionDef instead
- *
- * @returns the light account version for the given light account and chain
- */
-export async function getLightAccountVersion<
-  TAccount extends LightAccountBase,
-  TLightAccountType extends GetLightAccountType<TAccount> = GetLightAccountType<TAccount>
->(
-  account: TAccount,
-  chain?: Chain
-): Promise<GetLightAccountVersion<TLightAccountType>>;
-
-/**
- * Get the light account version for the given light account and chain
- *
- * @deprecated don't use this function as this function is replaced with getLightAccountVersionDef.
- *
- * @param account - the light account to get the version for
- * @param chain - the chain to get the version for
- * @returns the light account version for the given light account and chain
- */
-export async function getLightAccountVersion(
-  account: LightAccountBase,
-  chain: Chain = supportedChains[0]
-): Promise<LightAccountVersion> {
-  return (await getLightAccountVersionDef(account, chain)).version;
-}

package/src/msca/plugins/multisig/middleware.ts

@@ -27,12 +27,12 @@ import {
  * This middleware handles correctly aggregating signatures passed through
  * as context when sending UserOperations, proposing UserOperations, or adding signatures to a UserOperation.
  *
- * @param struct the user operation struct to be signed
- * @param param the parameters to be passed to the middleware
- * @param param.account the account to be used for signing
- * @param param.client the smart account client that will be used for RPC requests
- * @param param.context the context object containing the signatures to be aggregated {@link MultisigUserOperationContext}
- * @returns a Promise containing a UserOperation with an aggregated signature in the `signature` field
+ * @param {Deferrable<UserOperationStruct<TEntryPointVersion>>} struct the user operation struct to be signed
+ * @param {ClientMiddlewareArgs<TAccount, C, TContext, TEntryPointVersion>} args the parameters to be passed to the middleware
+ * @param {UserOperationOverrides<TEntryPointVersion>} args.account the account to be used for signing
+ * @param {MiddlewareClient} args.client the smart account client that will be used for RPC requests
+ * @param {MultisigUserOperationContext} args.context the context object containing the signatures to be aggregated MultisigUserOperationContext
+ * @returns {Promise<Deferrable<UserOperationStruct<TEntryPointVersion>>>} a Promise containing a UserOperation with an aggregated signature in the `signature` field
  */
 export const multisigSignatureMiddleware: ClientMiddlewareFn<
   MultisigUserOperationContext

package/src/msca/plugins/multisig/utils/formatSignatures.ts

@@ -8,9 +8,9 @@ import type { Signature } from "../types";
  * by signer address. The EOA SIGS contain the 65 signautre data for EOA signers and 65 bytes containing SIGNER | OFFSET | V for contract signers.
  * The OFFSET is used to fetch the signature data from the CONTRACT_SIG_DATAS.
  *
- * @param signatures the array of {@link Signature} objects to combine into the correct aggregated signature format excluding the upper limits
- * @param usingMaxValues a boolean indicating wether or not the UserOperation is using the UPPER_LIMIT for the gas and fee values
- * @returns the Hex representation of the signature
+ * @param {Signature[]} signatures the array of Signature objects to combine into the correct aggregated signature format excluding the upper limits
+ * @param {boolean} usingMaxValues a boolean indicating wether or not the UserOperation is using the UPPER_LIMIT for the gas and fee values
+ * @returns {Hex} the Hex representation of the signature
  */
 export const formatSignatures = (
   signatures: Signature[],

package/src/msca/plugins/multisig/utils/splitAggregatedSignature.ts

@@ -19,15 +19,23 @@ export type SplitAggregateSignatureParams<
   account: SmartContractAccount;
   request: UserOperationRequest<TEntryPointVersion>;
 };
+
+export type SplitAggregateSignatureResult = {
+  upperLimitPvg: Hex;
+  upperLimitMaxFeePerGas: Hex;
+  upperLimitMaxPriorityFeePerGas: Hex;
+  signatures: Signature[];
+};
+
 /**
  * Takes an aggregated signature and threshold and splits it into its components
  *
- * @param args - the arguments for the split
- * @param args.aggregateSignature - the aggregated signature to split
- * @param args.threshold - the threshold for the signature
- * @param args.account - the account which the signature is valid for
- * @param args.request - the user operation request that the signature is for
- * @returns the signature split into its upper limits and current signatures
+ * @param {SplitAggregateSignatureParams<TAccount>} args - the arguments for the split
+ * @param {Hex} args.aggregateSignature - the aggregated signature to split
+ * @param {number} args.threshold - the threshold for the signature
+ * @param {SmartContractAccount} args.account - the account which the signature is valid for
+ * @param {UserOperationRequest<TEntryPointVersion>} args.request - the user operation request that the signature is for
+ * @returns {Promise<SplitAggregateSignatureResult>} the signature split into its upper limits and current signatures
  */
 export const splitAggregatedSignature = async <
   TAccount extends SmartContractAccount | undefined =
@@ -35,12 +43,7 @@ export const splitAggregatedSignature = async <
     | undefined
 >(
   args: SplitAggregateSignatureParams<TAccount>
-): Promise<{
-  upperLimitPvg: Hex;
-  upperLimitMaxFeePerGas: Hex;
-  upperLimitMaxPriorityFeePerGas: Hex;
-  signatures: Signature[];
-}> => {
+): Promise<SplitAggregateSignatureResult> => {
   const { aggregatedSignature, threshold, account, request } = args;
   if (aggregatedSignature.length < 192 + (65 * threshold - 1)) {
     throw new InvalidAggregatedSignatureError();