@account-kit/plugingen 4.0.0-alpha.0

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

@@ -0,0 +1,97 @@
+import { pascalCase } from "change-case";
+import dedent from "dedent";
+import type { Phase } from "../../types";
+import { extractExecutionAbi } from "../../utils.js";
+
+export const AccountReadActionsGenPhase: 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: "encodeFunctionData" });
+  addImport("viem", { name: "Hex", isType: true });
+
+  const accountFunctionActionDefs: string[] = [];
+
+  const accountFunctions = executionAbi.map((n) => {
+    const methodContent: string[] = [];
+    const argsParamString = n.inputs.length > 0 ? `{ args }` : "";
+    const argsEncodeString = n.inputs.length > 0 ? "args," : "";
+    const isViewFunction = n.stateMutability === "view";
+
+    const encodeMethodName = `encode${pascalCase(n.name)}`;
+    accountFunctionActionDefs.push(
+      dedent`${encodeMethodName}: (args: Pick<EncodeFunctionDataParameters<typeof ${executionAbiConst}, "${n.name}">, "args">) => Hex`
+    );
+    methodContent.push(dedent`
+      ${encodeMethodName}(${argsParamString}) {
+          return encodeFunctionData({
+              abi: ${executionAbiConst},
+              functionName: "${n.name}",
+              ${argsEncodeString}
+          });
+      }
+    `);
+
+    const readArgsParamString =
+      n.inputs.length > 0
+        ? `{ args, account = client.account }`
+        : "{ account = client.account }";
+    if (isViewFunction) {
+      addImport("viem", { name: "ReadContractReturnType", isType: true });
+      input.hasReadMethods = true;
+      const readMethodName = `read${pascalCase(n.name)}`;
+      accountFunctionActionDefs.push(
+        n.inputs.length > 0
+          ? dedent`${readMethodName}: (
+            args: Pick<EncodeFunctionDataParameters<typeof ${executionAbiConst}, "${n.name}">, "args"> &
+              GetAccountParameter<TAccount>
+          ) => Promise<ReadContractReturnType<typeof ${executionAbiConst}, "${n.name}">>`
+          : dedent`${readMethodName}: (args: GetAccountParameter<TAccount>) =>
+              Promise<ReadContractReturnType<typeof ${executionAbiConst}, "${n.name}">>`
+      );
+
+      methodContent.push(dedent`
+        async ${readMethodName} (${readArgsParamString}) {
+          if (!account) {
+            throw new AccountNotFoundError();
+          }
+
+          if (!isSmartAccountClient(client)) {
+            throw new IncompatibleClientError("SmartAccountClient", "${readMethodName}", client);
+          }
+
+          return client.readContract({
+            address: account.address,
+            abi: ${executionAbiConst},
+            functionName: "${n.name}",
+            ${argsEncodeString}
+          });
+        }
+      `);
+    }
+
+    return methodContent.join(",\n\n");
+  });
+
+  const typeName = input.hasReadMethods
+    ? `ReadAndEncodeActions<
+        TAccount extends SmartContractAccount | undefined = SmartContractAccount | undefined,
+      >`
+    : "ReadAndEncodeActions";
+
+  addType(
+    typeName,
+    dedent`{
+    ${accountFunctionActionDefs.join(";\n\n")}
+  }`
+  );
+  input.content.push(...accountFunctions);
+
+  return input;
+};

package/src/commands/generate/phases/plugin-generator/get-contract-gen.ts

@@ -0,0 +1,30 @@
+import dedent from "dedent";
+import type { Phase } from "../../types";
+
+export const GetContractGenPhase: Phase = async (input) => {
+  const { content, pluginConfig, addImport } = input;
+
+  addImport("viem", { name: "getContract", isType: false });
+  addImport("viem", { name: "GetContractReturnType", isType: true });
+  addImport("viem", { name: "Address", isType: true });
+  addImport("viem", { name: "Transport", isType: true });
+  addImport("viem", { name: "PublicClient", isType: true });
+  addImport("viem", { name: "Client", isType: true });
+  addImport("@aa-sdk/core", { name: "ChainNotFoundError" });
+
+  content.push(dedent`
+  getContract: <C extends Client>(
+    client: C,
+    address?: Address
+  ): GetContractReturnType<typeof ${pluginConfig.name}Abi, PublicClient, Address> => {
+      if (!client.chain) throw new ChainNotFoundError();
+
+      return getContract({
+        address: address || addresses[client.chain.id],
+        abi: ${pluginConfig.name}Abi,
+        client: client,
+      });
+  }`);
+
+  return input;
+};

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

@@ -0,0 +1,27 @@
+import { asyncPipe } from "@aa-sdk/core";
+import dedent from "dedent";
+import type { Phase } from "../../types";
+import { GetContractGenPhase } from "./get-contract-gen.js";
+import { MetaGenPhase } from "./meta-gen.js";
+
+export const PluginGeneratorPhase: Phase = async (input) => {
+  const pluginPhases: Phase[] = [MetaGenPhase, GetContractGenPhase];
+  const { pluginConfig, addImport } = input;
+
+  const result = await asyncPipe(...pluginPhases)({
+    ...input,
+    content: [],
+  });
+
+  addImport("@account-kit/smart-contracts", { name: "Plugin", isType: true });
+
+  input.content.push(dedent`
+    export const ${pluginConfig.name}: Plugin<typeof ${
+    pluginConfig.name
+  }Abi> = {
+        ${result.content.join(",\n")}
+    };
+  `);
+
+  return input;
+};

package/src/commands/generate/phases/plugin-generator/meta-gen.ts

@@ -0,0 +1,17 @@
+import dedent from "dedent";
+import type { Phase } from "../../types";
+
+export const MetaGenPhase: Phase = async (input) => {
+  const { contract, content } = input;
+  const { name, version } = await contract.read.pluginMetadata();
+
+  content.push(dedent`
+    meta: {
+        name: "${name}",
+        version: "${version}",
+        addresses,
+    }
+  `);
+
+  return input;
+};

package/src/commands/generate/types.ts

@@ -0,0 +1,18 @@
+import type { GetContractReturnType, PublicClient } from "viem";
+import type { Config, PluginConfig } from "../../config.js";
+import type { IPluginAbi } from "../../IPlugin.js";
+
+export type PhaseInput = {
+  content: string[];
+  addImport: (
+    moduleName: string,
+    member: { name: string; isType?: boolean }
+  ) => void;
+  addType: (typeName: string, typeDef: string, isPublic?: boolean) => void;
+  pluginConfig: PluginConfig;
+  config: Config;
+  contract: GetContractReturnType<typeof IPluginAbi, PublicClient>;
+  hasReadMethods?: boolean;
+};
+
+export type Phase = (input: PhaseInput) => Promise<PhaseInput>;

package/src/commands/generate/utils.ts

@@ -0,0 +1,26 @@
+import { type AbiFunction } from "abitype";
+import { getAbiItem, type Abi, type AbiItem, type Address } from "viem";
+
+export const executionAbiConst = (name: string) =>
+  `${name}ExecutionFunctionAbi`;
+
+export const extractExecutionAbi = (
+  executionFunctions: readonly Address[],
+  abi: Abi
+): AbiFunction[] => {
+  return executionFunctions.map((f) => {
+    const item = getAbiItem({
+      abi: abi,
+      name: f,
+    }) as AbiItem;
+
+    if (item.type !== "function") {
+      throw new Error(
+        "execution function not mapping to a function in the ABI",
+        { cause: JSON.stringify(item, null, 2) }
+      );
+    }
+
+    return item;
+  });
+};

package/src/commands/init.ts

@@ -0,0 +1,93 @@
+// borrows heavily from https://github.com/wevm/wagmi/blob/main/packages/cli/src/commands/init.ts
+import dedent from "dedent";
+import { default as fs } from "fs-extra";
+import { relative, resolve } from "pathe";
+import pc from "picocolors";
+import z from "zod";
+import { fromZodError } from "../errors.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";
+
+export type InitOptions = {
+  /** Path to config file */
+  config?: string;
+  /** Directory to init config file */
+  root?: string;
+};
+
+const InitSchema = z.object({
+  config: z.string().optional(),
+  root: z.string().optional(),
+});
+
+export async function init(options: InitOptions = {}) {
+  try {
+    options = await InitSchema.parseAsync(options);
+  } catch (error) {
+    if (error instanceof z.ZodError)
+      throw fromZodError(error, { prefix: "Invalid option" });
+    throw error;
+  }
+
+  // Check for existing config file
+  const configPath = await findConfig(options);
+  if (configPath) {
+    logger.info(
+      `Config already exists at ${pc.gray(relative(process.cwd(), configPath))}`
+    );
+    return configPath;
+  }
+
+  const spinner = logger.spinner();
+  spinner.start("Creating config");
+  // Check if project is using TypeScript
+  const isUsingTypeScript = await getIsUsingTypeScript();
+  const rootDir = resolve(options.root || process.cwd());
+  let outPath: string;
+  if (options.config) {
+    outPath = resolve(rootDir, options.config);
+  } else {
+    const extension = isUsingTypeScript ? "ts" : "js";
+    outPath = resolve(rootDir, `plugingen.config.${extension}`);
+  }
+
+  let content: string;
+  if (isUsingTypeScript) {
+    content = dedent(`
+      import { defineConfig } from '@account-kit/plugingen';
+      import { sepolia } from "viem/chains";
+      
+      export default defineConfig({
+        outDir: "./src/generated",
+        chain: sepolia,
+        rpcUrl: "https://ethereum-sepolia.publicnode.com",
+        plugins: [],
+      });
+    `);
+  } else {
+    content = dedent(`
+      // @ts-check
+
+      /** @type {import('@account-kit/plugingen').Config} */
+      export default ${dedent`
+      {
+        outDir: "./src/generated",
+        chain: sepolia,
+        rpcUrl: "https://ethereum-sepolia.publicnode.com",
+        plugins: [],
+      }
+      `.replace(/"(\d*)":/gm, "$1:")}
+    `);
+  }
+
+  const formatted = await format(content);
+  await fs.writeFile(outPath, formatted);
+  spinner.succeed();
+  logger.success(
+    `Config created at ${pc.gray(relative(process.cwd(), outPath))}`
+  );
+
+  return outPath;
+}

package/src/config.ts

@@ -0,0 +1,79 @@
+import type { Abi, Address, Chain, Hex, parseAbiParameters } from "viem";
+import type { Evaluate, MaybeArray, MaybePromise } from "./types";
+
+export type ContractConfig<
+  chainId extends number = number,
+  requiredChainId extends number | undefined = undefined
+> = {
+  /**
+   * Contract ABI
+   */
+  abi: Abi;
+  /**
+   * Contract address or addresses.
+   *
+   * Accepts an object `{ [chainId]: address }` to support multiple chains.
+   *
+   * @example
+   * '0x314159265dd8dbb310642f98f50c066173c1259b'
+   *
+   * @example
+   * {
+   *   1: '0x314159265dd8dbb310642f98f50c066173c1259b',
+   *   5: '0x112234455c3a32fd11230c42e7bccd4a84e02010',
+   * }
+   */
+  address?:
+    | Address
+    | (requiredChainId extends number
+        ? Record<requiredChainId, Address> & Partial<Record<chainId, Address>>
+        : Record<chainId, Address>)
+    | undefined;
+  /**
+   * Name of contract.
+   */
+  name: string;
+};
+
+export type Contract = Evaluate<
+  ContractConfig & {
+    /** Generated string content */
+    content: string;
+    /** Meta info about contract */
+    meta: {
+      abiName: string;
+      addressName?: string | undefined;
+      configName?: string | undefined;
+    };
+  }
+>;
+
+export type PluginConfig = {
+  abi: Abi;
+  addresses: Record<number, Address>;
+  // allows you to override the root config chain
+  chain?: Chain;
+  // allows you to override the root config rpcUrl
+  rpcUrl?: string;
+  name: string;
+  installConfig?: {
+    initAbiParams: ReturnType<typeof parseAbiParameters> | [];
+    dependencies?: {
+      plugin: PluginConfig;
+      functionId: Hex;
+    }[];
+  };
+};
+
+export type Config = {
+  chain: Chain;
+  rpcUrl: string;
+  outDir?: string;
+  plugins: PluginConfig[];
+};
+
+export function defineConfig(
+  config: MaybeArray<Config> | (() => MaybePromise<MaybeArray<Config>>)
+) {
+  return config;
+}

package/src/errors.ts

@@ -0,0 +1,58 @@
+import { type z } from "zod";
+
+// from https://github.com/wevm/wagmi/blob/main/packages/cli/src/errors.ts
+class ValidationError extends Error {
+  details: Zod.ZodIssue[];
+
+  constructor(
+    message: string,
+    options: {
+      details: Zod.ZodIssue[];
+    }
+  ) {
+    super(message);
+    this.details = options.details;
+  }
+}
+
+// From https://github.com/causaly/zod-validation-error
+export function fromZodError(
+  zError: z.ZodError,
+  {
+    maxIssuesInMessage = 99,
+    issueSeparator = "\n- ",
+    prefixSeparator = "\n- ",
+    prefix = "Validation Error",
+  }: {
+    maxIssuesInMessage?: number;
+    issueSeparator?: string;
+    prefixSeparator?: string;
+    prefix?: string;
+  } = {}
+): ValidationError {
+  function joinPath(arr: Array<string | number>): string {
+    return arr.reduce<string>((acc, value) => {
+      if (typeof value === "number") return `${acc}[${value}]`;
+      const separator = acc === "" ? "" : ".";
+      return acc + separator + value;
+    }, "");
+  }
+
+  const reason = zError.errors
+    // limit max number of issues printed in the reason section
+    .slice(0, maxIssuesInMessage)
+    // format error message
+    .map((issue) => {
+      const { message, path } = issue;
+      if (path.length > 0) return `${message} at \`${joinPath(path)}\``;
+      return message;
+    })
+    // concat as string
+    .join(issueSeparator);
+
+  const message = reason ? [prefix, reason].join(prefixSeparator) : prefix;
+
+  return new ValidationError(message, {
+    details: zError.errors,
+  });
+}

package/src/exports/config.ts

@@ -0,0 +1 @@
+export { defineConfig, type Config, type PluginConfig } from "../config.js";

package/src/exports/index.ts

@@ -0,0 +1,7 @@
+export { defineConfig, type Config, type PluginConfig } from "../config.js";
+
+export * as logger from "../logger.js";
+
+export { loadEnv } from "../utils/loadEnv.js";
+
+export { VERSION } from "../version.js";

package/src/exports/types.ts

@@ -0,0 +1 @@
+export { IPluginAbi } from "../IPlugin.js";

package/src/logger.ts

@@ -0,0 +1,36 @@
+import ora from "ora";
+import pc from "picocolors";
+import { format as utilFormat } from "util";
+
+function format(args: any[]) {
+  return utilFormat(...args)
+    .split("\n")
+    .join("\n");
+}
+
+export function success(...args: any[]) {
+  console.log(pc.green(format(args)));
+}
+
+export function info(...args: any[]) {
+  console.info(pc.blue(format(args)));
+}
+
+export function log(...args: any[]) {
+  console.log(pc.white(format(args)));
+}
+
+export function warn(...args: any[]) {
+  console.warn(pc.yellow(format(args)));
+}
+
+export function error(...args: any[]) {
+  console.error(pc.red(format(args)));
+}
+
+export function spinner() {
+  return ora({
+    color: "yellow",
+    spinner: "dots",
+  });
+}

package/src/types.ts

@@ -0,0 +1,11 @@
+// Source: https://github.com/wevm/wagmi/blob/main/packages/cli/src/types.ts
+export type Evaluate<type> = { [key in keyof type]: type[key] } & unknown;
+
+export type MaybeArray<T> = T | T[];
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export type RequiredBy<TType, TKeys extends keyof TType> = Required<
+  Pick<TType, TKeys>
+> &
+  Omit<TType, TKeys>;

package/src/utils/findConfig.ts

@@ -0,0 +1,37 @@
+// source: https://github.com/wevm/wagmi/blob/main/packages/cli/src/utils/findConfig.ts
+import { findUp } from "find-up";
+import { default as fs } from "fs-extra";
+import { resolve } from "pathe";
+
+// Do not reorder
+// In order of preference files are checked
+const configFiles = [
+  "plugingen.config.ts",
+  "plugingen.config.js",
+  "plugingen.config.mjs",
+  "plugingen.config.mts",
+];
+
+type FindConfigParameters = {
+  /** Config file name */
+  config?: string;
+  /** Config file directory */
+  root?: string;
+};
+
+/**
+ * Resolves path to plugingen CLI config file.
+ *
+ * @param parameters - optional override parameters for finding the config object
+ * @returns the path to the config file
+ */
+export async function findConfig(parameters: FindConfigParameters = {}) {
+  const { config, root } = parameters;
+  const rootDir = resolve(root || process.cwd());
+  if (config) {
+    const path = resolve(rootDir, config);
+    if (fs.pathExistsSync(path)) return path;
+    return;
+  }
+  return findUp(configFiles, { cwd: rootDir });
+}

package/src/utils/format.ts

@@ -0,0 +1,11 @@
+// https://github.com/wevm/wagmi/blob/main/packages/cli/src/utils/format.ts
+import prettier from "prettier";
+
+export async function format(content: string) {
+  const config = await prettier.resolveConfig(process.cwd());
+  return prettier.format(content, {
+    parser: "typescript",
+    ...config,
+    plugins: [],
+  });
+}

package/src/utils/isUsingTypescript.ts

@@ -0,0 +1,22 @@
+// https://github.com/wevm/wagmi/blob/main/packages/cli/src/utils/getIsUsingTypeScript.ts
+import { findUp } from "find-up";
+
+export async function getIsUsingTypeScript() {
+  try {
+    const cwd = process.cwd();
+    const tsconfig = await findUp("tsconfig.json", { cwd });
+    if (tsconfig) return true;
+
+    const plugingenConfig = await findUp(
+      ["plugingenConfig.config.ts", "plugingenConfig.config.mts"],
+      {
+        cwd,
+      }
+    );
+    if (plugingenConfig) return true;
+
+    return false;
+  } catch {
+    return false;
+  }
+}

package/src/utils/loadEnv.ts

@@ -0,0 +1,91 @@
+// https://github.com/wevm/wagmi/blob/main/packages/cli/src/utils/loadEnv.ts
+import { parse } from "dotenv";
+import { expand } from "dotenv-expand";
+
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/env.ts#L7
+export function loadEnv(
+  config: {
+    mode?: string;
+    envDir?: string;
+  } = {}
+): Record<string, string> {
+  const mode = config.mode;
+  if (mode === "local") {
+    throw new Error(
+      `"local" cannot be used as a mode name because it conflicts with the .local postfix for .env files.`
+    );
+  }
+
+  const envFiles = [
+    /** default file */ ".env",
+    /** local file */ ".env.local",
+    ...(mode
+      ? [
+          /** mode file */ `.env.${mode}`,
+          /** mode local file */ `.env.${mode}.local`,
+        ]
+      : []),
+  ];
+
+  const envDir = config.envDir ?? process.cwd();
+  const parsed = Object.fromEntries(
+    envFiles.flatMap((file) => {
+      const path = lookupFile(envDir, [file], {
+        pathOnly: true,
+        rootDir: envDir,
+      });
+      if (!path) return [];
+      return Object.entries(parse(readFileSync(path)));
+    })
+  );
+
+  try {
+    // let environment variables use each other
+    expand({ parsed });
+  } catch (error) {
+    // custom error handling until https://github.com/motdotla/dotenv-expand/issues/65 is fixed upstream
+    // check for message "TypeError: Cannot read properties of undefined (reading 'split')"
+    if ((error as Error).message.includes("split")) {
+      throw new Error(
+        "dotenv-expand failed to expand env vars. Maybe you need to escape `$`?"
+      );
+    }
+    throw error;
+  }
+
+  return parsed;
+}
+
+function lookupFile(
+  dir: string,
+  formats: string[],
+  options?: {
+    pathOnly?: boolean;
+    rootDir?: string;
+    predicate?: (file: string) => boolean;
+  }
+): string | undefined {
+  for (const format of formats) {
+    const fullPath = join(dir, format);
+    if (existsSync(fullPath) && statSync(fullPath).isFile()) {
+      const result = options?.pathOnly
+        ? fullPath
+        : readFileSync(fullPath, "utf-8");
+      if (!options?.predicate || options.predicate(result)) {
+        return result;
+      }
+    }
+  }
+
+  const parentDir = dirname(dir);
+  if (
+    parentDir !== dir &&
+    (!options?.rootDir || parentDir.startsWith(options?.rootDir))
+  )
+    return lookupFile(parentDir, formats, options);
+
+  return undefined;
+}