@latticexyz/cli 2.0.0-snapshot-test-32d38619 → 2.0.0-transaction-context-af4b168c

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,151 @@
+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}__${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,
+      deployedBytecodeSize: contractData.deployedBytecodeSize,
+      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 modules = config.modules.map((mod) => {
+    const contractData =
+      defaultModuleContracts.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,
+      deployedBytecodeSize: contractData.deployedBytecodeSize,
+      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/mudPackages.ts

@@ -0,0 +1,24 @@
+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 { _errors, ...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

@@ -0,0 +1,131 @@
+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 { StoreConfig } from "@latticexyz/store";
+import { WorldConfig } from "@latticexyz/world";
+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/utils/postDeploy";
+import { WorldDeploy } from "./deploy/common";
+import { build } from "./build";
+
+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.",
+  },
+  salt: {
+    type: "string",
+    desc: "The deployment salt to use. Defaults to a random salt.",
+  },
+} 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 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 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, srcDir, foundryProfile: profile });
+  }
+
+  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({
+    salt,
+    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,23 +1,26 @@
 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";
+import { Abi, Hex, size } from "viem";
 
 // These modules are always deployed
-export const defaultModuleContracts: ContractCode[] = [
+export const defaultModuleContracts = [
   {
     name: "KeysWithValueModule",
-    abi: KeysWithValueModuleData.abi,
-    bytecode: KeysWithValueModuleData.bytecode,
+    abi: KeysWithValueModuleData.abi as Abi,
+    bytecode: KeysWithValueModuleData.bytecode.object as Hex,
+    deployedBytecodeSize: size(KeysWithValueModuleData.deployedBytecode.object as Hex),
   },
   {
     name: "KeysInTableModule",
-    abi: KeysInTableModuleData.abi,
-    bytecode: KeysInTableModuleData.bytecode,
+    abi: KeysInTableModuleData.abi as Abi,
+    bytecode: KeysInTableModuleData.bytecode.object as Hex,
+    deployedBytecodeSize: size(KeysInTableModuleData.deployedBytecode.object as Hex),
   },
   {
     name: "UniqueEntityModule",
-    abi: UniqueEntityModuleData.abi,
-    bytecode: UniqueEntityModuleData.bytecode,
+    abi: UniqueEntityModuleData.abi as Abi,
+    bytecode: UniqueEntityModuleData.bytecode.object as Hex,
+    deployedBytecodeSize: size(UniqueEntityModuleData.deployedBytecode.object as Hex),
   },
 ];

package/src/utils/utils/getContractData.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from "fs";
 import path from "path";
-import { Fragment } from "ethers/lib/utils.js";
 import { MUDError } from "@latticexyz/common/errors";
+import { Abi, Hex, size } from "viem";
 
 /**
  * Load the contract's abi and bytecode from the file system
@@ -10,7 +10,7 @@ import { MUDError } from "@latticexyz/common/errors";
 export function getContractData(
   contractName: string,
   forgeOutDirectory: string
-): { bytecode: string; abi: Fragment[] } {
+): { bytecode: Hex; abi: Abi; deployedBytecodeSize: number } {
   let data: any;
   const contractDataPath = path.join(forgeOutDirectory, contractName + ".sol", contractName + ".json");
   try {
@@ -22,8 +22,11 @@ export function getContractData(
   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}`);
 
-  return { abi, bytecode };
+  return { abi, bytecode, deployedBytecodeSize: size(deployedBytecode as Hex) };
 }

package/dist/chunk-WERDORTY.js

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