@account-kit/smart-contracts 4.0.0-alpha.0

package/src/msca/account/multiOwnerAccount.ts

@@ -0,0 +1,131 @@
+import type {
+  EntryPointParameter,
+  SmartAccountSigner,
+  SmartContractAccountWithSigner,
+  ToSmartContractAccountParams,
+} from "@aa-sdk/core";
+import {
+  createBundlerClient,
+  getAccountAddress,
+  getEntryPoint,
+  toSmartContractAccount,
+} from "@aa-sdk/core";
+import {
+  concatHex,
+  encodeFunctionData,
+  hexToBigInt,
+  type Address,
+  type Chain,
+  type Hex,
+  type Transport,
+} from "viem";
+import { MultiOwnerModularAccountFactoryAbi } from "../abis/MultiOwnerModularAccountFactory.js";
+import { multiOwnerMessageSigner } from "../plugins/multi-owner/signer.js";
+import { getDefaultMultiOwnerModularAccountFactoryAddress } from "../utils.js";
+import { standardExecutor } from "./standardExecutor.js";
+
+export type MultiOwnerModularAccount<
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = SmartContractAccountWithSigner<
+  "MultiOwnerModularAccount",
+  TSigner,
+  "0.6.0"
+>;
+
+// [!region CreateMultiOwnerModularAccountParams]
+export type CreateMultiOwnerModularAccountParams<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TEntryPointVersion extends "0.6.0" = "0.6.0"
+> = Pick<
+  ToSmartContractAccountParams<
+    "MultiOwnerModularAccount",
+    TTransport,
+    Chain,
+    TEntryPointVersion
+  >,
+  "transport" | "chain"
+> & {
+  signer: TSigner;
+  salt?: bigint;
+  factoryAddress?: Address;
+  initCode?: Hex;
+  owners?: Address[];
+  accountAddress?: Address;
+} & EntryPointParameter<TEntryPointVersion, Chain>;
+// [!endregion CreateMultiOwnerModularAccountParams]
+
+export async function createMultiOwnerModularAccount<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>(
+  config: CreateMultiOwnerModularAccountParams<TTransport, TSigner>
+): Promise<MultiOwnerModularAccount<TSigner>>;
+
+export async function createMultiOwnerModularAccount({
+  transport,
+  chain,
+  signer,
+  accountAddress,
+  initCode,
+  entryPoint = getEntryPoint(chain, { version: "0.6.0" }),
+  factoryAddress = getDefaultMultiOwnerModularAccountFactoryAddress(chain),
+  owners = [],
+  salt = 0n,
+}: CreateMultiOwnerModularAccountParams): Promise<MultiOwnerModularAccount> {
+  const client = createBundlerClient({
+    transport,
+    chain,
+  });
+
+  const getAccountInitCode = async () => {
+    if (initCode) {
+      return initCode;
+    }
+
+    // NOTE: the current signer connected will be one of the owners as well
+    const ownerAddress = await signer.getAddress();
+    // owners need to be dedupe + ordered in ascending order and not == to zero address
+    const owners_ = Array.from(new Set([...owners, ownerAddress]))
+      .filter((x) => hexToBigInt(x) !== 0n)
+      .sort((a, b) => {
+        const bigintA = hexToBigInt(a);
+        const bigintB = hexToBigInt(b);
+
+        return bigintA < bigintB ? -1 : bigintA > bigintB ? 1 : 0;
+      });
+
+    return concatHex([
+      factoryAddress,
+      encodeFunctionData({
+        abi: MultiOwnerModularAccountFactoryAbi,
+        functionName: "createAccount",
+        args: [salt, owners_],
+      }),
+    ]);
+  };
+
+  const _accountAddress = await getAccountAddress({
+    client,
+    entryPoint,
+    accountAddress,
+    getAccountInitCode,
+  });
+
+  const baseAccount = await toSmartContractAccount({
+    transport,
+    chain,
+    entryPoint,
+    accountAddress: _accountAddress,
+    source: `MultiOwnerModularAccount`,
+    getAccountInitCode,
+    ...standardExecutor,
+    ...multiOwnerMessageSigner(client, _accountAddress, () => signer),
+  });
+
+  return {
+    ...baseAccount,
+    publicKey: await signer.getAddress(),
+    getSigner: () => signer,
+  };
+}

package/src/msca/account/multisigAccount.ts

@@ -0,0 +1,146 @@
+import {
+  createBundlerClient,
+  getAccountAddress,
+  getEntryPoint,
+  toSmartContractAccount,
+  type Address,
+  type EntryPointParameter,
+  type SmartAccountSigner,
+  type SmartContractAccount,
+  type SmartContractAccountWithSigner,
+  type ToSmartContractAccountParams,
+} from "@aa-sdk/core";
+import {
+  concatHex,
+  encodeFunctionData,
+  hexToBigInt,
+  type Chain,
+  type Hex,
+  type Transport,
+} from "viem";
+import { MultisigModularAccountFactoryAbi } from "../abis/MultisigModularAccountFactory.js";
+import { multisigSignMethods } from "../plugins/multisig/signer.js";
+import { getDefaultMultisigModularAccountFactoryAddress } from "../utils.js";
+import { standardExecutor } from "./standardExecutor.js";
+
+export const MULTISIG_ACCOUNT_SOURCE = "MultisigModularAccount";
+
+export type MultisigModularAccount<
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = SmartContractAccountWithSigner<
+  typeof MULTISIG_ACCOUNT_SOURCE,
+  TSigner,
+  "0.6.0"
+> & {
+  getLocalThreshold: () => bigint;
+};
+
+export type CreateMultisigModularAccountParams<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TEntryPointVersion extends "0.6.0" = "0.6.0"
+> = Pick<
+  ToSmartContractAccountParams<
+    "MultisigModularAccount",
+    TTransport,
+    Chain,
+    TEntryPointVersion
+  >,
+  "transport" | "chain"
+> & {
+  signer: TSigner;
+  salt?: bigint;
+  factoryAddress?: Address;
+  initCode?: Hex;
+  threshold: bigint;
+  owners?: Address[];
+  accountAddress?: Address;
+} & EntryPointParameter<TEntryPointVersion, Chain>;
+
+export async function createMultisigModularAccount<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>(
+  config: CreateMultisigModularAccountParams<TTransport, TSigner>
+): Promise<MultisigModularAccount<TSigner>>;
+
+export async function createMultisigModularAccount({
+  transport,
+  chain,
+  signer,
+  accountAddress,
+  initCode,
+  entryPoint = getEntryPoint(chain, { version: "0.6.0" }),
+  factoryAddress = getDefaultMultisigModularAccountFactoryAddress(chain),
+  owners = [],
+  salt = 0n,
+  threshold,
+}: CreateMultisigModularAccountParams): Promise<MultisigModularAccount> {
+  const client = createBundlerClient({
+    transport,
+    chain,
+  });
+
+  const getAccountInitCode = async () => {
+    if (initCode) {
+      return initCode;
+    }
+
+    // NOTE: the current signer connected will be one of the sigs as well
+    const sigAddress = await signer.getAddress();
+    // sigs need to be deduped + ordered in ascending order and !== to zero address
+    const sigs_ = Array.from(new Set([...owners, sigAddress]))
+      .filter((x) => hexToBigInt(x) !== 0n)
+      .sort((a, b) => {
+        const bigintA = hexToBigInt(a);
+        const bigintB = hexToBigInt(b);
+
+        return bigintA < bigintB ? -1 : bigintA > bigintB ? 1 : 0;
+      });
+
+    return concatHex([
+      factoryAddress,
+      encodeFunctionData({
+        abi: MultisigModularAccountFactoryAbi,
+        functionName: "createAccount",
+        args: [salt, sigs_, threshold],
+      }),
+    ]);
+  };
+
+  accountAddress = await getAccountAddress({
+    client,
+    entryPoint,
+    accountAddress: accountAddress,
+    getAccountInitCode,
+  });
+
+  const baseAccount = await toSmartContractAccount({
+    transport,
+    chain,
+    entryPoint,
+    accountAddress,
+    source: MULTISIG_ACCOUNT_SOURCE,
+    getAccountInitCode,
+    ...standardExecutor,
+    ...multisigSignMethods({
+      client,
+      accountAddress,
+      threshold,
+      signer: () => signer,
+    }),
+  });
+
+  return {
+    ...baseAccount,
+    getLocalThreshold: () => threshold,
+    publicKey: await signer.getAddress(),
+    getSigner: () => signer,
+  };
+}
+
+export const isMultisigModularAccount = (
+  acct: SmartContractAccount
+): acct is MultisigModularAccount => {
+  return acct.source === MULTISIG_ACCOUNT_SOURCE;
+};

package/src/msca/account/standardExecutor.ts

@@ -0,0 +1,29 @@
+import type { SmartContractAccount } from "@aa-sdk/core";
+import { encodeFunctionData } from "viem";
+import { IStandardExecutorAbi } from "../abis/IStandardExecutor.js";
+
+export const standardExecutor: Pick<
+  SmartContractAccount,
+  "encodeExecute" | "encodeBatchExecute"
+> = {
+  encodeExecute: async ({ target, data, value }) => {
+    return encodeFunctionData({
+      abi: IStandardExecutorAbi,
+      functionName: "execute",
+      args: [target, value ?? 0n, data],
+    });
+  },
+  encodeBatchExecute: async (txs) => {
+    return encodeFunctionData({
+      abi: IStandardExecutorAbi,
+      functionName: "executeBatch",
+      args: [
+        txs.map((tx) => ({
+          target: tx.target,
+          data: tx.data,
+          value: tx.value ?? 0n,
+        })),
+      ],
+    });
+  },
+};

package/src/msca/account-loupe/decorator.ts

@@ -0,0 +1,150 @@
+import {
+  AccountNotFoundError,
+  IncompatibleClientError,
+  isSmartAccountClient,
+  type GetAccountParameter,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import type { Address, Chain, Client, Hash, Transport } from "viem";
+import { IAccountLoupeAbi } from "../abis/IAccountLoupe.js";
+import type {
+  ExecutionFunctionConfig,
+  ExecutionHooks,
+  FunctionReference,
+  PreValidationHooks,
+} from "./types.js";
+
+export type AccountLoupeActions<
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+> = {
+  /// @notice Gets the validation functions and plugin address for a selector
+  /// @dev If the selector is a native function, the plugin address will be the address of the account
+  /// @param selector The selector to get the configuration for
+  /// @return The configuration for this selector
+  getExecutionFunctionConfig(
+    args: { selector: FunctionReference } & GetAccountParameter<TAccount>
+  ): Promise<ExecutionFunctionConfig>;
+
+  /// @notice Gets the pre and post execution hooks for a selector
+  /// @param selector The selector to get the hooks for
+  /// @return The pre and post execution hooks for this selector
+  getExecutionHooks(
+    args: {
+      selector: FunctionReference;
+    } & GetAccountParameter<TAccount>
+  ): Promise<ReadonlyArray<ExecutionHooks>>;
+
+  /// @notice Gets the pre user op and runtime validation hooks associated with a selector
+  /// @param selector The selector to get the hooks for
+  /// @return preUserOpValidationHooks The pre user op validation hooks for this selector
+  /// @return preRuntimeValidationHooks The pre runtime validation hooks for this selector
+  getPreValidationHooks(
+    args: { selector: Hash } & GetAccountParameter<TAccount>
+  ): Promise<Readonly<PreValidationHooks>>;
+
+  /// @notice Gets an array of all installed plugins
+  /// @return The addresses of all installed plugins
+  getInstalledPlugins(
+    args: GetAccountParameter<TAccount>
+  ): Promise<ReadonlyArray<Address>>;
+};
+
+export const accountLoupeActions: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+) => AccountLoupeActions<TAccount> = (client) => ({
+  getExecutionFunctionConfig: async ({
+    selector,
+    account = client.account,
+  }) => {
+    if (!account) {
+      throw new AccountNotFoundError();
+    }
+
+    if (!isSmartAccountClient(client)) {
+      throw new IncompatibleClientError(
+        "SmartAccountClient",
+        "getExecutionFunctionConfig",
+        client
+      );
+    }
+
+    return client.readContract({
+      address: account.address,
+      abi: IAccountLoupeAbi,
+      functionName: "getExecutionFunctionConfig",
+      args: [selector],
+    });
+  },
+
+  getExecutionHooks: async ({ selector, account = client.account }) => {
+    if (!account) {
+      throw new AccountNotFoundError();
+    }
+
+    if (!isSmartAccountClient(client)) {
+      throw new IncompatibleClientError(
+        "SmartAccountClient",
+        "getExecutionHooks",
+        client
+      );
+    }
+
+    return client.readContract({
+      address: account.address,
+      abi: IAccountLoupeAbi,
+      functionName: "getExecutionHooks",
+      args: [selector],
+    });
+  },
+
+  getPreValidationHooks: async ({ selector, account = client.account }) => {
+    if (!account) {
+      throw new AccountNotFoundError();
+    }
+
+    if (!isSmartAccountClient(client)) {
+      throw new IncompatibleClientError(
+        "SmartAccountClient",
+        "getPreValidationHooks",
+        client
+      );
+    }
+
+    return client.readContract({
+      address: account.address,
+      abi: IAccountLoupeAbi,
+      functionName: "getPreValidationHooks",
+      args: [selector],
+    });
+  },
+
+  getInstalledPlugins: async ({ account = client.account }) => {
+    if (!account) {
+      throw new AccountNotFoundError();
+    }
+
+    if (!isSmartAccountClient(client)) {
+      throw new IncompatibleClientError(
+        "SmartAccountClient",
+        "getInstalledPlugins",
+        client
+      );
+    }
+
+    return client
+      .readContract({
+        address: account.address,
+        abi: IAccountLoupeAbi,
+        functionName: "getInstalledPlugins",
+      })
+      .catch(() => []);
+  },
+});

package/src/msca/account-loupe/types.ts

@@ -0,0 +1,22 @@
+import type { Address, Hex } from "viem";
+
+export type FunctionId = Hex;
+
+// Treats the first 20 bytes as an address, and the last byte as a identifier.
+export type FunctionReference = Hex;
+
+export type ExecutionFunctionConfig = {
+  plugin: Address;
+  userOpValidationFunction: FunctionReference;
+  runtimeValidationFunction: FunctionReference;
+};
+
+export type ExecutionHooks = {
+  preExecHook: FunctionReference;
+  postExecHook: FunctionReference;
+};
+
+export type PreValidationHooks = [
+  readonly FunctionReference[],
+  readonly FunctionReference[]
+];

package/src/msca/client/alchemyClient.ts

@@ -0,0 +1,80 @@
+import {
+  AlchemyProviderConfigSchema,
+  createAlchemyPublicRpcClient,
+  createAlchemySmartAccountClientFromExisting,
+  type AlchemySmartAccountClient,
+  type AlchemySmartAccountClientConfig,
+} from "@account-kit/infra";
+import {
+  accountLoupeActions,
+  createMultiOwnerModularAccount,
+  multiOwnerPluginActions,
+  pluginManagerActions,
+  type AccountLoupeActions,
+  type CreateMultiOwnerModularAccountParams,
+  type LightAccount,
+  type MultiOwnerModularAccount,
+  type MultiOwnerPluginActions,
+  type PluginManagerActions,
+} from "@account-kit/smart-contracts";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import {
+  custom,
+  type Chain,
+  type CustomTransport,
+  type HttpTransport,
+  type Transport,
+} from "viem";
+
+export type AlchemyModularAccountClientConfig<
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = Omit<
+  CreateMultiOwnerModularAccountParams<HttpTransport, TSigner>,
+  "transport" | "chain"
+> &
+  Omit<
+    AlchemySmartAccountClientConfig<Transport, Chain, LightAccount<TSigner>>,
+    "account"
+  >;
+
+export function createModularAccountAlchemyClient<
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>(
+  params: AlchemyModularAccountClientConfig<TSigner>
+): Promise<
+  AlchemySmartAccountClient<
+    CustomTransport,
+    Chain | undefined,
+    MultiOwnerModularAccount<TSigner>,
+    MultiOwnerPluginActions<MultiOwnerModularAccount<TSigner>> &
+      PluginManagerActions<MultiOwnerModularAccount<TSigner>> &
+      AccountLoupeActions<MultiOwnerModularAccount<TSigner>>
+  >
+>;
+
+export async function createModularAccountAlchemyClient(
+  config: AlchemyModularAccountClientConfig
+): Promise<AlchemySmartAccountClient> {
+  const { chain, opts, ...connectionConfig } =
+    AlchemyProviderConfigSchema.parse(config);
+
+  const client = createAlchemyPublicRpcClient({
+    chain,
+    connectionConfig,
+  });
+
+  const account = await createMultiOwnerModularAccount({
+    transport: custom(client),
+    ...config,
+  });
+
+  return createAlchemySmartAccountClientFromExisting({
+    ...config,
+    client,
+    account,
+    opts,
+  })
+    .extend(multiOwnerPluginActions)
+    .extend(pluginManagerActions)
+    .extend(accountLoupeActions);
+}