@latticexyz/cli 2.0.12-main-9be2bb86 → 2.0.12-main-96e7bf43

package/src/deploy/resolveConfig.ts

@@ -1,104 +0,0 @@
-import path from "path";
-import { resolveWorldConfig } from "@latticexyz/world/internal";
-import { Config, ConfigInput, Library, System, WorldFunction } from "./common";
-import { resourceToHex } from "@latticexyz/common";
-import { Hex, toFunctionSelector, toFunctionSignature } from "viem";
-import { getExistingContracts } from "../utils/getExistingContracts";
-import { getContractData } from "../utils/getContractData";
-import { configToTables } from "./configToTables";
-import { groupBy } from "@latticexyz/common/utils";
-import { findLibraries } from "./findLibraries";
-import { createPrepareDeploy } from "./createPrepareDeploy";
-
-// TODO: this should be replaced by https://github.com/latticexyz/mud/issues/1668
-
-export function resolveConfig<config extends ConfigInput>({
-  config,
-  forgeSourceDir,
-  forgeOutDir,
-}: {
-  config: config;
-  forgeSourceDir: string;
-  forgeOutDir: string;
-}): Config<config> {
-  const libraries = findLibraries(forgeOutDir).map((library): Library => {
-    // foundry/solc flattens artifacts, so we just use the path basename
-    const contractData = getContractData(path.basename(library.path), library.name, forgeOutDir);
-    return {
-      path: library.path,
-      name: library.name,
-      abi: contractData.abi,
-      prepareDeploy: createPrepareDeploy(contractData.bytecode, contractData.placeholders),
-      deployedBytecodeSize: contractData.deployedBytecodeSize,
-    };
-  });
-
-  const tables = configToTables(config);
-
-  // TODO: should the config parser/loader help with resolving systems?
-  const contractNames = getExistingContracts(forgeSourceDir).map(({ basename }) => basename);
-  const resolvedConfig = resolveWorldConfig(config, contractNames);
-  const baseSystemContractData = getContractData("System.sol", "System", forgeOutDir);
-  const baseSystemFunctions = baseSystemContractData.abi
-    .filter((item): item is typeof item & { type: "function" } => item.type === "function")
-    .map(toFunctionSignature);
-
-  const systems = Object.entries(resolvedConfig.systems).map(([systemName, system]): System => {
-    const namespace = config.namespace;
-    const name = system.name;
-    const systemId = resourceToHex({ type: "system", namespace, name });
-    const contractData = getContractData(`${systemName}.sol`, systemName, forgeOutDir);
-
-    const systemFunctions = contractData.abi
-      .filter((item): item is typeof item & { type: "function" } => item.type === "function")
-      .map(toFunctionSignature)
-      .filter((sig) => !baseSystemFunctions.includes(sig))
-      .map((sig): WorldFunction => {
-        // TODO: figure out how to not duplicate contract behavior (https://github.com/latticexyz/mud/issues/1708)
-        const worldSignature = namespace === "" ? sig : `${namespace}__${sig}`;
-        return {
-          signature: worldSignature,
-          selector: toFunctionSelector(worldSignature),
-          systemId,
-          systemFunctionSignature: sig,
-          systemFunctionSelector: toFunctionSelector(sig),
-        };
-      });
-
-    return {
-      namespace,
-      name,
-      systemId,
-      allowAll: system.openAccess,
-      allowedAddresses: system.accessListAddresses as Hex[],
-      allowedSystemIds: system.accessListSystems.map((name) =>
-        resourceToHex({ type: "system", namespace, name: resolvedConfig.systems[name].name }),
-      ),
-      prepareDeploy: createPrepareDeploy(contractData.bytecode, contractData.placeholders),
-      deployedBytecodeSize: contractData.deployedBytecodeSize,
-      abi: contractData.abi,
-      functions: systemFunctions,
-    };
-  });
-
-  // Check for overlapping system IDs (since names get truncated when turning into IDs)
-  // TODO: move this into the world config resolve step once it resolves system IDs
-  const systemsById = groupBy(systems, (system) => system.systemId);
-  const overlappingSystems = Array.from(systemsById.values())
-    .filter((matches) => matches.length > 1)
-    .flat();
-  if (overlappingSystems.length) {
-    const names = overlappingSystems.map((system) => system.name);
-    throw new Error(
-      `Found systems with overlapping system ID: ${names.join(
-        ", ",
-      )}.\n\nSystem IDs are generated from the first 16 bytes of the name, so you may need to rename them to avoid the overlap.`,
-    );
-  }
-
-  return {
-    tables,
-    systems,
-    libraries,
-  };
-}

package/src/index.ts

@@ -1 +0,0 @@
-// nothing to export

package/src/modules.d.ts

@@ -1,11 +0,0 @@
-// adding .js to minimal would break clients down the line because it probably won't get a synthetic default import
-/* eslint-disable @typescript-eslint/no-explicit-any */
-declare module "protobufjs/minimal" {
-  export const configure: any;
-  export const util: any;
-  export const Reader: any;
-  export type Reader = any;
-  export const Writer: any;
-  export type Writer = any;
-}
-declare module "rollup-plugin-preserve-shebang";

package/src/mud.ts

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-
-// Load .env file into process.env
-import * as dotenv from "dotenv";
-dotenv.config();
-
-async function run() {
-  // Import everything else async so they can pick up env vars in .env
-  const { default: yargs } = await import("yargs");
-  const { default: chalk } = await import("chalk");
-  const { hideBin } = await import("yargs/helpers");
-  const { logError } = await import("./utils/errors");
-  const { commands } = await import("./commands");
-
-  yargs(hideBin(process.argv))
-    // Explicit name to display in help (by default it's the entry file, which may not be "mud" for e.g. ts-node)
-    .scriptName("mud")
-    // Use the commands directory to scaffold
-    // command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    .command(commands as any)
-    // Enable strict mode.
-    .strict()
-    // Custom error handler
-    .fail((msg, err) => {
-      console.error(chalk.red(msg));
-      if (msg.includes("Missing required argument")) {
-        console.log(
-          chalk.yellow(`Run 'pnpm mud ${process.argv[2]} --help' for a list of available and required arguments.`),
-        );
-      }
-      console.log("");
-      // Even though `.fail` type says we should get an `Error`, this can sometimes be undefined
-      if (err != null) {
-        logError(err);
-        console.log("");
-      }
-
-      process.exit(1);
-    })
-    // Useful aliases.
-    .alias({ h: "help" }).argv;
-}
-
-run();

package/src/mudPackages.ts

@@ -1,24 +0,0 @@
-import { ZodError, z } from "zod";
-import { MudPackages } from "./common";
-
-const envSchema = z.object({
-  MUD_PACKAGES: z.string().transform((value) => JSON.parse(value) as MudPackages),
-});
-
-function parseEnv(): z.infer<typeof envSchema> {
-  try {
-    return envSchema.parse({
-      // tsup replaces the env vars with their values at compile time
-      MUD_PACKAGES: process.env.MUD_PACKAGES,
-    });
-  } catch (error) {
-    if (error instanceof ZodError) {
-      const { ...invalidEnvVars } = error.format();
-      console.error(`\nMissing or invalid environment variables:\n\n  ${Object.keys(invalidEnvVars).join("\n  ")}\n`);
-      process.exit(1);
-    }
-    throw error;
-  }
-}
-
-export const mudPackages = parseEnv().MUD_PACKAGES;

package/src/runDeploy.ts

@@ -1,181 +0,0 @@
-import path from "node:path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { InferredOptionTypes, Options } from "yargs";
-import { deploy } from "./deploy/deploy";
-import { createWalletClient, http, Hex, isHex } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-import { loadConfig } from "@latticexyz/config/node";
-import { World as WorldConfig } from "@latticexyz/world";
-import { worldToV1 } from "@latticexyz/world/config/v2";
-import { getOutDirectory, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
-import chalk from "chalk";
-import { MUDError } from "@latticexyz/common/errors";
-import { resolveConfig } from "./deploy/resolveConfig";
-import { getChainId } from "viem/actions";
-import { postDeploy } from "./utils/postDeploy";
-import { WorldDeploy } from "./deploy/common";
-import { build } from "./build";
-import { kmsKeyToAccount } from "@latticexyz/common/kms";
-import { configToModules } from "./deploy/configToModules";
-
-export const deployOptions = {
-  configPath: { type: "string", desc: "Path to the MUD config file" },
-  printConfig: { type: "boolean", desc: "Print the resolved config" },
-  profile: { type: "string", desc: "The foundry profile to use" },
-  saveDeployment: { type: "boolean", desc: "Save the deployment info to a file", default: true },
-  rpc: { type: "string", desc: "The RPC URL to use. Defaults to the RPC url from the local foundry.toml" },
-  rpcBatch: {
-    type: "boolean",
-    desc: "Enable batch processing of RPC requests in viem client (defaults to batch size of 100 and wait of 1s)",
-  },
-  deployerAddress: {
-    type: "string",
-    desc: "Deploy using an existing deterministic deployer (https://github.com/Arachnid/deterministic-deployment-proxy)",
-  },
-  worldAddress: { type: "string", desc: "Deploy to an existing World at the given address" },
-  srcDir: { type: "string", desc: "Source directory. Defaults to foundry src directory." },
-  skipBuild: { type: "boolean", desc: "Skip rebuilding the contracts before deploying" },
-  alwaysRunPostDeploy: {
-    type: "boolean",
-    desc: "Always run PostDeploy.s.sol after each deploy (including during upgrades). By default, PostDeploy.s.sol is only run once after a new world is deployed.",
-  },
-  forgeScriptOptions: { type: "string", description: "Options to pass to forge script PostDeploy.s.sol" },
-  salt: {
-    type: "string",
-    desc: "The deployment salt to use. Defaults to a random salt.",
-  },
-  kms: {
-    type: "boolean",
-    desc: "Deploy the World with an AWS KMS key instead of local private key.",
-  },
-} as const satisfies Record<string, Options>;
-
-export type DeployOptions = InferredOptionTypes<typeof deployOptions>;
-
-/**
- * Given some CLI arguments, finds and resolves a MUD config, foundry profile, and runs a deploy.
- * This is used by the deploy, test, and dev-contracts CLI commands.
- */
-export async function runDeploy(opts: DeployOptions): Promise<WorldDeploy> {
-  const salt = opts.salt;
-  if (salt != null && !isHex(salt)) {
-    throw new MUDError("Expected hex string for salt");
-  }
-
-  const profile = opts.profile ?? process.env.FOUNDRY_PROFILE;
-
-  const configV2 = (await loadConfig(opts.configPath)) as WorldConfig;
-  const config = worldToV1(configV2);
-  if (opts.printConfig) {
-    console.log(chalk.green("\nResolved config:\n"), JSON.stringify(config, null, 2));
-  }
-
-  const srcDir = opts.srcDir ?? (await getSrcDirectory(profile));
-  const outDir = await getOutDirectory(profile);
-
-  const rpc = opts.rpc ?? (await getRpcUrl(profile));
-  console.log(
-    chalk.bgBlue(
-      chalk.whiteBright(`\n Deploying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} \n`),
-    ),
-  );
-
-  // Run build
-  if (!opts.skipBuild) {
-    await build({ config: configV2, srcDir, foundryProfile: profile });
-  }
-
-  const resolvedConfig = resolveConfig({ config, forgeSourceDir: srcDir, forgeOutDir: outDir });
-  const modules = await configToModules(configV2, outDir);
-
-  const account = await (async () => {
-    if (opts.kms) {
-      const keyId = process.env.AWS_KMS_KEY_ID;
-      if (!keyId) {
-        throw new MUDError(
-          "Missing `AWS_KMS_KEY_ID` environment variable. This is required when using with `--kms` option.",
-        );
-      }
-
-      return await kmsKeyToAccount({ keyId });
-    } else {
-      const privateKey = process.env.PRIVATE_KEY;
-      if (!privateKey) {
-        throw new MUDError(
-          `Missing PRIVATE_KEY environment variable.
-  Run 'echo "PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" > .env'
-  in your contracts directory to use the default anvil private key.`,
-        );
-      }
-
-      return privateKeyToAccount(privateKey as Hex);
-    }
-  })();
-
-  const client = createWalletClient({
-    transport: http(rpc, {
-      batch: opts.rpcBatch
-        ? {
-            batchSize: 100,
-            wait: 1000,
-          }
-        : undefined,
-    }),
-    account,
-  });
-
-  console.log("Deploying from", client.account.address);
-
-  const startTime = Date.now();
-  const worldDeploy = await deploy({
-    deployerAddress: opts.deployerAddress as Hex | undefined,
-    salt,
-    worldAddress: opts.worldAddress as Hex | undefined,
-    client,
-    config: resolvedConfig,
-    modules,
-    withWorldProxy: configV2.deploy.upgradeableWorldImplementation,
-  });
-  if (opts.worldAddress == null || opts.alwaysRunPostDeploy) {
-    await postDeploy(
-      config.postDeployScript,
-      worldDeploy.address,
-      rpc,
-      profile,
-      opts.forgeScriptOptions,
-      opts.kms ? true : false,
-    );
-  }
-  console.log(chalk.green("Deployment completed in", (Date.now() - startTime) / 1000, "seconds"));
-
-  const deploymentInfo = {
-    worldAddress: worldDeploy.address,
-    blockNumber: Number(worldDeploy.deployBlock),
-  };
-
-  if (opts.saveDeployment) {
-    const chainId = await getChainId(client);
-    const deploysDir = path.join(config.deploysDirectory, chainId.toString());
-    mkdirSync(deploysDir, { recursive: true });
-    writeFileSync(path.join(deploysDir, "latest.json"), JSON.stringify(deploymentInfo, null, 2));
-    writeFileSync(path.join(deploysDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2));
-
-    const localChains = [1337, 31337];
-    const deploys = existsSync(config.worldsFile) ? JSON.parse(readFileSync(config.worldsFile, "utf-8")) : {};
-    deploys[chainId] = {
-      address: deploymentInfo.worldAddress,
-      // We expect the worlds file to be committed and since local deployments are often
-      // a consistent address but different block number, we'll ignore the block number.
-      blockNumber: localChains.includes(chainId) ? undefined : deploymentInfo.blockNumber,
-    };
-    writeFileSync(config.worldsFile, JSON.stringify(deploys, null, 2));
-
-    console.log(
-      chalk.bgGreen(chalk.whiteBright(`\n Deployment result (written to ${config.worldsFile} and ${deploysDir}): \n`)),
-    );
-  }
-
-  console.log(deploymentInfo);
-
-  return worldDeploy;
-}

package/src/utils/errors.ts

@@ -1,29 +0,0 @@
-import chalk from "chalk";
-import { ZodError } from "zod";
-import { fromZodError, ValidationError } from "zod-validation-error";
-import { NotInsideProjectError } from "@latticexyz/config/library";
-import { MUDError } from "@latticexyz/common/errors";
-
-export function logError(error: unknown) {
-  if (error instanceof ValidationError) {
-    console.log(chalk.redBright(error.message));
-  } else if (error instanceof ZodError) {
-    // TODO currently this error shouldn't happen, use `fromZodErrorCustom`
-    // (see https://github.com/latticexyz/mud/issues/438)
-    const validationError = fromZodError(error, {
-      prefixSeparator: "\n- ",
-      issueSeparator: "\n- ",
-    });
-    console.log(chalk.redBright(validationError.message));
-  } else if (error instanceof NotInsideProjectError) {
-    console.log(chalk.red(error.message));
-    console.log("");
-    // TODO add docs to the website and update the link to the specific page
-    // (see https://github.com/latticexyz/mud/issues/445)
-    console.log(chalk.blue(`To learn more about MUD's configuration, please go to https://mud.dev/packages/cli/`));
-  } else if (error instanceof MUDError) {
-    console.log(chalk.red(error));
-  } else {
-    console.log(error);
-  }
-}

package/src/utils/findPlaceholders.ts

@@ -1,27 +0,0 @@
-import { LibraryPlaceholder } from "../deploy/common";
-
-// TODO: move this to a broader solc artifact type
-/** From `artifact.bytecode.linkReferences` where `artifact` is the solc JSON output of a compiled Solidity contract */
-export type LinkReferences = {
-  [filename: string]: {
-    [name: string]: {
-      start: number;
-      length: number;
-    }[];
-  };
-};
-
-export function findPlaceholders(linkReferences: LinkReferences): readonly LibraryPlaceholder[] {
-  return Object.entries(linkReferences).flatMap(([path, contracts]) =>
-    Object.entries(contracts).flatMap(([contractName, locations]) =>
-      locations.map(
-        (location): LibraryPlaceholder => ({
-          path,
-          name: contractName,
-          start: location.start,
-          length: location.length,
-        }),
-      ),
-    ),
-  );
-}

package/src/utils/getContractArtifact.ts

@@ -1,80 +0,0 @@
-import { Abi, Hex, isHex, size } from "viem";
-import { LibraryPlaceholder } from "../deploy/common";
-import { findPlaceholders } from "./findPlaceholders";
-import { z } from "zod";
-import { Abi as abiSchema } from "abitype/zod";
-import { createRequire } from "node:module";
-import { findUp } from "find-up";
-
-export type GetContractArtifactOptions = {
-  /**
-   * Path to `package.json` where `artifactPath`s are resolved relative to.
-   *
-   * Defaults to nearest `package.json` relative to `process.cwd()`.
-   */
-  packageJsonPath?: string;
-  /**
-   * Import path to contract's forge/solc JSON artifact with the contract's compiled bytecode.
-   *
-   * This path is resolved using node's module resolution relative to `configPath`, so this supports both
-   * relative file paths (`../path/to/MyModule.json`) as well as JS import paths (`@latticexyz/world-contracts/out/CallWithSignatureModule.sol/CallWithSignatureModule.json`).
-   */
-  artifactPath: string;
-};
-
-export type GetContractArtifactResult = {
-  bytecode: Hex;
-  placeholders: readonly LibraryPlaceholder[];
-  abi: Abi;
-  deployedBytecodeSize: number;
-};
-
-const bytecodeSchema = z.object({
-  object: z.string().refine(isHex),
-  linkReferences: z.record(
-    z.record(
-      z.array(
-        z.object({
-          start: z.number(),
-          length: z.number(),
-        }),
-      ),
-    ),
-  ),
-});
-
-const artifactSchema = z.object({
-  bytecode: bytecodeSchema,
-  deployedBytecode: bytecodeSchema,
-  abi: abiSchema,
-});
-
-export async function getContractArtifact({
-  packageJsonPath,
-  artifactPath,
-}: GetContractArtifactOptions): Promise<GetContractArtifactResult> {
-  let importedArtifact;
-  try {
-    const requirePath = packageJsonPath ?? (await findUp("package.json", { cwd: process.cwd() }));
-    if (!requirePath) throw new Error("Could not find package.json to import relative to.");
-
-    const require = createRequire(requirePath);
-    importedArtifact = require(artifactPath);
-  } catch (error) {
-    console.error();
-    console.error("Could not import contract artifact at", artifactPath);
-    console.error();
-    throw error;
-  }
-
-  // TODO: improve errors or replace with arktype?
-  const artifact = artifactSchema.parse(importedArtifact);
-  const placeholders = findPlaceholders(artifact.bytecode.linkReferences);
-
-  return {
-    abi: artifact.abi,
-    bytecode: artifact.bytecode.object,
-    placeholders,
-    deployedBytecodeSize: size(artifact.deployedBytecode.object),
-  };
-}

package/src/utils/getContractData.ts

@@ -1,38 +0,0 @@
-import { readFileSync } from "fs";
-import path from "path";
-import { MUDError } from "@latticexyz/common/errors";
-import { Abi, Hex, size } from "viem";
-import { LibraryPlaceholder } from "../deploy/common";
-import { findPlaceholders } from "./findPlaceholders";
-
-/**
- * Load the contract's abi and bytecode from the file system
- * @param contractName: Name of the contract to load
- */
-export function getContractData(
-  filename: string,
-  contractName: string,
-  forgeOutDirectory: string,
-): { bytecode: Hex; placeholders: readonly LibraryPlaceholder[]; abi: Abi; deployedBytecodeSize: number } {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let data: any;
-  const contractDataPath = path.join(forgeOutDirectory, filename, contractName + ".json");
-  try {
-    data = JSON.parse(readFileSync(contractDataPath, "utf8"));
-  } catch (error) {
-    throw new MUDError(`Error reading file at ${contractDataPath}`);
-  }
-
-  const bytecode = data?.bytecode?.object;
-  if (!bytecode) throw new MUDError(`No bytecode found in ${contractDataPath}`);
-
-  const deployedBytecode = data?.deployedBytecode?.object;
-  if (!deployedBytecode) throw new MUDError(`No deployed bytecode found in ${contractDataPath}`);
-
-  const abi = data?.abi;
-  if (!abi) throw new MUDError(`No ABI found in ${contractDataPath}`);
-
-  const placeholders = findPlaceholders(data?.bytecode?.linkReferences ?? {});
-
-  return { abi, bytecode, placeholders, deployedBytecodeSize: size(deployedBytecode as Hex) };
-}

package/src/utils/getExistingContracts.ts

@@ -1,12 +0,0 @@
-import glob from "glob";
-import { basename } from "path";
-
-/**
- * Get a list of all contract paths/names within the provided src directory
- */
-export function getExistingContracts(srcDir: string) {
-  return glob.sync(`${srcDir}/**/*.sol`).map((path) => ({
-    path,
-    basename: basename(path, ".sol"),
-  }));
-}

package/src/utils/knownModuleArtifacts.ts

@@ -1,8 +0,0 @@
-/** @deprecated Please don't add to this list! These are kept for backwards compatibility and assumes the downstream project has this module installed as a dependency. */
-export const knownModuleArtifacts = {
-  KeysWithValueModule: "@latticexyz/world-modules/out/KeysWithValueModule.sol/KeysWithValueModule.json",
-  KeysInTableModule: "@latticexyz/world-modules/out/KeysInTableModule.sol/KeysInTableModule.json",
-  UniqueEntityModule: "@latticexyz/world-modules/out/UniqueEntityModule.sol/UniqueEntityModule.json",
-  Unstable_CallWithSignatureModule:
-    "@latticexyz/world-modules/out/Unstable_CallWithSignatureModule.sol/Unstable_CallWithSignatureModule.json",
-};

package/src/utils/postDeploy.ts

@@ -1,42 +0,0 @@
-import { existsSync } from "fs";
-import path from "path";
-import chalk from "chalk";
-import { getScriptDirectory, forge } from "@latticexyz/common/foundry";
-
-export async function postDeploy(
-  postDeployScript: string,
-  worldAddress: string,
-  rpc: string,
-  profile: string | undefined,
-  forgeOptions: string | undefined,
-  kms: boolean,
-): Promise<void> {
-  // TODO: make this more robust as it is likely to fail for any args that have a space in them
-  const userOptions = forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
-  const postDeployPath = path.join(await getScriptDirectory(), postDeployScript + ".s.sol");
-  if (!existsSync(postDeployPath)) {
-    console.log(`No script at ${postDeployPath}, skipping post deploy hook`);
-    return;
-  }
-
-  console.log(chalk.blue(`Executing post deploy script at ${postDeployPath}`));
-
-  await forge(
-    [
-      "script",
-      postDeployScript,
-      "--broadcast",
-      "--sig",
-      "run(address)",
-      worldAddress,
-      "--rpc-url",
-      rpc,
-      "-vvv",
-      kms ? "--aws" : "",
-      ...userOptions,
-    ],
-    {
-      profile: profile,
-    },
-  );
-}

package/src/utils/printMUD.ts

@@ -1,14 +0,0 @@
-import chalk from "chalk";
-
-export function printMUD() {
-  console.log(
-    chalk.yellow(`
-.------..------..------.
-|M.--. ||U.--. ||D.--. |
-| (\\/) || (\\/) || :/\\: |
-| :\\/: || :\\/: || (__) |
-| '--'M|| '--'U|| '--'D|
-'------''------''------'
-`),
-  );
-}

package/src/verify/verifyContract.ts

@@ -1,23 +0,0 @@
-import { forge } from "@latticexyz/common/foundry";
-import { Address } from "viem";
-
-type VerifyContractOptions = {
-  name: string;
-  rpc: string;
-  verifier?: string;
-  verifierUrl?: string;
-  address: Address;
-  cwd?: string;
-};
-
-export async function verifyContract(options: VerifyContractOptions) {
-  const args = ["verify-contract", options.address, options.name, "--rpc-url", options.rpc];
-
-  if (options.verifier) {
-    args.push("--verifier", options.verifier);
-  }
-  if (options.verifierUrl) {
-    args.push("--verifier-url", options.verifierUrl);
-  }
-  await forge(args, { cwd: options.cwd });
-}