@account-kit/smart-contracts 4.12.1-alpha.0 → 4.13.1-alpha.0

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

@@ -0,0 +1,193 @@
+import type {
+  EntryPointDef,
+  SmartAccountSigner,
+  ToSmartContractAccountParams,
+} from "@aa-sdk/core";
+import {
+  createBundlerClient,
+  getEntryPoint,
+  getAccountAddress,
+  EntityIdOverrideError,
+  InvalidModularAccountV2Mode,
+} from "@aa-sdk/core";
+import {
+  concatHex,
+  encodeFunctionData,
+  type Address,
+  type Chain,
+  type Hex,
+  type Transport,
+} from "viem";
+import { accountFactoryAbi } from "../abis/accountFactoryAbi.js";
+import { getDefaultMAV2FactoryAddress } from "../utils.js";
+import {
+  type SignerEntity,
+  type ModularAccountV2,
+  createMAv2Base,
+} from "./common/modularAccountV2Base.js";
+import { DEFAULT_OWNER_ENTITY_ID } from "../utils.js";
+
+export type CreateModularAccountV2Params<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = (Pick<
+  ToSmartContractAccountParams<"ModularAccountV2", TTransport, Chain, "0.7.0">,
+  "transport" | "chain" | "accountAddress"
+> & {
+  signer: TSigner;
+  entryPoint?: EntryPointDef<"0.7.0", Chain>;
+  signerEntity?: SignerEntity;
+}) &
+  (
+    | {
+        mode?: "default";
+        salt?: bigint;
+        factoryAddress?: Address;
+        initCode?: Hex;
+      }
+    | {
+        mode: "7702";
+      }
+  );
+
+export async function createModularAccountV2<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>(
+  config: CreateModularAccountV2Params<TTransport, TSigner>
+): Promise<ModularAccountV2<TSigner>>;
+
+/**
+ * Creates a ModularAccount V2 account, with the mode depending on the provided "mode" field.
+ * Possible modes include: "default", which is SMA Bytecode, and "7702", which is SMA 7702.
+ * Handles nonce generation, transaction encoding, and mode variant-specific behavior like initcode construction.
+ *
+ * @example
+ * ```ts twoslash
+ * import { createModularAccountV2 } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { alchemy, sepolia } from "@account-kit/infra";
+ *
+ * const MNEMONIC = "...";
+ * const RPC_URL = "...";
+ *
+ * const signer = LocalAccountSigner.mnemonicToAccountSigner(MNEMONIC);
+ *
+ * const chain = sepolia;
+ *
+ * const transport = alchemy({ rpcUrl: RPC_URL });
+ *
+ *
+ * const modularAccountV2 = await createModularAccountV2({
+ *  mode: "default", // or "7702"
+ *  chain,
+ *  signer,
+ *  transport,
+ * });
+ * ```
+ *
+ * @param {CreateModularAccountV2Params} config Configuration parameters for creating a Modular Account V2.
+ * @returns {Promise<ModularAccountV2>} A promise that resolves to an `ModularAccountV2` providing methods for nonce retrieval, transaction execution, and more.
+ */
+export async function createModularAccountV2(
+  config: CreateModularAccountV2Params
+): Promise<ModularAccountV2> {
+  const {
+    transport,
+    chain,
+    signer,
+    accountAddress: _accountAddress,
+    entryPoint = getEntryPoint(chain, { version: "0.7.0" }),
+    signerEntity = {
+      isGlobalValidation: true,
+      entityId: DEFAULT_OWNER_ENTITY_ID,
+    },
+    signerEntity: { entityId = DEFAULT_OWNER_ENTITY_ID } = {},
+  } = config;
+
+  const client = createBundlerClient({
+    transport,
+    chain,
+  });
+
+  const accountFunctions = await (async () => {
+    switch (config.mode) {
+      case "7702": {
+        const getAccountInitCode = async (): Promise<Hex> => {
+          return "0x";
+        };
+        const signerAddress = await signer.getAddress();
+        const accountAddress = _accountAddress ?? signerAddress;
+        if (
+          entityId === DEFAULT_OWNER_ENTITY_ID &&
+          signerAddress !== accountAddress
+        ) {
+          throw new EntityIdOverrideError();
+        }
+
+        const implementation: Address =
+          "0x69007702764179f14F51cdce752f4f775d74E139";
+
+        const getImplementationAddress = async () => implementation;
+
+        return {
+          getAccountInitCode,
+          accountAddress,
+          getImplementationAddress,
+        };
+      }
+      case "default":
+      case undefined: {
+        const {
+          salt = 0n,
+          factoryAddress = getDefaultMAV2FactoryAddress(chain),
+          initCode,
+        } = config;
+
+        const getAccountInitCode = async () => {
+          if (initCode) {
+            return initCode;
+          }
+
+          return concatHex([
+            factoryAddress,
+            encodeFunctionData({
+              abi: accountFactoryAbi,
+              functionName: "createSemiModularAccount",
+              args: [await signer.getAddress(), salt],
+            }),
+          ]);
+        };
+
+        const accountAddress = await getAccountAddress({
+          client,
+          entryPoint,
+          accountAddress: _accountAddress,
+          getAccountInitCode,
+        });
+
+        return {
+          getAccountInitCode,
+          accountAddress,
+        };
+      }
+      default:
+        assertNever(config);
+    }
+  })();
+
+  return createMAv2Base({
+    source: "ModularAccountV2",
+    transport,
+    chain,
+    signer,
+    entryPoint,
+    signerEntity,
+    ...accountFunctions,
+  });
+}
+
+// If we add more valid modes, the switch case branch's mode will no longer be `never`, which will cause a compile time error here and ensure we handle the new type.
+function assertNever(_valid: never): never {
+  throw new InvalidModularAccountV2Mode();
+}

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

@@ -26,7 +26,7 @@ import {
  *
  * const MNEMONIC = "...":
  *
- * const account = createSMAV2Account({ config });
+ * const account = createModularAccountV2({ config });
  *
  * const signer = LocalAccountSigner.mnemonicToAccountSigner(MNEMONIC);
  *

package/src/ma-v2/actions/install-validation/installValidation.ts

@@ -24,8 +24,8 @@ import {
   serializeModuleEntity,
 } from "../common/utils.js";
 
-import { type SMAV2AccountClient } from "../../client/client.js";
-import { type MAV2Account } from "../../account/semiModularAccountV2.js";
+import { type ModularAccountV2Client } from "../../client/client.js";
+import { type ModularAccountV2 } from "../../account/common/modularAccountV2Base.js";
 import { DEFAULT_OWNER_ENTITY_ID } from "../../utils.js";
 
 export type InstallValidationParams<
@@ -38,9 +38,9 @@ export type InstallValidationParams<
     hookConfig: HookConfig;
     initData: Hex;
   }[];
-  account?: MAV2Account<TSigner> | undefined;
+  account?: ModularAccountV2<TSigner> | undefined;
 } & UserOperationOverridesParameter<
-  GetEntryPointFromAccount<MAV2Account<TSigner>>
+  GetEntryPointFromAccount<ModularAccountV2<TSigner>>
 >;
 
 export type UninstallValidationParams<
@@ -50,9 +50,9 @@ export type UninstallValidationParams<
   entityId: number;
   uninstallData: Hex;
   hookUninstallDatas: Hex[];
-  account?: MAV2Account<TSigner> | undefined;
+  account?: ModularAccountV2<TSigner> | undefined;
 } & UserOperationOverridesParameter<
-  GetEntryPointFromAccount<MAV2Account<TSigner>>
+  GetEntryPointFromAccount<ModularAccountV2<TSigner>>
 >;
 
 export type InstallValidationActions<
@@ -61,9 +61,16 @@ export type InstallValidationActions<
   installValidation: (
     args: InstallValidationParams<TSigner>
   ) => Promise<SendUserOperationResult>;
+  encodeInstallValidation: (
+    // TODO: omit the user op sending related parameters from this type
+    args: InstallValidationParams<TSigner>
+  ) => Promise<Hex>;
   uninstallValidation: (
     args: UninstallValidationParams<TSigner>
   ) => Promise<SendUserOperationResult>;
+  encodeUninstallValidation: (
+    args: UninstallValidationParams<TSigner>
+  ) => Promise<Hex>;
 };
 
 /**
@@ -71,10 +78,10 @@ export type InstallValidationActions<
  *
  * @example
  * ```ts
- * import { createSMAV2AccountClient, installValidationActions, getDefaultSingleSignerValidationModuleAddress, SingleSignerValidationModule } from "@account-kit/smart-contracts";
+ * import { createModularAccountV2Client, installValidationActions, getDefaultSingleSignerValidationModuleAddress, SingleSignerValidationModule } from "@account-kit/smart-contracts";
  * import { Address } from "viem";
  *
- * const client = (await createSMAV2AccountClient({ ... })).extend(installValidationActions);
+ * const client = (await createModularAccountV2Client({ ... })).extend(installValidationActions);
  * const sessionKeyAddress: Address = "0x1234";
  * const sessionKeyEntityId: number = 1;
  *
@@ -113,16 +120,15 @@ export type InstallValidationActions<
 export const installValidationActions: <
   TSigner extends SmartAccountSigner = SmartAccountSigner
 >(
-  client: SMAV2AccountClient<TSigner>
-) => InstallValidationActions<TSigner> = (client) => ({
-  installValidation: async ({
+  client: ModularAccountV2Client<TSigner>
+) => InstallValidationActions<TSigner> = (client) => {
+  const encodeInstallValidation = async ({
     validationConfig,
     selectors,
     installData,
     hooks,
     account = client.account,
-    overrides,
-  }) => {
+  }: InstallValidationParams) => {
     if (!account) {
       throw new AccountNotFoundError();
     }
@@ -143,9 +149,7 @@ export const installValidationActions: <
       throw new EntityIdOverrideError();
     }
 
-    const { encodeCallData } = account;
-
-    const callData = await encodeCallData(
+    return account.encodeCallData(
       encodeFunctionData({
         abi: semiModularAccountBytecodeAbi,
         functionName: "installValidation",
@@ -159,22 +163,15 @@ export const installValidationActions: <
         ],
       })
     );
+  };
 
-    return client.sendUserOperation({
-      uo: callData,
-      account,
-      overrides,
-    });
-  },
-
-  uninstallValidation: async ({
+  const encodeUninstallValidation = async ({
     moduleAddress,
     entityId,
     uninstallData,
     hookUninstallDatas,
     account = client.account,
-    overrides,
-  }) => {
+  }: UninstallValidationParams) => {
     if (!account) {
       throw new AccountNotFoundError();
     }
@@ -187,9 +184,7 @@ export const installValidationActions: <
       );
     }
 
-    const { encodeCallData } = account;
-
-    const callData = await encodeCallData(
+    return account.encodeCallData(
       encodeFunctionData({
         abi: semiModularAccountBytecodeAbi,
         functionName: "uninstallValidation",
@@ -203,11 +198,55 @@ export const installValidationActions: <
         ],
       })
     );
-
-    return client.sendUserOperation({
-      uo: callData,
-      account,
+  };
+
+  return {
+    encodeInstallValidation,
+    encodeUninstallValidation,
+    installValidation: async ({
+      validationConfig,
+      selectors,
+      installData,
+      hooks,
+      account = client.account,
       overrides,
-    });
-  },
-});
+    }) => {
+      const callData = await encodeInstallValidation({
+        validationConfig,
+        selectors,
+        installData,
+        hooks,
+        account,
+      });
+
+      return client.sendUserOperation({
+        uo: callData,
+        account,
+        overrides,
+      });
+    },
+
+    uninstallValidation: async ({
+      moduleAddress,
+      entityId,
+      uninstallData,
+      hookUninstallDatas,
+      account = client.account,
+      overrides,
+    }) => {
+      const callData = await encodeUninstallValidation({
+        moduleAddress,
+        entityId,
+        uninstallData,
+        hookUninstallDatas,
+        account,
+      });
+
+      return client.sendUserOperation({
+        uo: callData,
+        account,
+        overrides,
+      });
+    },
+  };
+};

package/src/ma-v2/client/client.ts

@@ -4,42 +4,49 @@ import {
   type SmartAccountClientConfig,
   type NotType,
   createSmartAccountClient,
+  default7702GasEstimator,
+  default7702UserOpSigner,
 } from "@aa-sdk/core";
 import { type Chain, type Transport } from "viem";
 
 import {
-  createSMAV2Account,
-  type CreateSMAV2AccountParams,
-  type MAV2Account,
-} from "../account/semiModularAccountV2.js";
+  createModularAccountV2,
+  type CreateModularAccountV2Params,
+} from "../account/modularAccountV2.js";
+
 import {
   createAlchemySmartAccountClient,
   isAlchemyTransport,
+  type AlchemySmartAccountClient,
   type AlchemySmartAccountClientConfig,
   type AlchemyTransport,
 } from "@account-kit/infra";
 import type { LightAccount } from "../../light-account/accounts/account.js";
-export type SMAV2AccountClient<
+
+import type { ModularAccountV2 } from "../account/common/modularAccountV2Base.js";
+
+export type ModularAccountV2Client<
   TSigner extends SmartAccountSigner = SmartAccountSigner,
   TChain extends Chain = Chain,
   TTransport extends Transport | AlchemyTransport = Transport
-> = SmartAccountClient<TTransport, TChain, MAV2Account<TSigner>>;
+> = SmartAccountClient<TTransport, TChain, ModularAccountV2<TSigner>>;
 
-export type CreateSMAV2AccountClientParams<
+export type CreateModularAccountV2ClientParams<
   TTransport extends Transport = Transport,
   TChain extends Chain = Chain,
   TSigner extends SmartAccountSigner = SmartAccountSigner
-> = CreateSMAV2AccountParams<TTransport, TSigner> &
+> = CreateModularAccountV2Params<TTransport, TSigner> &
   Omit<
     SmartAccountClientConfig<TTransport, TChain>,
     "transport" | "account" | "chain"
   >;
-export type CreateSMAV2AlchemyAccountClientParams<
+
+export type CreateModularAccountV2AlchemyClientParams<
   TTransport extends Transport = Transport,
   TChain extends Chain = Chain,
   TSigner extends SmartAccountSigner = SmartAccountSigner
 > = Omit<
-  CreateSMAV2AccountClientParams<TTransport, TChain, TSigner>,
+  CreateModularAccountV2ClientParams<TTransport, TChain, TSigner>,
   "transport"
 > &
   Omit<
@@ -47,31 +54,34 @@ export type CreateSMAV2AlchemyAccountClientParams<
     "account"
   > & { paymasterAndData?: never; dummyPaymasterAndData?: never };
 
-export function createSMAV2AccountClient<
+export function createModularAccountV2Client<
   TChain extends Chain = Chain,
   TSigner extends SmartAccountSigner = SmartAccountSigner
 >(
-  args: CreateSMAV2AlchemyAccountClientParams<AlchemyTransport, TChain, TSigner>
-): Promise<SMAV2AccountClient<TSigner, TChain, AlchemyTransport>>;
+  args: CreateModularAccountV2AlchemyClientParams<
+    AlchemyTransport,
+    TChain,
+    TSigner
+  >
+): Promise<ModularAccountV2Client<TSigner, TChain, AlchemyTransport>>;
 
-export function createSMAV2AccountClient<
+export function createModularAccountV2Client<
   TTransport extends Transport = Transport,
   TChain extends Chain = Chain,
   TSigner extends SmartAccountSigner = SmartAccountSigner
 >(
-  args: CreateSMAV2AccountClientParams<TTransport, TChain, TSigner> &
+  args: CreateModularAccountV2ClientParams<TTransport, TChain, TSigner> &
     NotType<TTransport, AlchemyTransport>
-): Promise<SMAV2AccountClient<TSigner, TChain>>;
+): Promise<ModularAccountV2Client<TSigner, TChain>>;
 
 /**
- * Creates a SMAv2 account client using the provided configuration parameters.
+ * Creates a Modular Account V2 client using the provided configuration parameters.
  *
  * @example
- * ```ts
- * import { http } from "viem";
- * import { createSMAV2AccountClient } from "@account-kit/smart-contracts";
+ * ```ts twoslash
+ * import { createModularAccountV2Client } from "@account-kit/smart-contracts";
  * import { LocalAccountSigner } from "@aa-sdk/core";
- * import { sepolia } from "@account-kit/infra";
+ * import { alchemy, sepolia } from "@account-kit/infra";
  *
  * const MNEMONIC = "...";
  * const RPC_URL = "...";
@@ -80,11 +90,11 @@ export function createSMAV2AccountClient<
  *
  * const chain = sepolia;
  *
- * const transport = http(RPC_URL);
+ * const transport = alchemy({ rpcUrl: RPC_URL });
  *
  * const policyId = "...";
  *
- * const SMAV2SignerAccountClient = await createSMAV2AccountClient({
+ * const modularAccountV2Client = await createModularAccountV2Client({
  *  chain,
  *  signer,
  *  transport,
@@ -92,29 +102,39 @@ export function createSMAV2AccountClient<
  * });
  * ```
  *
- * @param {CreateSMAV2AccountClientParams} config The configuration parameters required to create the MAv2 account client
+ * @param {CreateModularAccountV2ClientParams} config The configuration parameters required to create the Modular Account v2 account client
  * @returns {Promise<SmartAccountClient>} A promise that resolves to a `SmartAccountClient` instance
  */
-export async function createSMAV2AccountClient(
-  config: CreateSMAV2AccountClientParams
-): Promise<SmartAccountClient> {
+export async function createModularAccountV2Client(
+  config:
+    | CreateModularAccountV2ClientParams
+    | CreateModularAccountV2AlchemyClientParams
+): Promise<SmartAccountClient | AlchemySmartAccountClient> {
   const { transport, chain } = config;
-  const smaV2Account = await createSMAV2Account({
-    ...config,
-    transport,
-    chain,
-  });
+
+  const account = await createModularAccountV2(config);
+
+  const middlewareToAppend =
+    config.mode === "7702"
+      ? {
+          gasEstimator: default7702GasEstimator(config.gasEstimator),
+          signUserOperation: default7702UserOpSigner(config.signUserOperation),
+        }
+      : {};
+
   if (isAlchemyTransport(transport, chain)) {
     return createAlchemySmartAccountClient({
       ...config,
       transport,
       chain,
-      account: smaV2Account,
+      account,
+      ...middlewareToAppend,
     });
   }
 
   return createSmartAccountClient({
     ...config,
-    account: smaV2Account,
+    account,
+    ...middlewareToAppend,
   });
 }

package/src/ma-v2/index.ts

@@ -5,8 +5,6 @@ export { semiModularAccountBytecodeAbi } from "./abis/semiModularAccountBytecode
 export { semiModularAccountStorageAbi } from "./abis/semiModularAccountStorageAbi.js";
 
 export { nativeSMASigner } from "./account/nativeSMASigner.js";
-export type * from "./account/semiModularAccountV2.js";
-export { createSMAV2Account } from "./account/semiModularAccountV2.js";
 
 export type {
   ModuleEntity,
@@ -23,9 +21,6 @@ export {
 export type * from "./actions/install-validation/installValidation.js";
 export { installValidationActions } from "./actions/install-validation/installValidation.js";
 
-export type * from "./client/client.js";
-export { createSMAV2AccountClient } from "./client/client.js";
-
 export {
   getDefaultAllowlistModuleAddress,
   getDefaultNativeTokenLimitModuleAddress,

package/src/ma-v2/modules/allowlist-module/module.ts

@@ -1,8 +1,37 @@
 import { encodeAbiParameters, type Address, type Hex } from "viem";
 import { allowlistModuleAbi } from "./abis/allowlistModuleAbi.js";
+import { HookType, type HookConfig } from "../../actions/common/types.js";
 
 export const AllowlistModule = {
   abi: allowlistModuleAbi,
+  buildHook: (
+    installArgs: {
+      entityId: number;
+      inputs: Array<{
+        target: Address;
+        hasSelectorAllowlist: boolean;
+        hasERC20SpendLimit: boolean;
+        erc20SpendLimit: bigint;
+        selectors: Array<Hex>;
+      }>;
+    },
+    address: Address
+  ): {
+    hookConfig: HookConfig;
+    initData: Hex;
+  } => {
+    const installData = AllowlistModule.encodeOnInstallData(installArgs);
+    return {
+      hookConfig: {
+        address: address,
+        entityId: installArgs.entityId,
+        hookType: HookType.VALIDATION,
+        hasPreHooks: true,
+        hasPostHooks: false,
+      },
+      initData: installData,
+    };
+  },
   encodeOnInstallData: (args: {
     entityId: number;
     inputs: Array<{

package/src/ma-v2/modules/single-signer-validation/signer.ts

@@ -24,7 +24,7 @@ import { packUOSignature, pack1271Signature } from "../../utils.js";
  *
  * const MNEMONIC = "...":
  * 
- * const account = createSMAV2Account({ config });
+ * const account = createModularAccountV2({ config });
  *
  * const signer = LocalAccountSigner.mnemonicToAccountSigner(MNEMONIC);
  *

package/src/ma-v2/modules/time-range-module/module.ts

@@ -1,9 +1,42 @@
-import { encodeAbiParameters, type Hex } from "viem";
+import { encodeAbiParameters, type Address, type Hex } from "viem";
 
 import { timeRangeModuleAbi } from "./abis/timeRangeModuleAbi.js";
+import { HookType, type HookConfig } from "../../actions/common/types.js";
 
 export const TimeRangeModule = {
   abi: timeRangeModuleAbi,
+  buildHook: (
+    installArgs: {
+      entityId: number;
+      validUntil: number;
+      validAfter: number;
+    },
+    address: Address
+  ): { hookConfig: HookConfig; initData: Hex } => {
+    if (installArgs.validUntil > 2 ** 48 - 1) {
+      throw new Error(
+        "TimeRangeModule.buildHook: validUntil > type(uint48).max"
+      );
+    }
+
+    if (installArgs.validAfter > 2 ** 48 - 1) {
+      throw new Error(
+        "TimeRangeModule.buildHook: validAfter > type(uint48).max"
+      );
+    }
+
+    const installData = TimeRangeModule.encodeOnInstallData(installArgs);
+    return {
+      hookConfig: {
+        address: address,
+        entityId: installArgs.entityId,
+        hookType: HookType.VALIDATION,
+        hasPreHooks: false,
+        hasPostHooks: false,
+      },
+      initData: installData,
+    };
+  },
   encodeOnInstallData: (args: {
     entityId: number;
     validUntil: number;