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

package/src/commands/verify.ts

@@ -1,100 +0,0 @@
-import type { CommandModule, InferredOptionTypes } from "yargs";
-import { verify } from "../verify";
-import { loadConfig } from "@latticexyz/config/node";
-import { World as WorldConfig } from "@latticexyz/world";
-import { resolveWorldConfig } from "@latticexyz/world/internal";
-import { worldToV1 } from "@latticexyz/world/config/v2";
-import { getOutDirectory, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
-import { getExistingContracts } from "../utils/getExistingContracts";
-import { getContractData } from "../utils/getContractData";
-import { Hex, createWalletClient, http } from "viem";
-import chalk from "chalk";
-import { configToModules } from "../deploy/configToModules";
-
-const verifyOptions = {
-  deployerAddress: {
-    type: "string",
-    desc: "Deploy using an existing deterministic deployer (https://github.com/Arachnid/deterministic-deployment-proxy)",
-  },
-  worldAddress: { type: "string", required: true, desc: "Verify an existing World at the given address" },
-  configPath: { type: "string", desc: "Path to the MUD config file" },
-  profile: { type: "string", desc: "The foundry profile to use" },
-  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)",
-  },
-  srcDir: { type: "string", desc: "Source directory. Defaults to foundry src directory." },
-  verifier: { type: "string", desc: "The verifier to use. Defaults to blockscout", default: "blockscout" },
-  verifierUrl: {
-    type: "string",
-    desc: "The verification provider.",
-  },
-} as const;
-
-type Options = InferredOptionTypes<typeof verifyOptions>;
-
-const commandModule: CommandModule<Options, Options> = {
-  command: "verify",
-
-  describe: "Verify contracts",
-
-  builder(yargs) {
-    return yargs.options(verifyOptions);
-  },
-
-  async handler(opts) {
-    const profile = opts.profile ?? process.env.FOUNDRY_PROFILE;
-
-    const configV2 = (await loadConfig(opts.configPath)) as WorldConfig;
-    const config = worldToV1(configV2);
-
-    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 Verifying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} \n`),
-      ),
-    );
-
-    const client = createWalletClient({
-      transport: http(rpc, {
-        batch: opts.rpcBatch
-          ? {
-              batchSize: 100,
-              wait: 1000,
-            }
-          : undefined,
-      }),
-    });
-
-    const contractNames = getExistingContracts(srcDir).map(({ basename }) => basename);
-    const resolvedWorldConfig = resolveWorldConfig(config, contractNames);
-
-    const systems = Object.keys(resolvedWorldConfig.systems).map((name) => {
-      const contractData = getContractData(`${name}.sol`, name, outDir);
-
-      return {
-        name,
-        bytecode: contractData.bytecode,
-      };
-    });
-
-    const modules = await configToModules(configV2, outDir);
-
-    await verify({
-      client,
-      rpc,
-      systems,
-      modules,
-      deployerAddress: opts.deployerAddress as Hex | undefined,
-      worldAddress: opts.worldAddress as Hex,
-      verifier: opts.verifier,
-      verifierUrl: opts.verifierUrl,
-    });
-  },
-};
-
-export default commandModule;

package/src/commands/worldgen.ts

@@ -1,58 +0,0 @@
-import type { CommandModule } from "yargs";
-import { loadConfig } from "@latticexyz/config/node";
-import { World as WorldConfig } from "@latticexyz/world";
-import { worldgen } from "@latticexyz/world/node";
-import { getSrcDirectory } from "@latticexyz/common/foundry";
-import path from "path";
-import { rmSync } from "fs";
-import { getExistingContracts } from "../utils/getExistingContracts";
-
-type Options = {
-  configPath?: string;
-  clean?: boolean;
-  srcDir?: string;
-  config?: WorldConfig;
-};
-
-const commandModule: CommandModule<Options, Options> = {
-  command: "worldgen",
-
-  describe: "Autogenerate interfaces for Systems and World based on existing contracts and the config file",
-
-  builder(yargs) {
-    return yargs.options({
-      configPath: { type: "string", desc: "Path to the MUD config file" },
-      clean: {
-        type: "boolean",
-        desc: "Clear the worldgen directory before generating new interfaces (defaults to true)",
-        default: true,
-      },
-    });
-  },
-
-  async handler(args) {
-    await worldgenHandler(args);
-    process.exit(0);
-  },
-};
-
-export async function worldgenHandler(args: Options) {
-  const srcDir = args.srcDir ?? (await getSrcDirectory());
-
-  const existingContracts = getExistingContracts(srcDir);
-
-  // Load the config
-  const mudConfig = args.config ?? ((await loadConfig(args.configPath)) as WorldConfig);
-
-  const outputBaseDirectory = path.join(srcDir, mudConfig.codegen.outputDirectory);
-
-  // clear the worldgen directory
-  if (args.clean) {
-    rmSync(path.join(outputBaseDirectory, mudConfig.codegen.worldgenDirectory), { recursive: true, force: true });
-  }
-
-  // generate new interfaces
-  await worldgen(mudConfig, existingContracts, outputBaseDirectory);
-}
-
-export default commandModule;

package/src/common.ts

@@ -1 +0,0 @@
-export type MudPackages = Record<string, { localPath: string }>;

package/src/debug.ts

@@ -1,10 +0,0 @@
-import createDebug from "debug";
-
-export const debug = createDebug("mud:cli");
-export const error = createDebug("mud:cli");
-
-// Pipe debug output to stdout instead of stderr
-debug.log = console.debug.bind(console);
-
-// Pipe error output to stderr
-error.log = console.error.bind(console);

package/src/deploy/common.ts

@@ -1,120 +0,0 @@
-import { Abi, Address, Hex, padHex } from "viem";
-import storeConfig from "@latticexyz/store/mud.config";
-import worldConfig from "@latticexyz/world/mud.config";
-import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
-import { Tables, configToTables } from "./configToTables";
-import { helloStoreEvent } from "@latticexyz/store";
-import { StoreConfig } from "@latticexyz/store/internal";
-import { helloWorldEvent } from "@latticexyz/world";
-import { WorldConfig } from "@latticexyz/world/internal";
-import { storeToV1 } from "@latticexyz/store/config/v2";
-import { worldToV1 } from "@latticexyz/world/config/v2";
-
-export const salt = padHex("0x", { size: 32 });
-
-// https://eips.ethereum.org/EIPS/eip-170
-export const contractSizeLimit = parseInt("6000", 16);
-
-// TODO: add `as const` to mud config so these get more strongly typed (blocked by current config parsing not using readonly)
-export const storeTables = configToTables(storeToV1(storeConfig));
-export const worldTables = configToTables(worldToV1(worldConfig));
-
-export const worldDeployEvents = [helloStoreEvent, helloWorldEvent] as const;
-
-export const worldAbi = IBaseWorldAbi;
-
-// Ideally, this should be an append-only list. Before adding more versions here, be sure to add backwards-compatible support for old Store/World versions.
-export const supportedStoreVersions = ["2.0.0", "2.0.1", "2.0.2"];
-export const supportedWorldVersions = ["2.0.0", "2.0.1", "2.0.2"];
-
-// TODO: extend this to include factory+deployer address? so we can reuse the deployer for a world?
-export type WorldDeploy = {
-  readonly address: Address;
-  readonly worldVersion: string;
-  readonly storeVersion: string;
-  /** Block number where the world was deployed */
-  readonly deployBlock: bigint;
-  /**
-   * Block number at the time of fetching world deploy.
-   * We use this block number when requesting data from the chain to align chain state
-   * with the same block during the introspection steps of the deploy.
-   */
-  readonly stateBlock: bigint;
-};
-
-export type WorldFunction = {
-  readonly signature: string;
-  readonly selector: Hex;
-  readonly systemId: Hex;
-  readonly systemFunctionSignature: string;
-  readonly systemFunctionSelector: Hex;
-};
-
-export type LibraryPlaceholder = {
-  /**
-   * Path to library source file, e.g. `src/libraries/SomeLib.sol`
-   */
-  path: string;
-  /**
-   * Library name, e.g. `SomeLib`
-   */
-  name: string;
-  /**
-   * Byte offset of placeholder in bytecode
-   */
-  start: number;
-  /**
-   * Size of placeholder to replace in bytes
-   */
-  length: number;
-};
-
-export type DeterministicContract = {
-  readonly prepareDeploy: (
-    deployer: Address,
-    libraries: readonly Library[],
-  ) => {
-    readonly address: Address;
-    readonly bytecode: Hex;
-  };
-  readonly deployedBytecodeSize: number;
-  readonly abi: Abi;
-};
-
-export type Library = DeterministicContract & {
-  /**
-   * Path to library source file, e.g. `src/libraries/SomeLib.sol`
-   */
-  path: string;
-  /**
-   * Library name, e.g. `SomeLib`
-   */
-  name: string;
-};
-
-export type System = DeterministicContract & {
-  readonly namespace: string;
-  readonly name: string;
-  readonly systemId: Hex;
-  readonly allowAll: boolean;
-  readonly allowedAddresses: readonly Hex[];
-  readonly allowedSystemIds: readonly Hex[];
-  readonly functions: readonly WorldFunction[];
-};
-
-export type DeployedSystem = Omit<System, "abi" | "prepareDeploy" | "deployedBytecodeSize" | "allowedSystemIds"> & {
-  address: Address;
-};
-
-export type Module = DeterministicContract & {
-  readonly name: string;
-  readonly installAsRoot: boolean;
-  readonly installData: Hex; // TODO: figure out better naming for this
-};
-
-export type ConfigInput = StoreConfig & WorldConfig;
-export type Config<config extends ConfigInput> = {
-  readonly tables: Tables<config>;
-  readonly systems: readonly System[];
-  readonly libraries: readonly Library[];
-};

package/src/deploy/configToModules.ts

@@ -1,75 +0,0 @@
-import path from "node:path";
-import { Module } from "./common";
-import { encodeField } from "@latticexyz/protocol-parser/internal";
-import { SchemaAbiType, SchemaAbiTypeToPrimitiveType } from "@latticexyz/schema-type/internal";
-import { bytesToHex } from "viem";
-import { createPrepareDeploy } from "./createPrepareDeploy";
-import { World } from "@latticexyz/world";
-import { getContractArtifact } from "../utils/getContractArtifact";
-import { knownModuleArtifacts } from "../utils/knownModuleArtifacts";
-import { resolveWithContext } from "@latticexyz/world/internal";
-
-export async function configToModules<config extends World>(
-  config: config,
-  // TODO: remove/replace `forgeOutDir`
-  forgeOutDir: string,
-): Promise<readonly Module[]> {
-  const modules = await Promise.all(
-    config.modules.map(async (mod): Promise<Module> => {
-      let artifactPath = mod.artifactPath;
-
-      // Backwards compatibility
-      // TODO: move this up a level so we don't need `forgeOutDir` in here?
-      if (!artifactPath) {
-        if (mod.name) {
-          artifactPath =
-            knownModuleArtifacts[mod.name as keyof typeof knownModuleArtifacts] ??
-            path.join(forgeOutDir, `${mod.name}.sol`, `${mod.name}.json`);
-          console.warn(
-            [
-              "",
-              `⚠️ Your \`mud.config.ts\` is using a module with a \`name\`, but this option is deprecated.`,
-              "",
-              "To resolve this, you can replace this:",
-              "",
-              `  name: ${JSON.stringify(mod.name)}`,
-              "",
-              "with this:",
-              "",
-              `  artifactPath: ${JSON.stringify(artifactPath)}`,
-              "",
-            ].join("\n"),
-          );
-        } else {
-          throw new Error("No `artifactPath` provided for module.");
-        }
-      }
-
-      const name = path.basename(artifactPath, ".json");
-      const artifact = await getContractArtifact({ artifactPath });
-
-      // TODO: replace args with something more strongly typed
-      const installArgs = mod.args
-        .map((arg) => resolveWithContext(arg, { config }))
-        .map((arg) => {
-          const value = arg.value instanceof Uint8Array ? bytesToHex(arg.value) : arg.value;
-          return encodeField(arg.type as SchemaAbiType, value as SchemaAbiTypeToPrimitiveType<SchemaAbiType>);
-        });
-
-      if (installArgs.length > 1) {
-        throw new Error(`${name} module should only have 0-1 args, but had ${installArgs.length} args.`);
-      }
-
-      return {
-        name,
-        installAsRoot: mod.root,
-        installData: installArgs.length === 0 ? "0x" : installArgs[0],
-        prepareDeploy: createPrepareDeploy(artifact.bytecode, artifact.placeholders),
-        deployedBytecodeSize: artifact.deployedBytecodeSize,
-        abi: artifact.abi,
-      };
-    }),
-  );
-
-  return modules;
-}

package/src/deploy/configToTables.ts

@@ -1,70 +0,0 @@
-import { resourceToHex } from "@latticexyz/common";
-import { KeySchema, ValueSchema } from "@latticexyz/protocol-parser/internal";
-import { SchemaAbiType, StaticAbiType } from "@latticexyz/schema-type/internal";
-import { StoreConfig, resolveUserTypes } from "@latticexyz/store/internal";
-import { Hex } from "viem";
-
-// TODO: we shouldn't need this file once our config parsing returns nicely formed tables
-
-type UserTypes<config extends StoreConfig = StoreConfig> = config["userTypes"];
-// TODO: fix strong enum types and avoid every schema getting `{ [k: string]: "uint8" }`
-// type UserTypes<config extends StoreConfig = StoreConfig> = config["userTypes"] & {
-//   [k in keyof config["enums"]]: { internalType: "uint8" };
-// };
-
-export type TableKey<
-  config extends StoreConfig = StoreConfig,
-  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]],
-> = `${config["namespace"]}_${table["name"]}`;
-
-export type Table<
-  config extends StoreConfig = StoreConfig,
-  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]],
-> = {
-  readonly namespace: config["namespace"];
-  readonly name: table["name"];
-  readonly tableId: Hex;
-  readonly keySchema: table["keySchema"] extends KeySchema<UserTypes<config>>
-    ? KeySchema & {
-        readonly [k in keyof table["keySchema"]]: UserTypes<config>[table["keySchema"][k]]["internalType"] extends StaticAbiType
-          ? UserTypes<config>[table["keySchema"][k]]["internalType"]
-          : table["keySchema"][k];
-      }
-    : KeySchema;
-  readonly valueSchema: table["valueSchema"] extends ValueSchema<UserTypes<config>>
-    ? {
-        readonly [k in keyof table["valueSchema"]]: UserTypes<config>[table["valueSchema"][k]]["internalType"] extends SchemaAbiType
-          ? UserTypes<config>[table["valueSchema"][k]]["internalType"]
-          : table["valueSchema"][k];
-      }
-    : ValueSchema;
-};
-
-export type Tables<config extends StoreConfig = StoreConfig> = {
-  readonly [k in keyof config["tables"] as TableKey<config, config["tables"][k]>]: Table<config, config["tables"][k]>;
-};
-
-export function configToTables<config extends StoreConfig>(config: config): Tables<config> {
-  const userTypes = {
-    ...config.userTypes,
-    ...Object.fromEntries(Object.entries(config.enums).map(([key]) => [key, { internalType: "uint8" }] as const)),
-  };
-  return Object.fromEntries(
-    Object.entries(config.tables).map(([tableName, table]) => [
-      `${config.namespace}_${tableName}` satisfies TableKey<config, config["tables"][keyof config["tables"]]>,
-      {
-        namespace: config.namespace,
-        name: table.name,
-        tableId: resourceToHex({
-          type: table.offchainOnly ? "offchainTable" : "table",
-          namespace: config.namespace,
-          name: table.name,
-        }),
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        keySchema: resolveUserTypes(table.keySchema, userTypes) as any,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        valueSchema: resolveUserTypes(table.valueSchema, userTypes) as any,
-      } satisfies Table<config, config["tables"][keyof config["tables"]]>,
-    ]),
-  ) as Tables<config>;
-}

package/src/deploy/create2/README.md

@@ -1,13 +0,0 @@
-Files generated by
-
-```
-git clone https://github.com/Arachnid/deterministic-deployment-proxy.git
-cd deterministic-deployment-proxy
-git checkout b3bb19c
-npm install
-npm run build
-cd output
-jq --arg bc "$(cat bytecode.txt)" '. + {creationCode: $bc}' deployment.json > deployment-with-creationCode.json
-mv deployment-with-creationCode.json deployment.json
-cp deployment.json ../path/to/this/dir
-```

package/src/deploy/create2/deployment.json

@@ -1,8 +0,0 @@
-{
-  "gasPrice": 100000000000,
-  "gasLimit": 100000,
-  "signerAddress": "3fab184622dc19b6109349b94811493bf2a45362",
-  "transaction": "f8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222",
-  "address": "4e59b44847b379578588920ca78fbf26c0b4956c",
-  "creationCode": "604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3"
-}

package/src/deploy/createPrepareDeploy.ts

@@ -1,28 +0,0 @@
-import { DeterministicContract, Library, LibraryPlaceholder, salt } from "./common";
-import { spliceHex } from "@latticexyz/common";
-import { Hex, getCreate2Address, Address } from "viem";
-
-export function createPrepareDeploy(
-  bytecodeWithPlaceholders: Hex,
-  placeholders: readonly LibraryPlaceholder[],
-): DeterministicContract["prepareDeploy"] {
-  return function prepareDeploy(deployer: Address, libraries: readonly Library[]) {
-    let bytecode = bytecodeWithPlaceholders;
-    for (const placeholder of placeholders) {
-      const library = libraries.find((lib) => lib.path === placeholder.path && lib.name === placeholder.name);
-      if (!library) {
-        throw new Error(`Could not find library for bytecode placeholder ${placeholder.path}:${placeholder.name}`);
-      }
-      bytecode = spliceHex(
-        bytecode,
-        placeholder.start,
-        placeholder.length,
-        library.prepareDeploy(deployer, libraries).address,
-      );
-    }
-    return {
-      bytecode,
-      address: getCreate2Address({ from: deployer, bytecode, salt }),
-    };
-  };
-}

package/src/deploy/debug.ts

@@ -1,10 +0,0 @@
-import { debug as parentDebug } from "../debug";
-
-export const debug = parentDebug.extend("deploy");
-export const error = parentDebug.extend("deploy");
-
-// Pipe debug output to stdout instead of stderr
-debug.log = console.debug.bind(console);
-
-// Pipe error output to stderr
-error.log = console.error.bind(console);

package/src/deploy/deploy.ts

@@ -1,137 +0,0 @@
-import { Account, Address, Chain, Client, Hex, Transport } from "viem";
-import { ensureDeployer } from "./ensureDeployer";
-import { deployWorld } from "./deployWorld";
-import { ensureTables } from "./ensureTables";
-import { Config, ConfigInput, Module, WorldDeploy, supportedStoreVersions, supportedWorldVersions } from "./common";
-import { ensureSystems } from "./ensureSystems";
-import { waitForTransactionReceipt } from "viem/actions";
-import { getWorldDeploy } from "./getWorldDeploy";
-import { ensureFunctions } from "./ensureFunctions";
-import { ensureModules } from "./ensureModules";
-import { Table } from "./configToTables";
-import { ensureNamespaceOwner } from "./ensureNamespaceOwner";
-import { debug } from "./debug";
-import { resourceToLabel } from "@latticexyz/common";
-import { ensureContractsDeployed } from "./ensureContractsDeployed";
-import { randomBytes } from "crypto";
-import { ensureWorldFactory } from "./ensureWorldFactory";
-
-type DeployOptions<configInput extends ConfigInput> = {
-  client: Client<Transport, Chain | undefined, Account>;
-  config: Config<configInput>;
-  modules?: readonly Module[];
-  salt?: Hex;
-  worldAddress?: Address;
-  /**
-   * Address of determinstic deployment proxy: https://github.com/Arachnid/deterministic-deployment-proxy
-   * By default, we look for a deployment at 0x4e59b44847b379578588920ca78fbf26c0b4956c and, if not, deploy one.
-   * If the target chain does not support legacy transactions, we deploy the proxy bytecode anyway, but it will
-   * not have a deterministic address.
-   */
-  deployerAddress?: Hex;
-  withWorldProxy?: boolean;
-};
-
-/**
- * Given a viem client and MUD config, we attempt to introspect the world
- * (or deploy a new one if no world address is provided) and do the minimal
- * amount of work to make the world match the config (e.g. deploy new tables,
- * replace systems, etc.)
- */
-export async function deploy<configInput extends ConfigInput>({
-  client,
-  config,
-  modules = [],
-  salt,
-  worldAddress: existingWorldAddress,
-  deployerAddress: initialDeployerAddress,
-  withWorldProxy,
-}: DeployOptions<configInput>): Promise<WorldDeploy> {
-  const tables = Object.values(config.tables) as Table[];
-
-  const deployerAddress = initialDeployerAddress ?? (await ensureDeployer(client));
-
-  await ensureWorldFactory(client, deployerAddress, withWorldProxy);
-
-  // deploy all dependent contracts, because system registration, module install, etc. all expect these contracts to be callable.
-  await ensureContractsDeployed({
-    client,
-    deployerAddress,
-    contracts: [
-      ...config.libraries.map((library) => ({
-        bytecode: library.prepareDeploy(deployerAddress, config.libraries).bytecode,
-        deployedBytecodeSize: library.deployedBytecodeSize,
-        label: `${library.path}:${library.name} library`,
-      })),
-      ...config.systems.map((system) => ({
-        bytecode: system.prepareDeploy(deployerAddress, config.libraries).bytecode,
-        deployedBytecodeSize: system.deployedBytecodeSize,
-        label: `${resourceToLabel(system)} system`,
-      })),
-      ...modules.map((mod) => ({
-        bytecode: mod.prepareDeploy(deployerAddress, config.libraries).bytecode,
-        deployedBytecodeSize: mod.deployedBytecodeSize,
-        label: `${mod.name} module`,
-      })),
-    ],
-  });
-
-  const worldDeploy = existingWorldAddress
-    ? await getWorldDeploy(client, existingWorldAddress)
-    : await deployWorld(client, deployerAddress, salt ?? `0x${randomBytes(32).toString("hex")}`, withWorldProxy);
-
-  if (!supportedStoreVersions.includes(worldDeploy.storeVersion)) {
-    throw new Error(`Unsupported Store version: ${worldDeploy.storeVersion}`);
-  }
-  if (!supportedWorldVersions.includes(worldDeploy.worldVersion)) {
-    throw new Error(`Unsupported World version: ${worldDeploy.worldVersion}`);
-  }
-
-  const namespaceTxs = await ensureNamespaceOwner({
-    client,
-    worldDeploy,
-    resourceIds: [...tables.map((table) => table.tableId), ...config.systems.map((system) => system.systemId)],
-  });
-
-  debug("waiting for all namespace registration transactions to confirm");
-  for (const tx of namespaceTxs) {
-    await waitForTransactionReceipt(client, { hash: tx });
-  }
-
-  const tableTxs = await ensureTables({
-    client,
-    worldDeploy,
-    tables,
-  });
-  const systemTxs = await ensureSystems({
-    client,
-    deployerAddress,
-    libraries: config.libraries,
-    worldDeploy,
-    systems: config.systems,
-  });
-  const functionTxs = await ensureFunctions({
-    client,
-    worldDeploy,
-    functions: config.systems.flatMap((system) => system.functions),
-  });
-  const moduleTxs = await ensureModules({
-    client,
-    deployerAddress,
-    libraries: config.libraries,
-    worldDeploy,
-    modules,
-  });
-
-  const txs = [...tableTxs, ...systemTxs, ...functionTxs, ...moduleTxs];
-
-  // wait for each tx separately/serially, because parallelizing results in RPC errors
-  debug("waiting for all transactions to confirm");
-  for (const tx of txs) {
-    await waitForTransactionReceipt(client, { hash: tx });
-    // TODO: throw if there was a revert?
-  }
-
-  debug("deploy complete");
-  return worldDeploy;
-}

package/src/deploy/deployWorld.ts

@@ -1,38 +0,0 @@
-import { Account, Chain, Client, Hex, Transport } from "viem";
-import { waitForTransactionReceipt } from "viem/actions";
-import { ensureWorldFactory } from "./ensureWorldFactory";
-import WorldFactoryAbi from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json" assert { type: "json" };
-import { writeContract } from "@latticexyz/common";
-import { debug } from "./debug";
-import { logsToWorldDeploy } from "./logsToWorldDeploy";
-import { WorldDeploy } from "./common";
-
-export async function deployWorld(
-  client: Client<Transport, Chain | undefined, Account>,
-  deployerAddress: Hex,
-  salt: Hex,
-  withWorldProxy?: boolean,
-): Promise<WorldDeploy> {
-  const worldFactory = await ensureWorldFactory(client, deployerAddress, withWorldProxy);
-
-  debug("deploying world");
-  const tx = await writeContract(client, {
-    chain: client.chain ?? null,
-    address: worldFactory,
-    abi: WorldFactoryAbi,
-    functionName: "deployWorld",
-    args: [salt],
-  });
-
-  debug("waiting for world deploy");
-  const receipt = await waitForTransactionReceipt(client, { hash: tx });
-  if (receipt.status !== "success") {
-    console.error("world deploy failed", receipt);
-    throw new Error("world deploy failed");
-  }
-
-  const deploy = logsToWorldDeploy(receipt.logs);
-  debug("deployed world to", deploy.address, "at block", deploy.deployBlock);
-
-  return { ...deploy, stateBlock: deploy.deployBlock };
-}