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

package/src/deploy/ensureContract.ts

@@ -1,66 +0,0 @@
-import { Client, Transport, Chain, Account, concatHex, getCreate2Address, Hex } from "viem";
-import { getBytecode } from "viem/actions";
-import { contractSizeLimit, salt } from "./common";
-import { sendTransaction } from "@latticexyz/common";
-import { debug } from "./debug";
-import pRetry from "p-retry";
-import { wait } from "@latticexyz/common/utils";
-
-export type Contract = {
-  bytecode: Hex;
-  deployedBytecodeSize: number;
-  label?: string;
-};
-
-export async function ensureContract({
-  client,
-  deployerAddress,
-  bytecode,
-  deployedBytecodeSize,
-  label = "contract",
-}: {
-  readonly client: Client<Transport, Chain | undefined, Account>;
-  readonly deployerAddress: Hex;
-} & Contract): Promise<readonly Hex[]> {
-  if (bytecode.includes("__$")) {
-    throw new Error(`Found unlinked public library in ${label} bytecode`);
-  }
-
-  const address = getCreate2Address({ from: deployerAddress, salt, bytecode });
-
-  const contractCode = await getBytecode(client, { address, blockTag: "pending" });
-  if (contractCode) {
-    debug("found", label, "at", address);
-    return [];
-  }
-
-  if (deployedBytecodeSize > contractSizeLimit) {
-    console.warn(
-      `\nBytecode for ${label} (${deployedBytecodeSize} bytes) is over the contract size limit (${contractSizeLimit} bytes). Run \`forge build --sizes\` for more info.\n`,
-    );
-  } else if (deployedBytecodeSize > contractSizeLimit * 0.95) {
-    console.warn(
-      `\nBytecode for ${label} (${deployedBytecodeSize} bytes) is almost over the contract size limit (${contractSizeLimit} bytes). Run \`forge build --sizes\` for more info.\n`,
-    );
-  }
-
-  debug("deploying", label, "at", address);
-  return [
-    await pRetry(
-      () =>
-        sendTransaction(client, {
-          chain: client.chain ?? null,
-          to: deployerAddress,
-          data: concatHex([salt, bytecode]),
-        }),
-      {
-        retries: 3,
-        onFailedAttempt: async (error) => {
-          const delay = error.attemptNumber * 500;
-          debug(`failed to deploy ${label}, retrying in ${delay}ms...`);
-          await wait(delay);
-        },
-      },
-    ),
-  ];
-}

package/src/deploy/ensureContractsDeployed.ts

@@ -1,33 +0,0 @@
-import { Client, Transport, Chain, Account, Hex } from "viem";
-import { waitForTransactionReceipt } from "viem/actions";
-import { debug } from "./debug";
-import { Contract, ensureContract } from "./ensureContract";
-import { uniqueBy } from "@latticexyz/common/utils";
-
-export async function ensureContractsDeployed({
-  client,
-  deployerAddress,
-  contracts,
-}: {
-  readonly client: Client<Transport, Chain | undefined, Account>;
-  readonly deployerAddress: Hex;
-  readonly contracts: readonly Contract[];
-}): Promise<readonly Hex[]> {
-  // Deployments assume a deterministic deployer, so we only need to deploy the unique bytecode
-  const uniqueContracts = uniqueBy(contracts, (contract) => contract.bytecode);
-
-  const txs = (
-    await Promise.all(uniqueContracts.map((contract) => ensureContract({ client, deployerAddress, ...contract })))
-  ).flat();
-
-  if (txs.length) {
-    debug("waiting for contracts");
-    // wait for each tx separately/serially, because parallelizing results in RPC errors
-    for (const tx of txs) {
-      await waitForTransactionReceipt(client, { hash: tx });
-      // TODO: throw if there was a revert?
-    }
-  }
-
-  return txs;
-}

package/src/deploy/ensureDeployer.ts

@@ -1,69 +0,0 @@
-import { Account, Address, Chain, Client, Transport } from "viem";
-import { getBalance, sendRawTransaction, sendTransaction, waitForTransactionReceipt } from "viem/actions";
-import deployment from "./create2/deployment.json";
-import { debug } from "./debug";
-import { getDeployer } from "./getDeployer";
-
-const deployer = `0x${deployment.address}` as const;
-
-export async function ensureDeployer(client: Client<Transport, Chain | undefined, Account>): Promise<Address> {
-  const existingDeployer = await getDeployer(client);
-  if (existingDeployer !== undefined) {
-    return existingDeployer;
-  }
-
-  // There's not really a way to simulate a pre-EIP-155 (no chain ID) transaction,
-  // so we have to attempt to create the deployer first and, if it fails, fall back
-  // to a regular deploy.
-
-  // Send gas to deployment signer
-  const gasRequired = BigInt(deployment.gasLimit) * BigInt(deployment.gasPrice);
-  const currentBalance = await getBalance(client, { address: `0x${deployment.signerAddress}` });
-  const gasNeeded = gasRequired - currentBalance;
-  if (gasNeeded > 0) {
-    debug("sending gas for CREATE2 deployer to signer at", deployment.signerAddress);
-    const gasTx = await sendTransaction(client, {
-      chain: client.chain ?? null,
-      to: `0x${deployment.signerAddress}`,
-      value: gasNeeded,
-    });
-    const gasReceipt = await waitForTransactionReceipt(client, { hash: gasTx });
-    if (gasReceipt.status !== "success") {
-      console.error("failed to send gas to deployer signer", gasReceipt);
-      throw new Error("failed to send gas to deployer signer");
-    }
-  }
-
-  // Deploy the deployer
-  debug("deploying CREATE2 deployer at", deployer);
-  const deployTx = await sendRawTransaction(client, { serializedTransaction: `0x${deployment.transaction}` }).catch(
-    (error) => {
-      // Do a regular contract create if the presigned transaction doesn't work due to replay protection
-      if (String(error).includes("only replay-protected (EIP-155) transactions allowed over RPC")) {
-        console.warn(
-          // eslint-disable-next-line max-len
-          `\n  ⚠️ Your chain or RPC does not allow for non EIP-155 signed transactions, so your deploys will not be determinstic and contract addresses may change between deploys.\n\n  We recommend running your chain's node with \`--rpc.allow-unprotected-txs\` to enable determinstic deployments.\n`,
-        );
-        debug("deploying CREATE2 deployer");
-        return sendTransaction(client, {
-          chain: client.chain ?? null,
-          data: `0x${deployment.creationCode}`,
-        });
-      }
-      throw error;
-    },
-  );
-
-  const deployReceipt = await waitForTransactionReceipt(client, { hash: deployTx });
-  if (!deployReceipt.contractAddress) {
-    throw new Error("Deploy receipt did not have contract address, was the deployer not deployed?");
-  }
-
-  if (deployReceipt.contractAddress !== deployer) {
-    console.warn(
-      `\n  ⚠️ CREATE2 deployer created at ${deployReceipt.contractAddress} does not match the CREATE2 determinstic deployer we expected (${deployer})`,
-    );
-  }
-
-  return deployReceipt.contractAddress;
-}

package/src/deploy/ensureFunctions.ts

@@ -1,86 +0,0 @@
-import { Client, Transport, Chain, Account, Hex } from "viem";
-import { hexToResource, writeContract } from "@latticexyz/common";
-import { WorldDeploy, WorldFunction, worldAbi } from "./common";
-import { debug } from "./debug";
-import { getFunctions } from "./getFunctions";
-import pRetry from "p-retry";
-import { wait } from "@latticexyz/common/utils";
-
-export async function ensureFunctions({
-  client,
-  worldDeploy,
-  functions,
-}: {
-  readonly client: Client<Transport, Chain | undefined, Account>;
-  readonly worldDeploy: WorldDeploy;
-  readonly functions: readonly WorldFunction[];
-}): Promise<readonly Hex[]> {
-  const worldFunctions = await getFunctions({ client, worldDeploy });
-  const worldSelectorToFunction = Object.fromEntries(worldFunctions.map((func) => [func.selector, func]));
-
-  const toSkip = functions.filter((func) => worldSelectorToFunction[func.selector]);
-  const toAdd = functions.filter((func) => !toSkip.includes(func));
-
-  if (toSkip.length) {
-    debug("functions already registered:", toSkip.map((func) => func.signature).join(", "));
-    const wrongSystem = toSkip.filter((func) => func.systemId !== worldSelectorToFunction[func.selector]?.systemId);
-    if (wrongSystem.length) {
-      console.warn(
-        "found",
-        wrongSystem.length,
-        "functions already registered but pointing at a different system ID:",
-        wrongSystem.map((func) => func.signature).join(", "),
-      );
-    }
-  }
-
-  if (!toAdd.length) return [];
-
-  debug("registering functions:", toAdd.map((func) => func.signature).join(", "));
-
-  return Promise.all(
-    toAdd.map((func) => {
-      const { namespace } = hexToResource(func.systemId);
-      if (namespace === "") {
-        return pRetry(
-          () =>
-            writeContract(client, {
-              chain: client.chain ?? null,
-              address: worldDeploy.address,
-              abi: worldAbi,
-              // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
-              functionName: "registerRootFunctionSelector",
-              args: [func.systemId, func.systemFunctionSignature, func.systemFunctionSignature],
-            }),
-          {
-            retries: 3,
-            onFailedAttempt: async (error) => {
-              const delay = error.attemptNumber * 500;
-              debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
-              await wait(delay);
-            },
-          },
-        );
-      }
-      return pRetry(
-        () =>
-          writeContract(client, {
-            chain: client.chain ?? null,
-            address: worldDeploy.address,
-            abi: worldAbi,
-            // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
-            functionName: "registerFunctionSelector",
-            args: [func.systemId, func.systemFunctionSignature],
-          }),
-        {
-          retries: 3,
-          onFailedAttempt: async (error) => {
-            const delay = error.attemptNumber * 500;
-            debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
-            await wait(delay);
-          },
-        },
-      );
-    }),
-  );
-}

package/src/deploy/ensureModules.ts

@@ -1,81 +0,0 @@
-import { Client, Transport, Chain, Account, Hex, BaseError } from "viem";
-import { writeContract } from "@latticexyz/common";
-import { Library, Module, WorldDeploy, worldAbi } from "./common";
-import { debug } from "./debug";
-import { isDefined, wait } from "@latticexyz/common/utils";
-import pRetry from "p-retry";
-import { ensureContractsDeployed } from "./ensureContractsDeployed";
-
-export async function ensureModules({
-  client,
-  deployerAddress,
-  libraries,
-  worldDeploy,
-  modules,
-}: {
-  readonly client: Client<Transport, Chain | undefined, Account>;
-  readonly deployerAddress: Hex;
-  readonly libraries: readonly Library[];
-  readonly worldDeploy: WorldDeploy;
-  readonly modules: readonly Module[];
-}): Promise<readonly Hex[]> {
-  if (!modules.length) return [];
-
-  await ensureContractsDeployed({
-    client,
-    deployerAddress,
-    contracts: modules.map((mod) => ({
-      bytecode: mod.prepareDeploy(deployerAddress, libraries).bytecode,
-      deployedBytecodeSize: mod.deployedBytecodeSize,
-      label: `${mod.name} module`,
-    })),
-  });
-
-  debug("installing modules:", modules.map((mod) => mod.name).join(", "));
-  return (
-    await Promise.all(
-      modules.map((mod) =>
-        pRetry(
-          async () => {
-            try {
-              // append module's ABI so that we can decode any custom errors
-              const abi = [...worldAbi, ...mod.abi];
-              const moduleAddress = mod.prepareDeploy(deployerAddress, libraries).address;
-              return mod.installAsRoot
-                ? await writeContract(client, {
-                    chain: client.chain ?? null,
-                    address: worldDeploy.address,
-                    abi,
-                    // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
-                    functionName: "installRootModule",
-                    args: [moduleAddress, mod.installData],
-                  })
-                : await writeContract(client, {
-                    chain: client.chain ?? null,
-                    address: worldDeploy.address,
-                    abi,
-                    // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
-                    functionName: "installModule",
-                    args: [moduleAddress, mod.installData],
-                  });
-            } catch (error) {
-              if (error instanceof BaseError && error.message.includes("Module_AlreadyInstalled")) {
-                debug(`module ${mod.name} already installed`);
-                return;
-              }
-              throw error;
-            }
-          },
-          {
-            retries: 3,
-            onFailedAttempt: async (error) => {
-              const delay = error.attemptNumber * 500;
-              debug(`failed to install module ${mod.name}, retrying in ${delay}ms...`);
-              await wait(delay);
-            },
-          },
-        ),
-      ),
-    )
-  ).filter(isDefined);
-}

package/src/deploy/ensureNamespaceOwner.ts

@@ -1,71 +0,0 @@
-import { Account, Chain, Client, Hex, Transport, getAddress } from "viem";
-import { WorldDeploy, worldAbi, worldTables } from "./common";
-import { hexToResource, resourceToHex, writeContract } from "@latticexyz/common";
-import { getResourceIds } from "./getResourceIds";
-import { getTableValue } from "./getTableValue";
-import { debug } from "./debug";
-
-export async function ensureNamespaceOwner({
-  client,
-  worldDeploy,
-  resourceIds,
-}: {
-  readonly client: Client<Transport, Chain | undefined, Account>;
-  readonly worldDeploy: WorldDeploy;
-  readonly resourceIds: readonly Hex[];
-}): Promise<readonly Hex[]> {
-  const desiredNamespaces = Array.from(new Set(resourceIds.map((resourceId) => hexToResource(resourceId).namespace)));
-  const existingResourceIds = await getResourceIds({ client, worldDeploy });
-  const existingNamespaces = new Set(existingResourceIds.map((resourceId) => hexToResource(resourceId).namespace));
-  if (existingNamespaces.size) {
-    debug(
-      "found",
-      existingNamespaces.size,
-      "existing namespaces:",
-      Array.from(existingNamespaces)
-        .map((namespace) => (namespace === "" ? "<root>" : namespace))
-        .join(", "),
-    );
-  }
-
-  // Assert ownership of existing namespaces
-  const existingDesiredNamespaces = desiredNamespaces.filter((namespace) => existingNamespaces.has(namespace));
-  const namespaceOwners = await Promise.all(
-    existingDesiredNamespaces.map(async (namespace) => {
-      const { owner } = await getTableValue({
-        client,
-        worldDeploy,
-        table: worldTables.world_NamespaceOwner,
-        key: { namespaceId: resourceToHex({ type: "namespace", namespace, name: "" }) },
-      });
-      return [namespace, owner];
-    }),
-  );
-
-  const unauthorizedNamespaces = namespaceOwners
-    .filter(([, owner]) => getAddress(owner) !== getAddress(client.account.address))
-    .map(([namespace]) => namespace);
-
-  if (unauthorizedNamespaces.length) {
-    throw new Error(`You are attempting to deploy to namespaces you do not own: ${unauthorizedNamespaces.join(", ")}`);
-  }
-
-  // Register missing namespaces
-  const missingNamespaces = desiredNamespaces.filter((namespace) => !existingNamespaces.has(namespace));
-  if (missingNamespaces.length > 0) {
-    debug("registering namespaces", Array.from(missingNamespaces).join(", "));
-  }
-  const registrationTxs = Promise.all(
-    missingNamespaces.map((namespace) =>
-      writeContract(client, {
-        chain: client.chain ?? null,
-        address: worldDeploy.address,
-        abi: worldAbi,
-        functionName: "registerNamespace",
-        args: [resourceToHex({ namespace, type: "namespace", name: "" })],
-      }),
-    ),
-  );
-
-  return registrationTxs;
-}

package/src/deploy/ensureSystems.ts

@@ -1,187 +0,0 @@
-import { Client, Transport, Chain, Account, Hex, getAddress, Address } from "viem";
-import { writeContract, resourceToLabel } from "@latticexyz/common";
-import { Library, System, WorldDeploy, worldAbi } from "./common";
-import { debug } from "./debug";
-import { getSystems } from "./getSystems";
-import { getResourceAccess } from "./getResourceAccess";
-import { wait } from "@latticexyz/common/utils";
-import pRetry from "p-retry";
-import { ensureContractsDeployed } from "./ensureContractsDeployed";
-
-// TODO: move each system registration+access to batch call to be atomic
-
-export async function ensureSystems({
-  client,
-  deployerAddress,
-  libraries,
-  worldDeploy,
-  systems,
-}: {
-  readonly client: Client<Transport, Chain | undefined, Account>;
-  readonly deployerAddress: Hex;
-  readonly libraries: readonly Library[];
-  readonly worldDeploy: WorldDeploy;
-  readonly systems: readonly System[];
-}): Promise<readonly Hex[]> {
-  const [worldSystems, worldAccess] = await Promise.all([
-    getSystems({ client, worldDeploy }),
-    getResourceAccess({ client, worldDeploy }),
-  ]);
-
-  // Register or replace systems
-
-  const existingSystems = systems.filter((system) =>
-    worldSystems.some(
-      (worldSystem) =>
-        worldSystem.systemId === system.systemId &&
-        getAddress(worldSystem.address) === getAddress(system.prepareDeploy(deployerAddress, libraries).address),
-    ),
-  );
-  if (existingSystems.length) {
-    debug("existing systems", existingSystems.map(resourceToLabel).join(", "));
-  }
-  const existingSystemIds = existingSystems.map((system) => system.systemId);
-
-  const missingSystems = systems.filter((system) => !existingSystemIds.includes(system.systemId));
-  if (!missingSystems.length) return [];
-
-  const systemsToUpgrade = missingSystems.filter((system) =>
-    worldSystems.some(
-      (worldSystem) =>
-        worldSystem.systemId === system.systemId &&
-        getAddress(worldSystem.address) !== getAddress(system.prepareDeploy(deployerAddress, libraries).address),
-    ),
-  );
-  if (systemsToUpgrade.length) {
-    debug("upgrading systems", systemsToUpgrade.map(resourceToLabel).join(", "));
-  }
-
-  const systemsToAdd = missingSystems.filter(
-    (system) => !worldSystems.some((worldSystem) => worldSystem.systemId === system.systemId),
-  );
-  if (systemsToAdd.length) {
-    debug("registering new systems", systemsToAdd.map(resourceToLabel).join(", "));
-  }
-
-  await ensureContractsDeployed({
-    client,
-    deployerAddress,
-    contracts: missingSystems.map((system) => ({
-      bytecode: system.prepareDeploy(deployerAddress, libraries).bytecode,
-      deployedBytecodeSize: system.deployedBytecodeSize,
-      label: `${resourceToLabel(system)} system`,
-    })),
-  });
-
-  const registerTxs = await Promise.all(
-    missingSystems.map((system) =>
-      pRetry(
-        () =>
-          writeContract(client, {
-            chain: client.chain ?? null,
-            address: worldDeploy.address,
-            abi: worldAbi,
-            // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
-            functionName: "registerSystem",
-            args: [system.systemId, system.prepareDeploy(deployerAddress, libraries).address, system.allowAll],
-          }),
-        {
-          retries: 3,
-          onFailedAttempt: async (error) => {
-            const delay = error.attemptNumber * 500;
-            debug(`failed to register system ${resourceToLabel(system)}, retrying in ${delay}ms...`);
-            await wait(delay);
-          },
-        },
-      ),
-    ),
-  );
-
-  // Adjust system access
-
-  const systemIds = systems.map((system) => system.systemId);
-  const currentAccess = worldAccess.filter(({ resourceId }) => systemIds.includes(resourceId));
-  const desiredAccess = [
-    ...systems.flatMap((system) =>
-      system.allowedAddresses.map((address) => ({ resourceId: system.systemId, address })),
-    ),
-    ...systems.flatMap((system) =>
-      system.allowedSystemIds
-        .map((systemId) => ({
-          resourceId: system.systemId,
-          address:
-            worldSystems.find((s) => s.systemId === systemId)?.address ??
-            systems.find((s) => s.systemId === systemId)?.prepareDeploy(deployerAddress, libraries).address,
-        }))
-        .filter((access): access is typeof access & { address: Address } => access.address != null),
-    ),
-  ];
-
-  const accessToAdd = desiredAccess.filter(
-    (access) =>
-      !currentAccess.some(
-        ({ resourceId, address }) =>
-          resourceId === access.resourceId && getAddress(address) === getAddress(access.address),
-      ),
-  );
-
-  const accessToRemove = currentAccess.filter(
-    (access) =>
-      !desiredAccess.some(
-        ({ resourceId, address }) =>
-          resourceId === access.resourceId && getAddress(address) === getAddress(access.address),
-      ),
-  );
-
-  if (accessToRemove.length) {
-    debug("revoking", accessToRemove.length, "access grants");
-  }
-  if (accessToAdd.length) {
-    debug("adding", accessToAdd.length, "access grants");
-  }
-
-  const accessTxs = await Promise.all([
-    ...accessToRemove.map((access) =>
-      pRetry(
-        () =>
-          writeContract(client, {
-            chain: client.chain ?? null,
-            address: worldDeploy.address,
-            abi: worldAbi,
-            functionName: "revokeAccess",
-            args: [access.resourceId, access.address],
-          }),
-        {
-          retries: 3,
-          onFailedAttempt: async (error) => {
-            const delay = error.attemptNumber * 500;
-            debug(`failed to revoke access, retrying in ${delay}ms...`);
-            await wait(delay);
-          },
-        },
-      ),
-    ),
-    ...accessToAdd.map((access) =>
-      pRetry(
-        () =>
-          writeContract(client, {
-            chain: client.chain ?? null,
-            address: worldDeploy.address,
-            abi: worldAbi,
-            functionName: "grantAccess",
-            args: [access.resourceId, access.address],
-          }),
-        {
-          retries: 3,
-          onFailedAttempt: async (error) => {
-            const delay = error.attemptNumber * 500;
-            debug(`failed to grant access, retrying in ${delay}ms...`);
-            await wait(delay);
-          },
-        },
-      ),
-    ),
-  ]);
-
-  return [...registerTxs, ...accessTxs];
-}

package/src/deploy/ensureTables.ts

@@ -1,64 +0,0 @@
-import { Client, Transport, Chain, Account, Hex } from "viem";
-import { Table } from "./configToTables";
-import { resourceToLabel, writeContract } from "@latticexyz/common";
-import { WorldDeploy, worldAbi } from "./common";
-import { valueSchemaToFieldLayoutHex, keySchemaToHex, valueSchemaToHex } from "@latticexyz/protocol-parser/internal";
-import { debug } from "./debug";
-import { getTables } from "./getTables";
-import pRetry from "p-retry";
-import { wait } from "@latticexyz/common/utils";
-
-export async function ensureTables({
-  client,
-  worldDeploy,
-  tables,
-}: {
-  readonly client: Client<Transport, Chain | undefined, Account>;
-  readonly worldDeploy: WorldDeploy;
-  readonly tables: readonly Table[];
-}): Promise<readonly Hex[]> {
-  const worldTables = await getTables({ client, worldDeploy });
-  const worldTableIds = worldTables.map((table) => table.tableId);
-
-  const existingTables = tables.filter((table) => worldTableIds.includes(table.tableId));
-  if (existingTables.length) {
-    debug("existing tables", existingTables.map(resourceToLabel).join(", "));
-  }
-
-  const missingTables = tables.filter((table) => !worldTableIds.includes(table.tableId));
-  if (missingTables.length) {
-    debug("registering tables", missingTables.map(resourceToLabel).join(", "));
-    return await Promise.all(
-      missingTables.map((table) =>
-        pRetry(
-          () =>
-            writeContract(client, {
-              chain: client.chain ?? null,
-              address: worldDeploy.address,
-              abi: worldAbi,
-              // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
-              functionName: "registerTable",
-              args: [
-                table.tableId,
-                valueSchemaToFieldLayoutHex(table.valueSchema),
-                keySchemaToHex(table.keySchema),
-                valueSchemaToHex(table.valueSchema),
-                Object.keys(table.keySchema),
-                Object.keys(table.valueSchema),
-              ],
-            }),
-          {
-            retries: 3,
-            onFailedAttempt: async (error) => {
-              const delay = error.attemptNumber * 500;
-              debug(`failed to register table ${resourceToLabel(table)}, retrying in ${delay}ms...`);
-              await wait(delay);
-            },
-          },
-        ),
-      ),
-    );
-  }
-
-  return [];
-}

package/src/deploy/ensureWorldFactory.ts

@@ -1,30 +0,0 @@
-import { Client, Transport, Chain, Account, Hex, Address } from "viem";
-import { ensureContractsDeployed } from "./ensureContractsDeployed";
-import { getWorldFactoryContracts } from "./getWorldFactoryContracts";
-import { getWorldProxyFactoryContracts } from "./getWorldProxyFactoryContracts";
-
-export async function ensureWorldFactory(
-  client: Client<Transport, Chain | undefined, Account>,
-  deployerAddress: Hex,
-  withWorldProxy?: boolean,
-): Promise<Address> {
-  if (withWorldProxy) {
-    const contracts = getWorldProxyFactoryContracts(deployerAddress);
-    // We can deploy these contracts in parallel because they do not call each other at this point.
-    await ensureContractsDeployed({
-      client,
-      deployerAddress,
-      contracts: Object.values(contracts),
-    });
-    return contracts.WorldProxyFactory.address;
-  }
-
-  const contracts = getWorldFactoryContracts(deployerAddress);
-  // We can deploy these contracts in parallel because they do not call each other at this point.
-  await ensureContractsDeployed({
-    client,
-    deployerAddress,
-    contracts: Object.values(contracts),
-  });
-  return contracts.WorldFactory.address;
-}