@account-kit/plugingen 4.0.0-alpha.0

package/dist/esm/utils/loadEnv.js

@@ -0,0 +1,59 @@
+import { parse } from "dotenv";
+import { expand } from "dotenv-expand";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+export function loadEnv(config = {}) {
+    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 = [
+        ".env",
+        ".env.local",
+        ...(mode
+            ? [
+                `.env.${mode}`,
+                `.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 {
+        expand({ parsed });
+    }
+    catch (error) {
+        if (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, formats, options) {
+    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;
+}
+//# sourceMappingURL=loadEnv.js.map

package/dist/esm/utils/loadEnv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadEnv.js","sourceRoot":"","sources":["../../../src/utils/loadEnv.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAG1C,MAAM,UAAU,OAAO,CACrB,SAGI,EAAE;IAEN,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;IACzB,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CACb,oGAAoG,CACrG,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG;QACK,MAAM;QACR,YAAY;QAC9B,GAAG,CAAC,IAAI;YACN,CAAC,CAAC;gBACmB,QAAQ,IAAI,EAAE;gBACR,QAAQ,IAAI,QAAQ;aAC5C;YACH,CAAC,CAAC,EAAE,CAAC;KACR,CAAC;IAEF,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAC9C,MAAM,MAAM,GAAG,MAAM,CAAC,WAAW,CAC/B,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE;YACtC,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,MAAM;SAChB,CAAC,CAAC;QACH,IAAI,CAAC,IAAI;YAAE,OAAO,EAAE,CAAC;QACrB,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC,CAAC,CACH,CAAC;IAEF,IAAI,CAAC;QAEH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACrB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAGf,IAAK,KAAe,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC/C,MAAM,IAAI,KAAK,CACb,wEAAwE,CACzE,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,UAAU,CACjB,GAAW,EACX,OAAiB,EACjB,OAIC;IAED,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QACnC,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC;YACxD,MAAM,MAAM,GAAG,OAAO,EAAE,QAAQ;gBAC9B,CAAC,CAAC,QAAQ;gBACV,CAAC,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YACpC,IAAI,CAAC,OAAO,EAAE,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;gBACrD,OAAO,MAAM,CAAC;YAChB,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/B,IACE,SAAS,KAAK,GAAG;QACjB,CAAC,CAAC,OAAO,EAAE,OAAO,IAAI,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAE7D,OAAO,UAAU,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAEjD,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["// https://github.com/wevm/wagmi/blob/main/packages/cli/src/utils/loadEnv.ts\nimport { parse } from \"dotenv\";\nimport { expand } from \"dotenv-expand\";\n\nimport { existsSync, readFileSync, statSync } from \"node:fs\";\nimport { dirname, join } from \"node:path\";\n\n// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/env.ts#L7\nexport function loadEnv(\n  config: {\n    mode?: string;\n    envDir?: string;\n  } = {}\n): Record<string, string> {\n  const mode = config.mode;\n  if (mode === \"local\") {\n    throw new Error(\n      `\"local\" cannot be used as a mode name because it conflicts with the .local postfix for .env files.`\n    );\n  }\n\n  const envFiles = [\n    /** default file */ \".env\",\n    /** local file */ \".env.local\",\n    ...(mode\n      ? [\n          /** mode file */ `.env.${mode}`,\n          /** mode local file */ `.env.${mode}.local`,\n        ]\n      : []),\n  ];\n\n  const envDir = config.envDir ?? process.cwd();\n  const parsed = Object.fromEntries(\n    envFiles.flatMap((file) => {\n      const path = lookupFile(envDir, [file], {\n        pathOnly: true,\n        rootDir: envDir,\n      });\n      if (!path) return [];\n      return Object.entries(parse(readFileSync(path)));\n    })\n  );\n\n  try {\n    // let environment variables use each other\n    expand({ parsed });\n  } catch (error) {\n    // custom error handling until https://github.com/motdotla/dotenv-expand/issues/65 is fixed upstream\n    // check for message \"TypeError: Cannot read properties of undefined (reading 'split')\"\n    if ((error as Error).message.includes(\"split\")) {\n      throw new Error(\n        \"dotenv-expand failed to expand env vars. Maybe you need to escape `$`?\"\n      );\n    }\n    throw error;\n  }\n\n  return parsed;\n}\n\nfunction lookupFile(\n  dir: string,\n  formats: string[],\n  options?: {\n    pathOnly?: boolean;\n    rootDir?: string;\n    predicate?: (file: string) => boolean;\n  }\n): string | undefined {\n  for (const format of formats) {\n    const fullPath = join(dir, format);\n    if (existsSync(fullPath) && statSync(fullPath).isFile()) {\n      const result = options?.pathOnly\n        ? fullPath\n        : readFileSync(fullPath, \"utf-8\");\n      if (!options?.predicate || options.predicate(result)) {\n        return result;\n      }\n    }\n  }\n\n  const parentDir = dirname(dir);\n  if (\n    parentDir !== dir &&\n    (!options?.rootDir || parentDir.startsWith(options?.rootDir))\n  )\n    return lookupFile(parentDir, formats, options);\n\n  return undefined;\n}\n"]}

package/dist/esm/utils/resolveConfig.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from "../config";
+import type { MaybeArray } from "../types";
+type ResolveConfigParameters = {
+    configPath: string;
+};
+export declare function resolveConfig(parameters: ResolveConfigParameters): Promise<MaybeArray<Config>>;
+export {};

package/dist/esm/utils/resolveConfig.js

@@ -0,0 +1,12 @@
+import { bundleRequire } from "bundle-require";
+export async function resolveConfig(parameters) {
+    const { configPath } = parameters;
+    const res = await bundleRequire({ filepath: configPath });
+    let config = res.mod.default;
+    if (config.default)
+        config = config.default;
+    if (typeof config !== "function")
+        return config;
+    return await config();
+}
+//# sourceMappingURL=resolveConfig.js.map

package/dist/esm/utils/resolveConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveConfig.js","sourceRoot":"","sources":["../../../src/utils/resolveConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAe/C,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,UAAmC;IAEnC,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC;IAClC,MAAM,GAAG,GAAG,MAAM,aAAa,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;IAC1D,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC;IAC7B,IAAI,MAAM,CAAC,OAAO;QAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC;IAC5C,IAAI,OAAO,MAAM,KAAK,UAAU;QAAE,OAAO,MAAM,CAAC;IAChD,OAAO,MAAM,MAAM,EAAE,CAAC;AACxB,CAAC","sourcesContent":["import { bundleRequire } from \"bundle-require\";\nimport type { Config } from \"../config\";\nimport type { MaybeArray } from \"../types\";\n\ntype ResolveConfigParameters = {\n  /** Path to config file */\n  configPath: string;\n};\n\n/**\n * Bundles and returns config object from path.\n *\n * @param parameters - Parameters to resolve config\n * @returns an array of the config objects\n */\nexport async function resolveConfig(\n  parameters: ResolveConfigParameters\n): Promise<MaybeArray<Config>> {\n  const { configPath } = parameters;\n  const res = await bundleRequire({ filepath: configPath });\n  let config = res.mod.default;\n  if (config.default) config = config.default;\n  if (typeof config !== \"function\") return config;\n  return await config();\n}\n"]}

package/dist/esm/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "4.0.0-alpha.0";

package/dist/esm/version.js

@@ -0,0 +1,2 @@
+export const VERSION = "4.0.0-alpha.0";
+//# sourceMappingURL=version.js.map

package/dist/esm/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,OAAO,GAAG,eAAe,CAAC","sourcesContent":["// This file is autogenerated by inject-version.ts. Any changes will be\n// overwritten on commit!\nexport const VERSION = \"4.0.0-alpha.0\";\n"]}

package/dist/types/IPlugin.d.ts

@@ -0,0 +1,475 @@
+export declare const IPluginAbi: readonly [{
+    readonly type: "function";
+    readonly name: "onInstall";
+    readonly inputs: readonly [{
+        readonly name: "data";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "onUninstall";
+    readonly inputs: readonly [{
+        readonly name: "data";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "pluginManifest";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct PluginManifest";
+        readonly components: readonly [{
+            readonly name: "interfaceIds";
+            readonly type: "bytes4[]";
+            readonly internalType: "bytes4[]";
+        }, {
+            readonly name: "dependencyInterfaceIds";
+            readonly type: "bytes4[]";
+            readonly internalType: "bytes4[]";
+        }, {
+            readonly name: "executionFunctions";
+            readonly type: "bytes4[]";
+            readonly internalType: "bytes4[]";
+        }, {
+            readonly name: "permittedExecutionSelectors";
+            readonly type: "bytes4[]";
+            readonly internalType: "bytes4[]";
+        }, {
+            readonly name: "permitAnyExternalAddress";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }, {
+            readonly name: "canSpendNativeToken";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }, {
+            readonly name: "permittedExternalCalls";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ManifestExternalCallPermission[]";
+            readonly components: readonly [{
+                readonly name: "externalAddress";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "permitAnySelector";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "selectors";
+                readonly type: "bytes4[]";
+                readonly internalType: "bytes4[]";
+            }];
+        }, {
+            readonly name: "userOpValidationFunctions";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ManifestAssociatedFunction[]";
+            readonly components: readonly [{
+                readonly name: "executionSelector";
+                readonly type: "bytes4";
+                readonly internalType: "bytes4";
+            }, {
+                readonly name: "associatedFunction";
+                readonly type: "tuple";
+                readonly internalType: "struct ManifestFunction";
+                readonly components: readonly [{
+                    readonly name: "functionType";
+                    readonly type: "uint8";
+                    readonly internalType: "enum ManifestAssociatedFunctionType";
+                }, {
+                    readonly name: "functionId";
+                    readonly type: "uint8";
+                    readonly internalType: "uint8";
+                }, {
+                    readonly name: "dependencyIndex";
+                    readonly type: "uint256";
+                    readonly internalType: "uint256";
+                }];
+            }];
+        }, {
+            readonly name: "runtimeValidationFunctions";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ManifestAssociatedFunction[]";
+            readonly components: readonly [{
+                readonly name: "executionSelector";
+                readonly type: "bytes4";
+                readonly internalType: "bytes4";
+            }, {
+                readonly name: "associatedFunction";
+                readonly type: "tuple";
+                readonly internalType: "struct ManifestFunction";
+                readonly components: readonly [{
+                    readonly name: "functionType";
+                    readonly type: "uint8";
+                    readonly internalType: "enum ManifestAssociatedFunctionType";
+                }, {
+                    readonly name: "functionId";
+                    readonly type: "uint8";
+                    readonly internalType: "uint8";
+                }, {
+                    readonly name: "dependencyIndex";
+                    readonly type: "uint256";
+                    readonly internalType: "uint256";
+                }];
+            }];
+        }, {
+            readonly name: "preUserOpValidationHooks";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ManifestAssociatedFunction[]";
+            readonly components: readonly [{
+                readonly name: "executionSelector";
+                readonly type: "bytes4";
+                readonly internalType: "bytes4";
+            }, {
+                readonly name: "associatedFunction";
+                readonly type: "tuple";
+                readonly internalType: "struct ManifestFunction";
+                readonly components: readonly [{
+                    readonly name: "functionType";
+                    readonly type: "uint8";
+                    readonly internalType: "enum ManifestAssociatedFunctionType";
+                }, {
+                    readonly name: "functionId";
+                    readonly type: "uint8";
+                    readonly internalType: "uint8";
+                }, {
+                    readonly name: "dependencyIndex";
+                    readonly type: "uint256";
+                    readonly internalType: "uint256";
+                }];
+            }];
+        }, {
+            readonly name: "preRuntimeValidationHooks";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ManifestAssociatedFunction[]";
+            readonly components: readonly [{
+                readonly name: "executionSelector";
+                readonly type: "bytes4";
+                readonly internalType: "bytes4";
+            }, {
+                readonly name: "associatedFunction";
+                readonly type: "tuple";
+                readonly internalType: "struct ManifestFunction";
+                readonly components: readonly [{
+                    readonly name: "functionType";
+                    readonly type: "uint8";
+                    readonly internalType: "enum ManifestAssociatedFunctionType";
+                }, {
+                    readonly name: "functionId";
+                    readonly type: "uint8";
+                    readonly internalType: "uint8";
+                }, {
+                    readonly name: "dependencyIndex";
+                    readonly type: "uint256";
+                    readonly internalType: "uint256";
+                }];
+            }];
+        }, {
+            readonly name: "executionHooks";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ManifestExecutionHook[]";
+            readonly components: readonly [{
+                readonly name: "executionSelector";
+                readonly type: "bytes4";
+                readonly internalType: "bytes4";
+            }, {
+                readonly name: "preExecHook";
+                readonly type: "tuple";
+                readonly internalType: "struct ManifestFunction";
+                readonly components: readonly [{
+                    readonly name: "functionType";
+                    readonly type: "uint8";
+                    readonly internalType: "enum ManifestAssociatedFunctionType";
+                }, {
+                    readonly name: "functionId";
+                    readonly type: "uint8";
+                    readonly internalType: "uint8";
+                }, {
+                    readonly name: "dependencyIndex";
+                    readonly type: "uint256";
+                    readonly internalType: "uint256";
+                }];
+            }, {
+                readonly name: "postExecHook";
+                readonly type: "tuple";
+                readonly internalType: "struct ManifestFunction";
+                readonly components: readonly [{
+                    readonly name: "functionType";
+                    readonly type: "uint8";
+                    readonly internalType: "enum ManifestAssociatedFunctionType";
+                }, {
+                    readonly name: "functionId";
+                    readonly type: "uint8";
+                    readonly internalType: "uint8";
+                }, {
+                    readonly name: "dependencyIndex";
+                    readonly type: "uint256";
+                    readonly internalType: "uint256";
+                }];
+            }];
+        }];
+    }];
+    readonly stateMutability: "pure";
+}, {
+    readonly type: "function";
+    readonly name: "pluginMetadata";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct PluginMetadata";
+        readonly components: readonly [{
+            readonly name: "name";
+            readonly type: "string";
+            readonly internalType: "string";
+        }, {
+            readonly name: "version";
+            readonly type: "string";
+            readonly internalType: "string";
+        }, {
+            readonly name: "author";
+            readonly type: "string";
+            readonly internalType: "string";
+        }, {
+            readonly name: "permissionDescriptors";
+            readonly type: "tuple[]";
+            readonly internalType: "struct SelectorPermission[]";
+            readonly components: readonly [{
+                readonly name: "functionSelector";
+                readonly type: "bytes4";
+                readonly internalType: "bytes4";
+            }, {
+                readonly name: "permissionDescription";
+                readonly type: "string";
+                readonly internalType: "string";
+            }];
+        }];
+    }];
+    readonly stateMutability: "pure";
+}, {
+    readonly type: "function";
+    readonly name: "postExecutionHook";
+    readonly inputs: readonly [{
+        readonly name: "functionId";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "preExecHookData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "preExecutionHook";
+    readonly inputs: readonly [{
+        readonly name: "functionId";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "sender";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "preRuntimeValidationHook";
+    readonly inputs: readonly [{
+        readonly name: "functionId";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "sender";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "preUserOpValidationHook";
+    readonly inputs: readonly [{
+        readonly name: "functionId";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "userOp";
+        readonly type: "tuple";
+        readonly internalType: "struct UserOperation";
+        readonly components: readonly [{
+            readonly name: "sender";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "initCode";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "callGasLimit";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "verificationGasLimit";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "preVerificationGas";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxFeePerGas";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxPriorityFeePerGas";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "paymasterAndData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "signature";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }, {
+        readonly name: "userOpHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "runtimeValidationFunction";
+    readonly inputs: readonly [{
+        readonly name: "functionId";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "sender";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "userOpValidationFunction";
+    readonly inputs: readonly [{
+        readonly name: "functionId";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "userOp";
+        readonly type: "tuple";
+        readonly internalType: "struct UserOperation";
+        readonly components: readonly [{
+            readonly name: "sender";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "initCode";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "callGasLimit";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "verificationGasLimit";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "preVerificationGas";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxFeePerGas";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxPriorityFeePerGas";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "paymasterAndData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "signature";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }, {
+        readonly name: "userOpHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}];
+//# sourceMappingURL=IPlugin.d.ts.map

package/dist/types/IPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IPlugin.d.ts","sourceRoot":"","sources":["../../src/IPlugin.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2Yb,CAAC"}

package/dist/types/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/types/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":""}

package/dist/types/commands/generate/index.d.ts

@@ -0,0 +1,17 @@
+import z from "zod";
+declare const GenerateSchema: z.ZodObject<{
+    /** Path to config file */
+    config: z.ZodOptional<z.ZodString>;
+    /** Directory to search for config file */
+    root: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    config?: string | undefined;
+    root?: string | undefined;
+}, {
+    config?: string | undefined;
+    root?: string | undefined;
+}>;
+export type GenerateOptions = z.infer<typeof GenerateSchema>;
+export declare function generate(options?: GenerateOptions): Promise<void>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/commands/generate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/generate/index.ts"],"names":[],"mappings":"AAaA,OAAO,CAAC,MAAM,KAAK,CAAC;AAepB,QAAA,MAAM,cAAc;IAClB,0BAA0B;;IAE1B,0CAA0C;;;;;;;;EAE1C,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE7D,wBAAsB,QAAQ,CAAC,OAAO,GAAE,eAAoB,iBA4F3D"}

package/dist/types/commands/generate/phases/contract-abi-gen.d.ts

@@ -0,0 +1,3 @@
+import type { Phase } from "../types";
+export declare const ContractAbiGenPhase: Phase;
+//# sourceMappingURL=contract-abi-gen.d.ts.map

package/dist/types/commands/generate/phases/contract-abi-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-abi-gen.d.ts","sourceRoot":"","sources":["../../../../../src/commands/generate/phases/contract-abi-gen.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC,eAAO,MAAM,mBAAmB,EAAE,KAQjC,CAAC"}

package/dist/types/commands/generate/phases/contract-addresses-gen.d.ts

@@ -0,0 +1,3 @@
+import type { Phase } from "../types";
+export declare const ContractAddressesGenPhase: Phase;
+//# sourceMappingURL=contract-addresses-gen.d.ts.map

package/dist/types/commands/generate/phases/contract-addresses-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-addresses-gen.d.ts","sourceRoot":"","sources":["../../../../../src/commands/generate/phases/contract-addresses-gen.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC,eAAO,MAAM,yBAAyB,EAAE,KAavC,CAAC"}

package/dist/types/commands/generate/phases/execution-abi-gen.d.ts

@@ -0,0 +1,3 @@
+import type { Phase } from "../types";
+export declare const ExecutionAbiGenPhase: Phase;
+//# sourceMappingURL=execution-abi-gen.d.ts.map

package/dist/types/commands/generate/phases/execution-abi-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-abi-gen.d.ts","sourceRoot":"","sources":["../../../../../src/commands/generate/phases/execution-abi-gen.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAGtC,eAAO,MAAM,oBAAoB,EAAE,KAelC,CAAC"}

package/dist/types/commands/generate/phases/plugin-actions/index.d.ts

@@ -0,0 +1,3 @@
+import type { Phase } from "../../types";
+export declare const PluginActionsGenPhase: Phase;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/commands/generate/phases/plugin-actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/commands/generate/phases/plugin-actions/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAKzC,eAAO,MAAM,qBAAqB,EAAE,KA8InC,CAAC"}

package/dist/types/commands/generate/phases/plugin-actions/management-actions.d.ts

@@ -0,0 +1,3 @@
+import type { Phase } from "../../types";
+export declare const ManagementActionsGenPhase: Phase;
+//# sourceMappingURL=management-actions.d.ts.map

package/dist/types/commands/generate/phases/plugin-actions/management-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"management-actions.d.ts","sourceRoot":"","sources":["../../../../../../src/commands/generate/phases/plugin-actions/management-actions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAc,MAAM,aAAa,CAAC;AAErD,eAAO,MAAM,yBAAyB,EAAE,KA+FvC,CAAC"}