@account-kit/plugingen 4.0.0-alpha.0

package/src/commands/generate/index.ts

@@ -0,0 +1,270 @@
+import { asyncPipe } from "@aa-sdk/core";
+import { kebabCase } from "change-case";
+import dedent from "dedent";
+import { default as fs } from "fs-extra";
+import { basename, dirname, resolve } from "pathe";
+import pc from "picocolors";
+import {
+  createPublicClient,
+  getContract,
+  http,
+  type GetContractReturnType,
+  type PublicClient,
+} from "viem";
+import z from "zod";
+import type { Config, PluginConfig } from "../../config.js";
+import { IPluginAbi } from "../../IPlugin.js";
+import * as logger from "../../logger.js";
+import { findConfig } from "../../utils/findConfig.js";
+import { format } from "../../utils/format.js";
+import { getIsUsingTypeScript } from "../../utils/isUsingTypescript.js";
+import { resolveConfig } from "../../utils/resolveConfig.js";
+import { ContractAbiGenPhase } from "./phases/contract-abi-gen.js";
+import { ContractAddressesGenPhase } from "./phases/contract-addresses-gen.js";
+import { ExecutionAbiGenPhase } from "./phases/execution-abi-gen.js";
+import { PluginActionsGenPhase } from "./phases/plugin-actions/index.js";
+import { PluginGeneratorPhase } from "./phases/plugin-generator/index.js";
+import type { Phase, PhaseInput } from "./types.js";
+
+const GenerateSchema = z.object({
+  /** Path to config file */
+  config: z.string().optional(),
+  /** Directory to search for config file */
+  root: z.string().optional(),
+});
+
+export type GenerateOptions = z.infer<typeof GenerateSchema>;
+
+export async function generate(options: GenerateOptions = {}) {
+  try {
+    options = await GenerateSchema.parseAsync(options);
+  } catch (error) {
+    if (error instanceof z.ZodError) throw error;
+    throw error;
+  }
+
+  // Get cli config file
+  const configPath = await findConfig(options);
+  if (!configPath) {
+    if (options.config) {
+      throw new Error(`Config not found at ${pc.gray(options.config)}`);
+    }
+
+    throw new Error("Config not found");
+  }
+
+  const resolvedConfigs = await resolveConfig({ configPath });
+  // TODO: need to use this in the phases below and add support for JS within the generated code
+  // To support that we will likely need to:
+  // 1. generate a types.ts file instead of appending the types to the top of the generated code
+  // 2. in generated plugin.(ts|js) files we will either import the types or use the type reference comment
+  // 3. in generated plugin files we need to check if TS when specifying the types of methods
+  const isTypeScript = await getIsUsingTypeScript();
+  if (!isTypeScript) {
+    throw new Error("Only typescript is supported at the moment.");
+  }
+
+  const outNames = new Set<string>();
+  const isArrayConfig = Array.isArray(resolvedConfigs);
+  const configs = isArrayConfig ? resolvedConfigs : [resolvedConfigs];
+
+  for (const config of configs) {
+    if (isArrayConfig)
+      logger.log(`Using config ${pc.gray(basename(configPath))}`);
+
+    // group configs by out dir
+    if (!config.outDir) throw new Error("outDir is required.");
+    if (outNames.has(config.outDir))
+      throw new Error(`outDir "${config.outDir}" must be unique.`);
+    outNames.add(config.outDir);
+    const spinner = logger.spinner();
+    const pluginConfigs = config.plugins;
+
+    // Get contracts from config
+    spinner.start("Resolving plugin contracts");
+    if (!pluginConfigs || !pluginConfigs.length) {
+      logger.warn("no plugins found in config");
+      spinner.fail();
+      return;
+    }
+
+    // TODO: check that plugins are unique
+    const plugins = pluginConfigs.map((plugin) => {
+      const chain = plugin.chain ?? config.chain;
+      const transport = http(plugin.rpcUrl ?? config.rpcUrl);
+
+      const client = createPublicClient({
+        chain,
+        transport,
+      });
+
+      if (!(chain.id in plugin.addresses)) {
+        spinner.fail();
+        throw new Error(
+          `contract address missing for the reference chain ${chain.id}`
+        );
+      }
+
+      return {
+        contract: getContract({
+          address: plugin.addresses[chain.id],
+          abi: IPluginAbi,
+          client,
+        }),
+        pluginConfig: plugin,
+      };
+    });
+    spinner.succeed();
+
+    // Generate plugin files
+    await Promise.all(
+      plugins.map((plugin) =>
+        generatePlugin({
+          pluginConfig: plugin.pluginConfig,
+          contract: plugin.contract,
+          config,
+        })
+      )
+    );
+  }
+}
+
+// Add more phases here if needed
+const phases: Phase[] = [
+  ContractAddressesGenPhase,
+  PluginGeneratorPhase,
+  PluginActionsGenPhase,
+  ExecutionAbiGenPhase,
+  ContractAbiGenPhase,
+];
+
+const generatePlugin = async ({
+  pluginConfig,
+  contract,
+  config,
+}: {
+  pluginConfig: PluginConfig;
+  contract: GetContractReturnType<typeof IPluginAbi, PublicClient>;
+  config: Config;
+}) => {
+  const spinner = logger.spinner();
+  spinner.start(`Generating plugin ${pc.gray(pluginConfig.name)}`);
+  // Setup plugin generator
+  const imports: Map<
+    string,
+    {
+      types: Set<string>;
+      members: Set<string>;
+    }
+  > = new Map();
+  const addImport: PhaseInput["addImport"] = (moduleName, member) => {
+    if (!imports.has(moduleName)) {
+      imports.set(moduleName, {
+        types: new Set(),
+        members: new Set(),
+      });
+    }
+
+    const module = imports.get(moduleName)!;
+    if (member.isType) {
+      module.types.add(member.name);
+    } else {
+      module.members.add(member.name);
+    }
+  };
+  const content: string[] = [];
+  const types: Map<string, { definition: string; isPublic: boolean }> =
+    new Map();
+  const addType: PhaseInput["addType"] = (typeName, typeDef, isPublic) => {
+    if (types.has(typeName)) {
+      throw new Error(`Type ${typeName} already exists`);
+    }
+
+    types.set(typeName, {
+      definition: typeDef.replace(";", ""),
+      isPublic: isPublic ?? false,
+    });
+  };
+
+  // TODO: we need to handle the case where this isn't typescript because right now we generate types in here
+  const result = await asyncPipe(...phases)({
+    addImport,
+    addType,
+    content,
+    config,
+    contract,
+    pluginConfig,
+  });
+
+  // Aggregate Result of phase
+  const finalContent = dedent`
+  ${Array.from(types.entries())
+    .map(
+      ([name, type]) =>
+        `${type.isPublic ? "export" : ""} type ${name} = ${type.definition};`
+    )
+    .join("\n\n")}
+
+  ${result.content.join("\n\n")}
+`;
+
+  const finalImports = Array.from(imports.entries())
+    .map(([moduleName, { members, types }]) => {
+      return dedent`
+      import { ${Array.from(members.values()).join(",")} ${
+        members.size > 0 ? "," : ""
+      } ${Array.from(types.values())
+        .map((x) => `type ${x}`)
+        .join(",")} } from "${moduleName}";
+  `;
+    })
+    .join("\n");
+  spinner.succeed();
+  await writePlugin({
+    config,
+    content: finalContent,
+    imports: finalImports,
+    pluginConfig,
+  });
+};
+
+const writePlugin = async ({
+  config,
+  content,
+  imports,
+  pluginConfig,
+}: {
+  pluginConfig: PluginConfig;
+  config: Config;
+  content: string;
+  imports: string;
+}) => {
+  const isTypeScript = await getIsUsingTypeScript();
+
+  const pluginRegEx: RegExp = /[pP]lugin/g;
+  // TODO: because we are now generating these ourselves, we have a lot more flexibility
+  // We could:
+  // 1. generate a types.ts file containing the type defs intead of merging them with content
+  // 2. generate an extensions.ts file which doesn't get overwritten on each generation
+  // 3. generate an index.ts file which correctly exports all of the types + exports the output of extensions.ts
+  // so that it's easier to extend and import without conflicts
+  const pluginPath = `${config.outDir}/${kebabCase(
+    pluginConfig.name.replaceAll(pluginRegEx, "")
+  )}/plugin.${isTypeScript ? "ts" : "js"}`;
+
+  const code = dedent`
+    ${imports}
+
+    ${content}
+`;
+
+  const spinner = logger.spinner();
+  spinner.start(`Writing plugin to ${pc.gray(pluginPath)}`);
+  // Format and write output
+  const cwd = process.cwd();
+  const outPath = resolve(cwd, pluginPath);
+  await fs.ensureDir(dirname(outPath));
+  const formatted = await format(code);
+  await fs.writeFile(outPath, formatted);
+  spinner.succeed();
+};

package/src/commands/generate/phases/contract-abi-gen.ts

@@ -0,0 +1,12 @@
+import dedent from "dedent";
+import type { Phase } from "../types";
+
+export const ContractAbiGenPhase: Phase = async (input) => {
+  const { content, pluginConfig } = input;
+  content.push(dedent`
+    export const ${pluginConfig.name}Abi = ${JSON.stringify(
+    pluginConfig.abi
+  )} as const;
+  `);
+  return input;
+};

package/src/commands/generate/phases/contract-addresses-gen.ts

@@ -0,0 +1,18 @@
+import dedent from "dedent";
+import type { Address } from "viem";
+import type { Phase } from "../types";
+
+export const ContractAddressesGenPhase: Phase = async (input) => {
+  const { pluginConfig, content, addImport } = input;
+
+  addImport("viem", { name: "Address", isType: true });
+  content.push(dedent`
+    const addresses = {${Object.entries(
+      pluginConfig.addresses as Record<number, Address>
+    ).reduce(
+      (prev, [chainId, addr]) => (prev += `${chainId}: "${addr}" as Address, `),
+      ""
+    )}} as Record<number, Address>;
+  `);
+  return input;
+};

package/src/commands/generate/phases/execution-abi-gen.ts

@@ -0,0 +1,20 @@
+import dedent from "dedent";
+import type { Phase } from "../types";
+import { executionAbiConst, extractExecutionAbi } from "../utils.js";
+
+export const ExecutionAbiGenPhase: Phase = async (input) => {
+  const { contract, content, pluginConfig } = input;
+
+  const { executionFunctions } = await contract.read.pluginManifest();
+  const executionAbi = extractExecutionAbi(
+    executionFunctions,
+    pluginConfig.abi
+  );
+
+  content.push(dedent`
+    export const ${executionAbiConst(pluginConfig.name)} = ${JSON.stringify(
+    executionAbi
+  )} as const;
+  `);
+  return input;
+};

package/src/commands/generate/phases/plugin-actions/index.ts

@@ -0,0 +1,151 @@
+import { asyncPipe } from "@aa-sdk/core";
+import { camelCase } from "change-case";
+import dedent from "dedent";
+import type { Phase } from "../../types";
+import { extractExecutionAbi } from "../../utils.js";
+import { ManagementActionsGenPhase } from "./management-actions.js";
+import { AccountReadActionsGenPhase } from "./read-actions.js";
+
+export const PluginActionsGenPhase: Phase = async (input) => {
+  const { pluginConfig, contract, addImport, addType } = input;
+  const { executionFunctions } = await contract.read.pluginManifest();
+  const executionAbiConst = `${pluginConfig.name}ExecutionFunctionAbi`;
+  const executionAbi = extractExecutionAbi(
+    executionFunctions,
+    pluginConfig.abi
+  );
+
+  addImport("viem", { name: "EncodeFunctionDataParameters", isType: true });
+  addImport("viem", { name: "Transport", isType: true });
+  addImport("viem", { name: "Chain", isType: true });
+  addImport("viem", { name: "Client", isType: true });
+  addImport("@aa-sdk/core", {
+    name: "SmartContractAccount",
+    isType: true,
+  });
+  addImport("@aa-sdk/core", {
+    name: "GetAccountParameter",
+    isType: true,
+  });
+  addImport("@aa-sdk/core", {
+    name: "SendUserOperationResult",
+    isType: true,
+  });
+  addImport("@aa-sdk/core", {
+    name: "GetEntryPointFromAccount",
+    isType: true,
+  });
+  addImport("@aa-sdk/core", {
+    name: "UserOperationOverridesParameter",
+    isType: true,
+  });
+  addImport("@aa-sdk/core", {
+    name: "UserOperationContext",
+    isType: true,
+  });
+  addImport("@aa-sdk/core", { name: "AccountNotFoundError" });
+  addImport("@aa-sdk/core", { name: "isSmartAccountClient" });
+  addImport("@aa-sdk/core", { name: "IncompatibleClientError" });
+  addImport("@aa-sdk/core", { name: "GetContextParameter", isType: true });
+
+  const providerFunctionDefs: string[] = [];
+  const providerFunctions = executionAbi
+    .filter((n) => n.stateMutability !== "view")
+    .map((n) => {
+      const argsParamString =
+        n.inputs.length > 0
+          ? dedent`{
+                args,
+                overrides,
+                context,
+                account = client.account
+            }`
+          : dedent`{
+                overrides,
+                context,
+                account = client.account
+            }`;
+      const argsEncodeString = n.inputs.length > 0 ? "args," : "";
+
+      providerFunctionDefs.push(dedent`
+          ${camelCase(
+            n.name
+          )}: (args: Pick<EncodeFunctionDataParameters<typeof ${executionAbiConst}, "${
+        n.name
+      }">, "args"> & UserOperationOverridesParameter<TEntryPointVersion> &
+          GetAccountParameter<TAccount> & GetContextParameter<TContext>) =>
+            Promise<SendUserOperationResult<TEntryPointVersion>>
+      `);
+      const methodName = camelCase(n.name);
+      return dedent`
+              ${methodName}(${argsParamString}) {
+                if (!account) {
+                  throw new AccountNotFoundError();
+                }
+                if (!isSmartAccountClient(client)) {
+                  throw new IncompatibleClientError("SmartAccountClient", "${methodName}", client);
+                }
+
+                const uo = encodeFunctionData({
+                  abi: ${executionAbiConst},
+                  functionName: "${n.name}",
+                  ${argsEncodeString}
+                });
+
+                return client.sendUserOperation({ uo, overrides, account, context });
+              }
+            `;
+    });
+
+  addType(
+    `ExecutionActions<
+      TAccount extends SmartContractAccount | undefined = SmartContractAccount | undefined,
+      TContext extends UserOperationContext | undefined = UserOperationContext | undefined,
+      TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+    >`,
+    dedent`{
+        ${providerFunctionDefs.join(";\n\n")}
+      }`
+  );
+
+  const { hasReadMethods } = await asyncPipe(
+    ManagementActionsGenPhase,
+    AccountReadActionsGenPhase
+  )({
+    ...input,
+    content: providerFunctions,
+  });
+
+  addType(
+    `${pluginConfig.name}Actions<
+      TAccount extends SmartContractAccount | undefined =
+          | SmartContractAccount
+          | undefined,
+      TContext extends UserOperationContext | undefined = UserOperationContext | undefined>`,
+    dedent`
+    ExecutionActions<TAccount, TContext> & ManagementActions<TAccount, TContext> & ReadAndEncodeActions${
+      hasReadMethods ? "<TAccount>" : ""
+    }
+  `,
+    true
+  );
+
+  input.content.push(dedent`
+    export const ${camelCase(pluginConfig.name)}Actions: <
+        TTransport extends Transport = Transport,
+        TChain extends Chain | undefined = Chain | undefined,
+        TAccount extends SmartContractAccount | undefined =
+            | SmartContractAccount
+            | undefined,
+        TContext extends UserOperationContext | undefined = UserOperationContext | undefined
+    >(
+      client: Client<TTransport, TChain, TAccount>
+    ) => ${
+      pluginConfig.name
+    }Actions<TAccount, TContext> = (client) => ({ ${providerFunctions.join(
+    ",\n"
+  )} });
+  `);
+
+  return input;
+};

package/src/commands/generate/phases/plugin-actions/management-actions.ts

@@ -0,0 +1,141 @@
+import { kebabCase } from "change-case";
+import dedent from "dedent";
+import type { PluginConfig } from "../../../../config";
+import type { Phase, PhaseInput } from "../../types";
+
+export const ManagementActionsGenPhase: Phase = async (input) => {
+  const { addImport, pluginConfig, addType } = input;
+  if (pluginConfig.installConfig != null) {
+    addImports(
+      addImport,
+      pluginConfig.installConfig.dependencies?.map((x) => x.plugin) ?? []
+    );
+
+    const initArgs = pluginConfig.installConfig.initAbiParams ?? [];
+
+    addType("InstallArgs", JSON.stringify(initArgs));
+    addType(
+      `Install${pluginConfig.name}Params`,
+      dedent`{
+        args: Parameters<typeof encodeAbiParameters<InstallArgs>>[1];
+        pluginAddress?: Address;
+        dependencyOverrides?: FunctionReference[];
+    }`,
+      true
+    );
+    addType(
+      `ManagementActions<
+        TAccount extends SmartContractAccount | undefined = SmartContractAccount | undefined,
+        TContext extends UserOperationContext | undefined = Record<string,any> | undefined,
+        TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+      >`,
+      dedent`{
+      install${pluginConfig.name}: (args:
+        UserOperationOverridesParameter<TEntryPointVersion> &
+        Install${pluginConfig.name}Params & GetAccountParameter<TAccount> & GetContextParameter<TContext>) =>
+          Promise<SendUserOperationResult<TEntryPointVersion>>
+    }`
+    );
+
+    const dependencies = (pluginConfig.installConfig.dependencies ?? []).map(
+      (x) => dedent`
+        (() => {
+          const pluginAddress = ${x.plugin.name}.meta.addresses[chain.id];
+          if (!pluginAddress) {
+            throw new Error("missing ${x.plugin.name} address for chain " + chain.name);
+          }
+
+          return encodePacked(
+            ["address", "uint8"],
+            [pluginAddress, ${x.functionId}]
+          );
+        })()
+      `
+    );
+
+    const installMethodName = `install${pluginConfig.name}`;
+
+    input.content.push(dedent`
+    ${installMethodName}({account = client.account, overrides, context, ...params}) {
+      if (!account) {
+        throw new AccountNotFoundError();
+      }
+
+      if (!isSmartAccountClient(client)) {
+        throw new IncompatibleClientError("SmartAccountClient", "${installMethodName}", client);
+      }
+
+      const chain = client.chain;
+      if (!chain) {
+        throw new ChainNotFoundError();
+      }
+
+      const dependencies = params.dependencyOverrides ?? [${dependencies.join(
+        ",\n\n"
+      )}];
+      const pluginAddress = params.pluginAddress ?? ${
+        pluginConfig.name
+      }.meta.addresses[chain.id] as Address | undefined;
+
+      if (!pluginAddress) {
+        throw new Error("missing ${
+          pluginConfig.name
+        } address for chain " + chain.name);
+      }
+
+      return installPlugin_(client, {
+        pluginAddress,
+        pluginInitData: encodeAbiParameters(${JSON.stringify(
+          initArgs
+        )}, params.args),
+        dependencies,
+        overrides,
+        account,
+        context,
+      });
+    }
+  `);
+  }
+
+  return input;
+};
+
+const addImports = (
+  addImport: PhaseInput["addImport"],
+  deps?: PluginConfig[]
+) => {
+  if (deps != null && deps.length > 0) {
+    addImport("viem", { name: "encodePacked" });
+    deps.forEach((x) => {
+      addImport(
+        `../${kebabCase(x.name.replaceAll(/[pP]lugin/g, ""))}/plugin.js`,
+        {
+          name: x.name,
+        }
+      );
+    });
+  }
+
+  addImport("@aa-sdk/core", { name: "ChainNotFoundError" });
+  addImport("viem", { name: "encodeAbiParameters" });
+  addImport("@account-kit/smart-contracts", {
+    name: "installPlugin as installPlugin_",
+  });
+  addImport("@aa-sdk/core", {
+    name: "GetAccountParameter",
+    isType: true,
+  });
+  addImport("@aa-sdk/core", {
+    name: "GetEntryPointFromAccount",
+    isType: true,
+  });
+  addImport("@aa-sdk/core", {
+    name: "UserOperationContext",
+    isType: true,
+  });
+  addImport("@account-kit/smart-contracts", {
+    name: "FunctionReference",
+    isType: true,
+  });
+  addImport("@aa-sdk/core", { name: "GetContextParameter", isType: true });
+};