@latticexyz/cli 2.0.0-next.11 → 2.0.0-next.13

package/src/deploy/getTables.ts

@@ -0,0 +1,59 @@
+import { Client, parseAbiItem, decodeAbiParameters, parseAbiParameters } from "viem";
+import { Table } from "./configToTables";
+import { hexToResource } from "@latticexyz/common";
+import { WorldDeploy, storeTables } from "./common";
+import { debug } from "./debug";
+import { storeSetRecordEvent } from "@latticexyz/store";
+import { getLogs } from "viem/actions";
+import { KeySchema, ValueSchema, decodeKey, decodeValueArgs, hexToSchema } from "@latticexyz/protocol-parser";
+
+export async function getTables({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly Table[]> {
+  // This assumes we only use `Tables._set(...)`, which is true as of this writing.
+  // TODO: PR to viem's getLogs to accept topics array so we can filter on all store events and quickly recreate this table's current state
+  // TODO: consider moving this to a batched getRecord for Tables table
+
+  debug("looking up tables for", worldDeploy.address);
+  const logs = await getLogs(client, {
+    strict: true,
+    // this may fail for certain RPC providers with block range limits
+    // if so, could potentially use our fetchLogs helper (which does pagination)
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    event: parseAbiItem(storeSetRecordEvent),
+    args: { tableId: storeTables.store_Tables.tableId },
+  });
+
+  // TODO: combine with store-sync logToTable and export from somewhere
+  const tables = logs.map((log) => {
+    const { tableId } = decodeKey(storeTables.store_Tables.keySchema, log.args.keyTuple);
+    const { namespace, name } = hexToResource(tableId);
+    const value = decodeValueArgs(storeTables.store_Tables.valueSchema, log.args);
+
+    // TODO: migrate to better helper
+    const keySchemaFields = hexToSchema(value.keySchema);
+    const valueSchemaFields = hexToSchema(value.valueSchema);
+    const keyNames = decodeAbiParameters(parseAbiParameters("string[]"), value.abiEncodedKeyNames)[0];
+    const fieldNames = decodeAbiParameters(parseAbiParameters("string[]"), value.abiEncodedFieldNames)[0];
+
+    const valueAbiTypes = [...valueSchemaFields.staticFields, ...valueSchemaFields.dynamicFields];
+
+    const keySchema = Object.fromEntries(
+      keySchemaFields.staticFields.map((abiType, i) => [keyNames[i], abiType])
+    ) as KeySchema;
+    const valueSchema = Object.fromEntries(valueAbiTypes.map((abiType, i) => [fieldNames[i], abiType])) as ValueSchema;
+
+    return { namespace, name, tableId, keySchema, valueSchema } as const;
+  });
+  // TODO: filter/detect duplicates?
+
+  debug("found", tables.length, "tables for", worldDeploy.address);
+
+  return tables;
+}

package/src/deploy/getWorldDeploy.ts

@@ -0,0 +1,39 @@
+import { Client, Address, getAddress, parseAbi } from "viem";
+import { getBlockNumber, getLogs } from "viem/actions";
+import { WorldDeploy, worldDeployEvents } from "./common";
+import { debug } from "./debug";
+import { logsToWorldDeploy } from "./logsToWorldDeploy";
+
+const deploys = new Map<Address, WorldDeploy>();
+
+export async function getWorldDeploy(client: Client, worldAddress: Address): Promise<WorldDeploy> {
+  const address = getAddress(worldAddress);
+
+  let deploy = deploys.get(address);
+  if (deploy != null) {
+    return deploy;
+  }
+
+  debug("looking up world deploy for", address);
+
+  const stateBlock = await getBlockNumber(client);
+  const logs = await getLogs(client, {
+    strict: true,
+    address,
+    events: parseAbi(worldDeployEvents),
+    // this may fail for certain RPC providers with block range limits
+    // if so, could potentially use our fetchLogs helper (which does pagination)
+    fromBlock: "earliest",
+    toBlock: stateBlock,
+  });
+
+  deploy = {
+    ...logsToWorldDeploy(logs),
+    stateBlock,
+  };
+  deploys.set(address, deploy);
+
+  debug("found world deploy for", address, "at block", deploy.deployBlock);
+
+  return deploy;
+}

package/src/deploy/logsToWorldDeploy.ts

@@ -0,0 +1,49 @@
+import { AbiEventSignatureNotFoundError, Log, decodeEventLog, hexToString, parseAbi, trim } from "viem";
+import { WorldDeploy, worldDeployEvents } from "./common";
+import { isDefined } from "@latticexyz/common/utils";
+
+export function logsToWorldDeploy(logs: readonly Log<bigint, number, false>[]): Omit<WorldDeploy, "stateBlock"> {
+  const deployLogs = logs
+    .map((log) => {
+      try {
+        return {
+          ...log,
+          ...decodeEventLog({
+            strict: true,
+            abi: parseAbi(worldDeployEvents),
+            topics: log.topics,
+            data: log.data,
+          }),
+        };
+      } catch (error: unknown) {
+        if (error instanceof AbiEventSignatureNotFoundError) {
+          return;
+        }
+        throw error;
+      }
+    })
+    .filter(isDefined);
+
+  // TODO: should this test for/validate that only one of each of these events is present? and that the address/block number don't change between each?
+  const { address, deployBlock, worldVersion, storeVersion } = deployLogs.reduce<Partial<WorldDeploy>>(
+    (deploy, log) => ({
+      ...deploy,
+      address: log.address,
+      deployBlock: log.blockNumber,
+      ...(log.eventName === "HelloWorld"
+        ? { worldVersion: hexToString(trim(log.args.worldVersion, { dir: "right" })) }
+        : null),
+      ...(log.eventName === "HelloStore"
+        ? { storeVersion: hexToString(trim(log.args.storeVersion, { dir: "right" })) }
+        : null),
+    }),
+    {}
+  );
+
+  if (address == null) throw new Error("could not find world address");
+  if (deployBlock == null) throw new Error("could not find world deploy block number");
+  if (worldVersion == null) throw new Error("could not find world version");
+  if (storeVersion == null) throw new Error("could not find store version");
+
+  return { address, deployBlock, worldVersion, storeVersion };
+}

package/src/deploy/resolveConfig.ts

@@ -0,0 +1,154 @@
+import { resolveWorldConfig } from "@latticexyz/world";
+import { Config, ConfigInput, WorldFunction, salt } from "./common";
+import { resourceToHex, hexToResource } from "@latticexyz/common";
+import { resolveWithContext } from "@latticexyz/config";
+import { encodeField } from "@latticexyz/protocol-parser";
+import { SchemaAbiType, SchemaAbiTypeToPrimitiveType } from "@latticexyz/schema-type";
+import {
+  getFunctionSelector,
+  Hex,
+  getCreate2Address,
+  getAddress,
+  hexToBytes,
+  Abi,
+  bytesToHex,
+  getFunctionSignature,
+} from "viem";
+import { getExistingContracts } from "../utils/getExistingContracts";
+import { defaultModuleContracts } from "../utils/modules/constants";
+import { getContractData } from "../utils/utils/getContractData";
+import { configToTables } from "./configToTables";
+import { deployer } from "./ensureDeployer";
+import { resourceLabel } from "./resourceLabel";
+
+// 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 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", forgeOutDir);
+  const baseSystemFunctions = baseSystemContractData.abi
+    .filter((item): item is typeof item & { type: "function" } => item.type === "function")
+    .map(getFunctionSignature);
+
+  const systems = Object.entries(resolvedConfig.systems).map(([systemName, system]) => {
+    const namespace = config.namespace;
+    const name = system.name;
+    const systemId = resourceToHex({ type: "system", namespace, name });
+    const contractData = getContractData(systemName, forgeOutDir);
+
+    const systemFunctions = contractData.abi
+      .filter((item): item is typeof item & { type: "function" } => item.type === "function")
+      .map(getFunctionSignature)
+      .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}_${name}_${sig}`;
+        return {
+          signature: worldSignature,
+          selector: getFunctionSelector(worldSignature),
+          systemId,
+          systemFunctionSignature: sig,
+          systemFunctionSelector: getFunctionSelector(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 })
+      ),
+      address: getCreate2Address({ from: deployer, bytecode: contractData.bytecode, salt }),
+      bytecode: contractData.bytecode,
+      abi: contractData.abi,
+      functions: systemFunctions,
+    };
+  });
+
+  // resolve allowedSystemIds
+  // TODO: resolve this at deploy time so we can allow for arbitrary system IDs registered in the world as the source-of-truth rather than config
+  const systemsWithAccess = systems.map(({ allowedAddresses, allowedSystemIds, ...system }) => {
+    const allowedSystemAddresses = allowedSystemIds.map((systemId) => {
+      const targetSystem = systems.find((s) => s.systemId === systemId);
+      if (!targetSystem) {
+        throw new Error(
+          `System ${resourceLabel(system)} wanted access to ${resourceLabel(
+            hexToResource(systemId)
+          )}, but it wasn't found in the config.`
+        );
+      }
+      return targetSystem.address;
+    });
+    return {
+      ...system,
+      allowedAddresses: Array.from(
+        new Set([...allowedAddresses, ...allowedSystemAddresses].map((addr) => getAddress(addr)))
+      ),
+    };
+  });
+
+  // ugh (https://github.com/latticexyz/mud/issues/1668)
+  const resolveContext = {
+    tableIds: Object.fromEntries(
+      Object.entries(config.tables).map(([tableName, table]) => [
+        tableName,
+        hexToBytes(
+          resourceToHex({
+            type: table.offchainOnly ? "offchainTable" : "table",
+            namespace: config.namespace,
+            name: table.name,
+          })
+        ),
+      ])
+    ),
+  };
+
+  const defaultModules = defaultModuleContracts.map((mod) => ({
+    name: mod.name,
+    bytecode: (typeof mod.bytecode === "string" ? mod.bytecode : mod.bytecode.object) as Hex,
+    abi: mod.abi as Abi,
+  }));
+
+  const modules = config.modules.map((mod) => {
+    const contractData =
+      defaultModules.find((defaultMod) => defaultMod.name === mod.name) ?? getContractData(mod.name, forgeOutDir);
+    const installArgs = mod.args
+      .map((arg) => resolveWithContext(arg, resolveContext))
+      .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(`${mod.name} module should only have 0-1 args, but had ${installArgs.length} args.`);
+    }
+    return {
+      name: mod.name,
+      installAsRoot: mod.root,
+      installData: installArgs.length === 0 ? "0x" : installArgs[0],
+      address: getCreate2Address({ from: deployer, bytecode: contractData.bytecode, salt }),
+      bytecode: contractData.bytecode,
+      abi: contractData.abi,
+    };
+  });
+
+  return {
+    tables,
+    systems: systemsWithAccess,
+    modules,
+  };
+}

package/src/deploy/resourceLabel.ts

@@ -0,0 +1,3 @@
+export function resourceLabel({ namespace, name }: { readonly namespace: string; readonly name: string }): string {
+  return `${namespace}:${name}`;
+}

package/src/index.ts

@@ -1 +1 @@
-export * from "./utils/deployHandler";
+// nothing to export

package/src/mud.ts

@@ -1,39 +1,45 @@
 #!/usr/bin/env node
 
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { commands } from "./commands";
-import { logError } from "./utils/errors";
-
 // Load .env file into process.env
 import * as dotenv from "dotenv";
-import chalk from "chalk";
 dotenv.config();
 
-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
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
-  .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);
+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;
+}
 
-    process.exit(1);
-  })
-  // Useful aliases.
-  .alias({ h: "help" }).argv;
+run();

package/src/runDeploy.ts

@@ -0,0 +1,128 @@
+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 } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { loadConfig } from "@latticexyz/config/node";
+import { StoreConfig } from "@latticexyz/store";
+import { WorldConfig } from "@latticexyz/world";
+import { forge, getOutDirectory, getRemappings, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
+import chalk from "chalk";
+import { execa } from "execa";
+import { MUDError } from "@latticexyz/common/errors";
+import { resolveConfig } from "./deploy/resolveConfig";
+import { getChainId } from "viem/actions";
+import { postDeploy } from "./utils/utils/postDeploy";
+import { WorldDeploy } from "./deploy/common";
+import { tablegen } from "@latticexyz/store/codegen";
+import { worldgen } from "@latticexyz/world/node";
+import { getExistingContracts } from "./utils/getExistingContracts";
+
+export const deployOptions = {
+  configPath: { type: "string", desc: "Path to the 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" },
+  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.",
+  },
+} 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 profile = opts.profile ?? process.env.FOUNDRY_PROFILE;
+
+  const config = (await loadConfig(opts.configPath)) as StoreConfig & WorldConfig;
+  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 remappings = await getRemappings();
+
+  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) {
+    const outPath = path.join(srcDir, config.codegenDirectory);
+    await Promise.all([tablegen(config, outPath, remappings), worldgen(config, getExistingContracts(srcDir), outPath)]);
+    await forge(["build"], { profile });
+    await execa("mud", ["abi-ts"], { stdio: "inherit" });
+  }
+
+  const privateKey = process.env.PRIVATE_KEY as Hex;
+  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.`
+    );
+  }
+
+  const resolvedConfig = resolveConfig({ config, forgeSourceDir: srcDir, forgeOutDir: outDir });
+
+  const client = createWalletClient({
+    transport: http(rpc),
+    account: privateKeyToAccount(privateKey),
+  });
+  console.log("Deploying from", client.account.address);
+
+  const startTime = Date.now();
+  const worldDeploy = await deploy({
+    worldAddress: opts.worldAddress as Hex | undefined,
+    client,
+    config: resolvedConfig,
+  });
+  if (opts.worldAddress == null || opts.alwaysRunPostDeploy) {
+    await postDeploy(config.postDeployScript, worldDeploy.address, rpc, profile);
+  }
+  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/modules/constants.ts

@@ -1,10 +1,9 @@
 import KeysWithValueModuleData from "@latticexyz/world-modules/out/KeysWithValueModule.sol/KeysWithValueModule.json" assert { type: "json" };
 import KeysInTableModuleData from "@latticexyz/world-modules/out/KeysInTableModule.sol/KeysInTableModule.json" assert { type: "json" };
 import UniqueEntityModuleData from "@latticexyz/world-modules/out/UniqueEntityModule.sol/UniqueEntityModule.json" assert { type: "json" };
-import { ContractCode } from "../utils/types";
 
 // These modules are always deployed
-export const defaultModuleContracts: ContractCode[] = [
+export const defaultModuleContracts = [
   {
     name: "KeysWithValueModule",
     abi: KeysWithValueModuleData.abi,

package/src/utils/utils/getContractData.ts

@@ -1,16 +1,13 @@
 import { readFileSync } from "fs";
 import path from "path";
-import { Fragment } from "ethers/lib/utils.js";
 import { MUDError } from "@latticexyz/common/errors";
+import { Abi, Hex } from "viem";
 
 /**
  * Load the contract's abi and bytecode from the file system
  * @param contractName: Name of the contract to load
  */
-export function getContractData(
-  contractName: string,
-  forgeOutDirectory: string
-): { bytecode: string; abi: Fragment[] } {
+export function getContractData(contractName: string, forgeOutDirectory: string): { bytecode: Hex; abi: Abi } {
   let data: any;
   const contractDataPath = path.join(forgeOutDirectory, contractName + ".sol", contractName + ".json");
   try {

package/dist/chunk-TW3YGZ4D.js

@@ -1,11 +0,0 @@
-import S from"chalk";import $ from"path";import{MUDError as it}from"@latticexyz/common/errors";import{loadConfig as ct}from"@latticexyz/config/node";import u from"chalk";import ze from"path";import{ethers as A}from"ethers";import{getOutDirectory as Qe,cast as Xe,getSrcDirectory as Ze,getRemappings as et}from"@latticexyz/common/foundry";import{resolveWorldConfig as tt}from"@latticexyz/world";import Fe from"chalk";import Ie from"@latticexyz/world/out/World.sol/World.json"assert{type:"json"};import Me from"@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json"assert{type:"json"};import G from"chalk";import{ethers as Pe}from"ethers";import{MUDError as U}from"@latticexyz/common/errors";async function I(e){let{signer:t,nonce:r,maxPriorityFeePerGas:o,maxFeePerGas:n,debug:a,gasPrice:l,confirmations:p,contract:m}=e;try{let i=new Pe.ContractFactory(m.abi,m.bytecode,t);console.log(G.gray(`executing deployment of ${m.name} with nonce ${r}`));let g=i.deploy({nonce:r,maxPriorityFeePerGas:o,maxFeePerGas:n,gasPrice:l}).then(s=>p?s:s.deployed()),{address:f}=await g;return console.log(G.green("Deployed",m.name,"to",f)),f}catch(i){throw a&&console.error(i),i?.message.includes("invalid bytecode")?new U(`Error deploying ${m.name}: invalid bytecode. Note that linking of public libraries is not supported yet, make sure none of your libraries use "external" functions.`):i?.message.includes("CreateContractLimit")?new U(`Error deploying ${m.name}: CreateContractLimit exceeded.`):i}}import{readFileSync as Se}from"fs";import Te from"path";import{MUDError as N}from"@latticexyz/common/errors";function w(e,t){let r,o=Te.join(t,e+".sol",e+".json");try{r=JSON.parse(Se(o,"utf8"))}catch{throw new N(`Error reading file at ${o}`)}let n=r?.bytecode?.object;if(!n)throw new N(`No bytecode found in ${o}`);let a=r?.abi;if(!a)throw new N(`No ABI found in ${o}`);return{abi:a,bytecode:n}}async function K(e){console.log(Fe.blue("Deploying World"));let t=e.worldContractName?{name:"World",...w(e.worldContractName,e.forgeOutDirectory)}:{abi:Me,bytecode:Ie.bytecode,name:"World"};return I({...e,nonce:e.nonce,contract:t})}import ot from"@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json"assert{type:"json"};import ce from"@latticexyz/world/out/CoreModule.sol/CoreModule.json"assert{type:"json"};import L from"@latticexyz/world-modules/out/KeysWithValueModule.sol/KeysWithValueModule.json"assert{type:"json"};import H from"@latticexyz/world-modules/out/KeysInTableModule.sol/KeysInTableModule.json"assert{type:"json"};import J from"@latticexyz/world-modules/out/UniqueEntityModule.sol/UniqueEntityModule.json"assert{type:"json"};var R=[{name:"KeysWithValueModule",abi:L.abi,bytecode:L.bytecode},{name:"KeysInTableModule",abi:H.abi,bytecode:H.bytecode},{name:"UniqueEntityModule",abi:J.abi,bytecode:J.bytecode}];import{defaultAbiCoder as ve}from"ethers/lib/utils.js";import{resolveWithContext as Ne}from"@latticexyz/config";async function _(e,t,r){let o=await e[t.name];if(!o)throw new Error(`Module ${t.name} not found`);let n=t.args.map(p=>Ne(p,{tableIds:r})),a=n.map(p=>p.value),l=n.map(p=>p.type);return{func:t.root?"installRootModule":"installModule",args:[o,ve.encode(l,a)]}}function q(e,t){return t.filter(r=>!e.some(o=>o.name===r.name))}import{resourceIdToHex as Re}from"@latticexyz/common";async function Y(e){let{systems:t,namespace:r,systemContracts:o}=e,n=[];for(let{name:a,accessListAddresses:l,accessListSystems:p}of t)l.map(async m=>n.push(V(a,r,m))),p.map(async m=>n.push(V(a,r,await o[m])));return n}function V(e,t,r){return{func:"grantAccess",args:[Re({type:"system",namespace:t,name:e}),r]}}import{resourceIdToHex as X}from"@latticexyz/common";import{ethers as k}from"ethers";function O(e,t){let{abi:r}=w(e,t);return r.filter(o=>["fallback","function"].includes(o.type)).map(o=>`${o.name}${Q(o.inputs)}`)}function z(e){return ke(e)}function Q(e){return`(${e.map(r=>{let o=r.type.match(/tuple(.*)/);return o?Q(r.components)+o[1]:r.type})})`}function ke(e){return k.utils.hexDataSlice(k.utils.keccak256(k.utils.toUtf8Bytes(e)),0,4)}function Z(e){let t=[],{systemContractName:r,namespace:o,forgeOutDirectory:n,system:a}=e;if(a.registerFunctionSelectors){let l=O("System",n),p=O(r,n).filter(i=>r==="System"||!l.includes(i)),m=o==="";for(let i of p)t.push(Oe({namespace:o,name:a.name,systemFunctionSignature:i,isRoot:m}))}return t}function Oe(e){let{namespace:t,name:r,systemFunctionSignature:o,isRoot:n}=e;if(n){let a=z(o);return{func:"registerRootFunctionSelector",args:[X({type:"system",namespace:t,name:r}),o,a]}}else return{func:"registerFunctionSelector",args:[X({type:"system",namespace:t,name:r}),o]}}import{resourceIdToHex as je}from"@latticexyz/common";async function ee(e){let{namespace:t,systemContracts:r,systemKey:o,system:n}=e,a=await r[o];return{func:"registerSystem",args:[je({type:"system",namespace:t,name:n.name}),a,n.openAccess]}}import{encodeSchema as te,getStaticByteLength as Ae}from"@latticexyz/schema-type/deprecated";import{resolveAbiOrUserType as oe}from"@latticexyz/store/codegen";import{resourceIdToHex as $e}from"@latticexyz/common";import{fieldLayoutToHex as We}from"@latticexyz/protocol-parser";import{loadAndExtractUserTypes as Ee}from"@latticexyz/common/codegen";function re(e,t,r,o){let{name:n,valueSchema:a,keySchema:l}=e;if(!n)throw Error("Table missing name");let p=Ee(t.userTypes,r,o),m=Object.values(a).map(s=>{let{schemaType:d}=oe(s,t,p);return d}),i=m.map(s=>Ae(s)),g={staticFieldLengths:i.filter(s=>s>0),numDynamicFields:i.filter(s=>s===0).length},f=Object.values(l).map(s=>{let{schemaType:d}=oe(s,t,p);return d});return{func:"registerTable",args:[$e({type:e.offchainOnly?"offchainTable":"table",namespace:t.namespace,name:n}),We(g),te(f),te(m),Object.keys(l),Object.keys(a)]}}import{resourceIdToHex as Be}from"@latticexyz/common";import{hexToBytes as Ge}from"viem";function ne(e){let t={};for(let[r,{name:o,offchainOnly:n}]of Object.entries(e.tables))t[r]=Ge(Be({type:n?"offchainTable":"table",namespace:e.namespace,name:o}));return t}import Ue from"chalk";import{MUDError as Ke}from"@latticexyz/common/errors";async function ae(e,t,r){let o=await e.getTransactionCount(),n=0,a=100;for(;o!==t&&n<a;)console.log(Ue.gray(`Waiting for transactions to be included before executing postDeployScript (local nonce: ${t}, remote nonce: ${o}, retry number ${n}/${a})`)),await new Promise(l=>setTimeout(l,r)),n++,o=await e.getTransactionCount();if(o!==t)throw new Ke("Remote nonce doesn't match local nonce, indicating that not all deploy transactions were included.")}import Le from"chalk";import{MUDError as He}from"@latticexyz/common/errors";async function h(e){let{func:t,args:r,contract:o,signer:n,nonce:a,maxPriorityFeePerGas:l,maxFeePerGas:p,gasPrice:m,confirmations:i=1,debug:g}=e,f=`${t}(${r.map(s=>`'${s}'`).join(",")})`;try{let s=o.connect(n),d=await s.estimateGas[t].apply(null,r);return console.log(Le.gray(`executing transaction: ${f} with nonce ${a}`)),s[t].apply(null,[...r,{gasLimit:d,nonce:a,maxPriorityFeePerGas:l,maxFeePerGas:p,gasPrice:m}]).then(D=>i===0?D:D.wait(i))}catch(s){throw g&&console.error(s),new He(`Gas estimation error for ${f}: ${s?.reason}`)}}import{existsSync as Je}from"fs";import _e from"path";import qe from"chalk";import{getScriptDirectory as Ve,forge as Ye}from"@latticexyz/common/foundry";async function se(e,t,r,o){let n=_e.join(await Ve(),e+".s.sol");Je(n)?(console.log(qe.blue(`Executing post deploy script at ${n}`)),await Ye(["script",e,"--sig","run(address)",t,"--broadcast","--rpc-url",r,"-vvv"],{profile:o})):console.log(`No script at ${n}, skipping post deploy hook`)}import{MUDError as j}from"@latticexyz/common/errors";async function ie(e,t){let r=await e.provider.getFeeData(),o,n,a;if(r.lastBaseFeePerGas){if(!r.lastBaseFeePerGas.eq(0)&&(await e.getBalance()).eq(0))throw new j(`Attempting to deploy to a chain with non-zero base fee with an account that has no balance.
-        If you're deploying to the Lattice testnet, you can fund your account by running 'pnpm mud faucet --address ${await e.getAddress()}'`);o=r.lastBaseFeePerGas.eq(0)?0:Math.floor(15e8*t),n=r.lastBaseFeePerGas.mul(2).add(o)}else if(r.gasPrice){if(!r.gasPrice.eq(0)&&(await e.getBalance()).eq(0))throw new j("Attempting to deploy to a chain with non-zero gas price with an account that has no balance.");a=r.gasPrice}else throw new j("Can not fetch fee data from RPC");return{maxPriorityFeePerGas:o,maxFeePerGas:n,gasPrice:a}}import{resourceIdToHex as rt}from"@latticexyz/common";async function le(e,t,r){let o=Date.now(),{profile:n,rpc:a,privateKey:l,priorityFeeMultiplier:p,debug:m,worldAddress:i,disableTxWait:g,pollInterval:f}=r,s=tt(e,t),d=await Qe(n),D=await et(n),T=ze.join(await Ze(n),e.codegenDirectory),E=new A.providers.StaticJsonRpcProvider(a);E.pollingInterval=f;let P=new A.Wallet(l,E);console.log("Deploying from",P.address);let y=await P.getTransactionCount();console.log("Initial nonce",y);let C={...await ie(P,p),signer:P,debug:!!m,disableTxWait:g,confirmations:g?0:1},B=Number(await Xe(["block-number","--rpc-url",a],{profile:n}));console.log("Start deployment at block",B);let de=i?Promise.resolve(i):K({...C,nonce:y++,worldContractName:e.worldContractName,forgeOutDirectory:d}),ue=q(R,e.modules),ge=Object.keys(ue).map(c=>{let{abi:b,bytecode:v}=w(c,d);return{name:c,abi:b,bytecode:v}}),ye=Object.keys(s.systems).map(c=>{let{abi:b,bytecode:v}=w(c,d);return{name:c,abi:b,bytecode:v}}),F=[{name:"CoreModule",abi:ce.abi,bytecode:ce.bytecode},...R,...ge,...ye].reduce((c,b)=>(c[b.name]=I({...C,nonce:y++,contract:b}),c),{}),M=await de,x=new A.Contract(M,ot);i||(console.log(u.blue("Installing CoreModule")),await h({...C,nonce:y++,contract:x,func:"initialize",args:[await F.CoreModule]}),console.log(u.green("Installed CoreModule"))),e.namespace&&(console.log(u.blue("Registering Namespace")),await h({...C,nonce:y++,contract:x,func:"registerNamespace",args:[rt({type:"namespace",namespace:e.namespace,name:""})]}),console.log(u.green("Namespace registered")));let be=ne(e),Ce=Object.values(e.tables).map(c=>re(c,e,T,D));console.log(u.blue("Registering tables")),await Promise.all(Ce.map(c=>h({...C,nonce:y++,contract:x,...c}))),console.log(u.green("Tables registered")),console.log(u.blue("Registering Systems and Functions"));let we=await Promise.all(Object.entries(s.systems).map(([c,b])=>ee({systemContracts:F,systemKey:c,system:b,namespace:e.namespace}))),he=Object.entries(s.systems).flatMap(([c,b])=>Z({systemContractName:c,system:b,namespace:e.namespace,forgeOutDirectory:d}));await Promise.all([...we,...he].map(c=>h({...C,nonce:y++,contract:x,...c}))),console.log(u.green("Systems and Functions registered"));let De=await Y({systems:Object.values(s.systems),systemContracts:F,namespace:e.namespace});console.log(u.blue("Granting Access")),await Promise.all(De.map(c=>h({...C,nonce:y++,contract:x,...c}))),console.log(u.green("Access granted"));let xe=await Promise.all(e.modules.map(c=>_(F,c,be)));return console.log(u.blue("Installing User Modules")),await Promise.all(xe.map(c=>h({...C,nonce:y++,contract:x,...c}))),console.log(u.green("User Modules Installed")),await ae(P,y,f),await se(e.postDeployScript,M,a,n),console.log(u.green("Deployment completed in",(Date.now()-o)/1e3,"seconds")),{worldAddress:M,blockNumber:B}}import{forge as fe,getRpcUrl as lt,getSrcDirectory as mt}from"@latticexyz/common/foundry";import{existsSync as pt,mkdirSync as ft,readFileSync as dt,writeFileSync as W}from"fs";import nt from"glob";import{basename as at}from"path";function me(e){return nt.sync(`${e}/**/*.sol`).map(t=>({path:t,basename:at(t,".sol")}))}import{execa as ut}from"execa";import{ethers as st}from"ethers";async function pe(e){let{result:t}=await st.utils.fetchJson(e,'{ "id": 42, "jsonrpc": "2.0", "method": "eth_chainId", "params": [ ] }');return Number(t)}async function nr(e){e.profile??=process.env.FOUNDRY_PROFILE;let{configPath:t,printConfig:r,profile:o,clean:n,skipBuild:a}=e,l=e.rpc??await lt(o);console.log(S.bgBlue(S.whiteBright(`
- Deploying MUD contracts${o?" with profile "+o:""} to RPC ${l} 
-`))),n&&await fe(["clean"],{profile:o}),a||(await fe(["build","--skip","test","script"],{profile:o}),await ut("mud",["abi-ts"],{stdio:"inherit"}));let p=e?.srcDir??await mt(),m=me(p).map(({basename:s})=>s),i=await ct(t);r&&console.log(S.green(`
-Resolved config:
-`),JSON.stringify(i,null,2));let g=process.env.PRIVATE_KEY;if(!g)throw new it(`Missing PRIVATE_KEY environment variable.
-Run 'echo "PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" > .env'
-in your contracts directory to use the default anvil private key.`);let f=await le(i,m,{...e,rpc:l,privateKey:g});if(e.saveDeployment){let s=await pe(l),d=$.join(i.deploysDirectory,s.toString());ft(d,{recursive:!0}),W($.join(d,"latest.json"),JSON.stringify(f,null,2)),W($.join(d,Date.now()+".json"),JSON.stringify(f,null,2));let D=[1337,31337],T=pt(i.worldsFile)?JSON.parse(dt(i.worldsFile,"utf-8")):{};T[s]={address:f.worldAddress,blockNumber:D.includes(s)?void 0:f.blockNumber},W(i.worldsFile,JSON.stringify(T,null,2)),console.log(S.bgGreen(S.whiteBright(`
- Deployment result (written to ${i.worldsFile} and ${d}): 
-`)))}return console.log(f),f}export{me as a,pe as b,nr as c};
-//# sourceMappingURL=chunk-TW3YGZ4D.js.map