@latticexyz/cli 2.0.0-skystrife-playtest-19728914 → 2.0.0-snapshot-test-32d38619

package/src/utils/deployHandler.ts

@@ -7,9 +7,9 @@ import { WorldConfig } from "@latticexyz/world";
 import { deploy } from "../utils/deploy";
 import { forge, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { getChainId } from "../utils/getChainId";
 import { getExistingContracts } from "./getExistingContracts";
 import { execa } from "execa";
+import { getChainId } from "./utils/getChainId";
 
 export type DeployOptions = {
   configPath?: string;

package/src/utils/modules/constants.ts

@@ -0,0 +1,23 @@
+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[] = [
+  {
+    name: "KeysWithValueModule",
+    abi: KeysWithValueModuleData.abi,
+    bytecode: KeysWithValueModuleData.bytecode,
+  },
+  {
+    name: "KeysInTableModule",
+    abi: KeysInTableModuleData.abi,
+    bytecode: KeysInTableModuleData.bytecode,
+  },
+  {
+    name: "UniqueEntityModule",
+    abi: UniqueEntityModuleData.abi,
+    bytecode: UniqueEntityModuleData.bytecode,
+  },
+];

package/src/utils/modules/getInstallModuleCallData.ts

@@ -0,0 +1,27 @@
+import { defaultAbiCoder } from "ethers/lib/utils.js";
+import { resolveWithContext } from "@latticexyz/config";
+import { Module } from "./types";
+import { CallData } from "../utils/types";
+import { TableIds } from "../tables/types";
+
+export async function getInstallModuleCallData(
+  moduleContracts: Record<string, Promise<string>>,
+  module: Module,
+  tableIds: TableIds
+): Promise<CallData> {
+  const moduleAddress = await moduleContracts[module.name];
+  if (!moduleAddress) throw new Error(`Module ${module.name} not found`);
+  // Resolve arguments
+  const resolvedArgs = module.args.map((arg) =>
+    resolveWithContext(arg, {
+      tableIds,
+    })
+  );
+  const values = resolvedArgs.map((arg) => arg.value);
+  const types = resolvedArgs.map((arg) => arg.type);
+
+  return {
+    func: module.root ? "installRootModule" : "installModule",
+    args: [moduleAddress, defaultAbiCoder.encode(types, values)],
+  };
+}

package/src/utils/modules/getUserModules.ts

@@ -0,0 +1,5 @@
+import { Module } from "./types";
+
+export function getUserModules(defaultModules: { name: string }[], configModules: Module[]): Omit<Module, "address">[] {
+  return configModules.filter((module) => !defaultModules.some((m) => m.name === module.name));
+}

package/src/utils/modules/types.ts

@@ -0,0 +1,14 @@
+export type Module = {
+  name: string;
+  root: boolean;
+  args: (
+    | {
+        value: (string | number | Uint8Array) & (string | number | Uint8Array | undefined);
+        type: string;
+      }
+    | {
+        type: any;
+        input: string;
+      }
+  )[];
+};

package/src/utils/systems/getGrantAccessCallData.ts

@@ -0,0 +1,29 @@
+import { System } from "./types";
+import { CallData } from "../utils/types";
+import { resourceIdToHex } from "@latticexyz/common";
+
+export async function getGrantAccessCallData(input: {
+  systems: System[];
+  systemContracts: Record<string, Promise<string>>;
+  namespace: string;
+}): Promise<CallData[]> {
+  const { systems, namespace, systemContracts } = input;
+  const calls: CallData[] = [];
+  for (const { name, accessListAddresses, accessListSystems } of systems) {
+    // Grant access to addresses
+    accessListAddresses.map(async (address) => calls.push(getGrantSystemAccessCallData(name, namespace, address)));
+
+    // Grant access to other systems
+    accessListSystems.map(async (granteeSystem) =>
+      calls.push(getGrantSystemAccessCallData(name, namespace, await systemContracts[granteeSystem]))
+    );
+  }
+  return calls;
+}
+
+function getGrantSystemAccessCallData(name: string, namespace: string, address: string): CallData {
+  return {
+    func: "grantAccess",
+    args: [resourceIdToHex({ type: "system", namespace, name }), address],
+  };
+}

package/src/utils/systems/getRegisterFunctionSelectorsCallData.ts

@@ -0,0 +1,57 @@
+import { resourceIdToHex } from "@latticexyz/common";
+import { System } from "./types";
+import { loadFunctionSignatures, toFunctionSelector } from "./utils";
+import { CallData } from "../utils/types";
+
+export function getRegisterFunctionSelectorsCallData(input: {
+  systemContractName: string;
+  system: System;
+  namespace: string;
+  forgeOutDirectory: string;
+}): CallData[] {
+  // Register system at route
+  const callData: CallData[] = [];
+  const { systemContractName, namespace, forgeOutDirectory, system } = input;
+
+  if (system.registerFunctionSelectors) {
+    const baseSystemFunctionSignatures = loadFunctionSignatures("System", forgeOutDirectory);
+    const systemFunctionSignatures = loadFunctionSignatures(systemContractName, forgeOutDirectory).filter(
+      (functionSignature) =>
+        systemContractName === "System" || !baseSystemFunctionSignatures.includes(functionSignature)
+    );
+    const isRoot = namespace === "";
+    for (const systemFunctionSignature of systemFunctionSignatures) {
+      callData.push(
+        getRegisterFunctionSelectorCallData({
+          namespace,
+          name: system.name,
+          systemFunctionSignature,
+          isRoot,
+        })
+      );
+    }
+  }
+  return callData;
+}
+
+function getRegisterFunctionSelectorCallData(input: {
+  namespace: string;
+  name: string;
+  systemFunctionSignature: string;
+  isRoot: boolean;
+}): CallData {
+  const { namespace, name, systemFunctionSignature, isRoot } = input;
+
+  if (isRoot) {
+    const functionSelector = toFunctionSelector(systemFunctionSignature);
+    return {
+      func: "registerRootFunctionSelector",
+      args: [resourceIdToHex({ type: "system", namespace, name }), systemFunctionSignature, functionSelector],
+    };
+  } else {
+    return {
+      func: "registerFunctionSelector",
+      args: [resourceIdToHex({ type: "system", namespace, name }), systemFunctionSignature],
+    };
+  }
+}

package/src/utils/systems/getRegisterSystemCallData.ts

@@ -0,0 +1,17 @@
+import { resourceIdToHex } from "@latticexyz/common";
+import { System } from "./types";
+import { CallData } from "../utils/types";
+
+export async function getRegisterSystemCallData(input: {
+  systemContracts: Record<string, Promise<string>>;
+  systemKey: string;
+  system: System;
+  namespace: string;
+}): Promise<CallData> {
+  const { namespace, systemContracts, systemKey, system } = input;
+  const systemAddress = await systemContracts[systemKey];
+  return {
+    func: "registerSystem",
+    args: [resourceIdToHex({ type: "system", namespace, name: system.name }), systemAddress, system.openAccess],
+  };
+}

package/src/utils/systems/types.ts

@@ -0,0 +1,9 @@
+export type System = {
+  name: string;
+  registerFunctionSelectors: boolean;
+  openAccess: boolean;
+  accessListAddresses: string[];
+  accessListSystems: string[];
+};
+
+export type SystemsConfig = Record<string, System>;

package/src/utils/systems/utils.ts

@@ -0,0 +1,42 @@
+import { ethers } from "ethers";
+import { ParamType } from "ethers/lib/utils.js";
+import { getContractData } from "../utils/getContractData";
+
+export function loadFunctionSignatures(contractName: string, forgeOutDirectory: string): string[] {
+  const { abi } = getContractData(contractName, forgeOutDirectory);
+
+  return abi
+    .filter((item) => ["fallback", "function"].includes(item.type))
+    .map((item) => {
+      return `${item.name}${parseComponents(item.inputs)}`;
+    });
+}
+
+// TODO: move this to utils as soon as utils are usable inside cli
+// (see https://github.com/latticexyz/mud/issues/499)
+export function toFunctionSelector(functionSignature: string): string {
+  return sigHash(functionSignature);
+}
+
+/**
+ * Recursively turn (nested) structs in signatures into tuples
+ */
+function parseComponents(params: ParamType[]): string {
+  const components = params.map((param) => {
+    const tupleMatch = param.type.match(/tuple(.*)/);
+    if (tupleMatch) {
+      // there can be arrays of tuples,
+      // `tupleMatch[1]` preserves the array brackets (or is empty string for non-arrays)
+      return parseComponents(param.components) + tupleMatch[1];
+    } else {
+      return param.type;
+    }
+  });
+  return `(${components})`;
+}
+
+// TODO: move this to utils as soon as utils are usable inside cli
+// (see https://github.com/latticexyz/mud/issues/499)
+function sigHash(signature: string) {
+  return ethers.utils.hexDataSlice(ethers.utils.keccak256(ethers.utils.toUtf8Bytes(signature)), 0, 4);
+}

package/src/utils/tables/getRegisterTableCallData.ts

@@ -0,0 +1,49 @@
+import { encodeSchema, getStaticByteLength } from "@latticexyz/schema-type/deprecated";
+import { StoreConfig } from "@latticexyz/store";
+import { resolveAbiOrUserType } from "@latticexyz/store/codegen";
+import { resourceIdToHex } from "@latticexyz/common";
+import { Table } from "./types";
+import { fieldLayoutToHex } from "@latticexyz/protocol-parser";
+import { CallData } from "../utils/types";
+import { loadAndExtractUserTypes } from "@latticexyz/common/codegen";
+
+export function getRegisterTableCallData(
+  table: Table,
+  storeConfig: StoreConfig,
+  outputBaseDirectory: string,
+  remappings: [string, string][]
+): CallData {
+  const { name, valueSchema, keySchema } = table;
+  if (!name) throw Error("Table missing name");
+
+  const solidityUserTypes = loadAndExtractUserTypes(storeConfig.userTypes, outputBaseDirectory, remappings);
+
+  const schemaTypes = Object.values(valueSchema).map((abiOrUserType) => {
+    const { schemaType } = resolveAbiOrUserType(abiOrUserType, storeConfig, solidityUserTypes);
+    return schemaType;
+  });
+
+  const schemaTypeLengths = schemaTypes.map((schemaType) => getStaticByteLength(schemaType));
+  const fieldLayout = {
+    staticFieldLengths: schemaTypeLengths.filter((schemaTypeLength) => schemaTypeLength > 0),
+    numDynamicFields: schemaTypeLengths.filter((schemaTypeLength) => schemaTypeLength === 0).length,
+  };
+
+  const keyTypes = Object.values(keySchema).map((abiOrUserType) => {
+    const { schemaType } = resolveAbiOrUserType(abiOrUserType, storeConfig, solidityUserTypes);
+    return schemaType;
+  });
+
+  return {
+    func: "registerTable",
+    args: [
+      // TODO: add support for table namespaces (https://github.com/latticexyz/mud/issues/994)
+      resourceIdToHex({ type: table.offchainOnly ? "offchainTable" : "table", namespace: storeConfig.namespace, name }),
+      fieldLayoutToHex(fieldLayout),
+      encodeSchema(keyTypes),
+      encodeSchema(schemaTypes),
+      Object.keys(keySchema),
+      Object.keys(valueSchema),
+    ],
+  };
+}

package/src/utils/tables/getTableIds.ts

@@ -0,0 +1,21 @@
+import { StoreConfig } from "@latticexyz/store";
+import { TableIds } from "./types";
+import { toBytes16 } from "../utils/toBytes16";
+
+export function getTableIds(storeConfig: StoreConfig): TableIds {
+  const tableIds: TableIds = {};
+  for (const [tableName, { name }] of Object.entries(storeConfig.tables)) {
+    tableIds[tableName] = toResourceSelector(storeConfig.namespace, name);
+  }
+  return tableIds;
+}
+
+// (see https://github.com/latticexyz/mud/issues/499)
+function toResourceSelector(namespace: string, file: string): Uint8Array {
+  const namespaceBytes = toBytes16(namespace);
+  const fileBytes = toBytes16(file);
+  const result = new Uint8Array(32);
+  result.set(namespaceBytes);
+  result.set(fileBytes, 16);
+  return result;
+}

package/src/utils/tables/types.ts

@@ -0,0 +1,12 @@
+export type Table = {
+  valueSchema: Record<string, string>;
+  keySchema: Record<string, string>;
+  directory: string;
+  tableIdArgument: boolean;
+  storeArgument: boolean;
+  offchainOnly: boolean;
+  name?: string | undefined;
+  dataStruct?: boolean | undefined;
+};
+
+export type TableIds = { [tableName: string]: Uint8Array };

package/src/utils/utils/confirmNonce.ts

@@ -0,0 +1,24 @@
+import chalk from "chalk";
+import { Wallet } from "ethers";
+import { MUDError } from "@latticexyz/common/errors";
+
+export async function confirmNonce(signer: Wallet, nonce: number, pollInterval: number): Promise<void> {
+  let remoteNonce = await signer.getTransactionCount();
+  let retryCount = 0;
+  const maxRetries = 100;
+  while (remoteNonce !== nonce && retryCount < maxRetries) {
+    console.log(
+      chalk.gray(
+        `Waiting for transactions to be included before executing postDeployScript (local nonce: ${nonce}, remote nonce: ${remoteNonce}, retry number ${retryCount}/${maxRetries})`
+      )
+    );
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    retryCount++;
+    remoteNonce = await signer.getTransactionCount();
+  }
+  if (remoteNonce !== nonce) {
+    throw new MUDError(
+      "Remote nonce doesn't match local nonce, indicating that not all deploy transactions were included."
+    );
+  }
+}

package/src/utils/utils/deployContract.ts

@@ -0,0 +1,33 @@
+import chalk from "chalk";
+import { ethers } from "ethers";
+import { MUDError } from "@latticexyz/common/errors";
+import { TxConfig, ContractCode } from "./types";
+
+export async function deployContract(input: TxConfig & { nonce: number; contract: ContractCode }): Promise<string> {
+  const { signer, nonce, maxPriorityFeePerGas, maxFeePerGas, debug, gasPrice, confirmations, contract } = input;
+
+  try {
+    const factory = new ethers.ContractFactory(contract.abi, contract.bytecode, signer);
+    console.log(chalk.gray(`executing deployment of ${contract.name} with nonce ${nonce}`));
+    const deployPromise = factory
+      .deploy({
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gasPrice,
+      })
+      .then((c) => (confirmations ? c : c.deployed()));
+    const { address } = await deployPromise;
+    console.log(chalk.green("Deployed", contract.name, "to", address));
+    return address;
+  } catch (error: any) {
+    if (debug) console.error(error);
+    if (error?.message.includes("invalid bytecode")) {
+      throw new MUDError(
+        `Error deploying ${contract.name}: invalid bytecode. Note that linking of public libraries is not supported yet, make sure none of your libraries use "external" functions.`
+      );
+    } else if (error?.message.includes("CreateContractLimit")) {
+      throw new MUDError(`Error deploying ${contract.name}: CreateContractLimit exceeded.`);
+    } else throw error;
+  }
+}

package/src/utils/utils/fastTxExecute.ts

@@ -0,0 +1,56 @@
+import chalk from "chalk";
+import { TransactionReceipt, TransactionResponse } from "@ethersproject/providers";
+import { MUDError } from "@latticexyz/common/errors";
+import { TxConfig } from "./types";
+
+/**
+ * Only await gas estimation (for speed), only execute if gas estimation succeeds (for safety)
+ */
+export async function fastTxExecute<
+  C extends { connect: any; estimateGas: any; [key: string]: any },
+  F extends keyof C
+>(
+  input: TxConfig & {
+    nonce: number;
+    contract: C;
+    func: F;
+    args: Parameters<C[F]>;
+    confirmations: number;
+  }
+): Promise<TransactionResponse | TransactionReceipt> {
+  const {
+    func,
+    args,
+    contract,
+    signer,
+    nonce,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gasPrice,
+    confirmations = 1,
+    debug,
+  } = input;
+  const functionName = `${func as string}(${args.map((arg) => `'${arg}'`).join(",")})`;
+  try {
+    const contractWithSigner = contract.connect(signer);
+    const gasLimit = await contractWithSigner.estimateGas[func].apply(null, args);
+    console.log(chalk.gray(`executing transaction: ${functionName} with nonce ${nonce}`));
+    return contractWithSigner[func]
+      .apply(null, [
+        ...args,
+        {
+          gasLimit,
+          nonce: nonce,
+          maxPriorityFeePerGas: maxPriorityFeePerGas,
+          maxFeePerGas: maxFeePerGas,
+          gasPrice: gasPrice,
+        },
+      ])
+      .then((tx: TransactionResponse) => {
+        return confirmations === 0 ? tx : tx.wait(confirmations);
+      });
+  } catch (error: any) {
+    if (debug) console.error(error);
+    throw new MUDError(`Gas estimation error for ${functionName}: ${error?.reason}`);
+  }
+}

package/src/utils/utils/getContractData.ts

@@ -0,0 +1,29 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { Fragment } from "ethers/lib/utils.js";
+import { MUDError } from "@latticexyz/common/errors";
+
+/**
+ * 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[] } {
+  let data: any;
+  const contractDataPath = path.join(forgeOutDirectory, contractName + ".sol", contractName + ".json");
+  try {
+    data = JSON.parse(readFileSync(contractDataPath, "utf8"));
+  } catch (error: any) {
+    throw new MUDError(`Error reading file at ${contractDataPath}`);
+  }
+
+  const bytecode = data?.bytecode?.object;
+  if (!bytecode) throw new MUDError(`No bytecode found in ${contractDataPath}`);
+
+  const abi = data?.abi;
+  if (!abi) throw new MUDError(`No ABI found in ${contractDataPath}`);
+
+  return { abi, bytecode };
+}

package/src/utils/utils/postDeploy.ts

@@ -0,0 +1,25 @@
+import { existsSync } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { getScriptDirectory, forge } from "@latticexyz/common/foundry";
+
+export async function postDeploy(
+  postDeployScript: string,
+  worldAddress: string,
+  rpc: string,
+  profile: string | undefined
+): Promise<void> {
+  // Execute postDeploy forge script
+  const postDeployPath = path.join(await getScriptDirectory(), postDeployScript + ".s.sol");
+  if (existsSync(postDeployPath)) {
+    console.log(chalk.blue(`Executing post deploy script at ${postDeployPath}`));
+    await forge(
+      ["script", postDeployScript, "--sig", "run(address)", worldAddress, "--broadcast", "--rpc-url", rpc, "-vvv"],
+      {
+        profile: profile,
+      }
+    );
+  } else {
+    console.log(`No script at ${postDeployPath}, skipping post deploy hook`);
+  }
+}

package/src/utils/utils/setInternalFeePerGas.ts

@@ -0,0 +1,49 @@
+import { BigNumber, Wallet } from "ethers";
+import { MUDError } from "@latticexyz/common/errors";
+
+/**
+ * Set the maxFeePerGas and maxPriorityFeePerGas based on the current base fee and the given multiplier.
+ * The multiplier is used to allow replacing pending transactions.
+ * @param multiplier Multiplier to apply to the base fee
+ */
+export async function setInternalFeePerGas(
+  signer: Wallet,
+  multiplier: number
+): Promise<{
+  maxPriorityFeePerGas: number | undefined;
+  maxFeePerGas: BigNumber | undefined;
+  gasPrice: BigNumber | undefined;
+}> {
+  // Compute maxFeePerGas and maxPriorityFeePerGas like ethers, but allow for a multiplier to allow replacing pending transactions
+  const feeData = await signer.provider.getFeeData();
+  let maxPriorityFeePerGas: number | undefined;
+  let maxFeePerGas: BigNumber | undefined;
+  let gasPrice: BigNumber | undefined;
+
+  if (feeData.lastBaseFeePerGas) {
+    if (!feeData.lastBaseFeePerGas.eq(0) && (await signer.getBalance()).eq(0)) {
+      throw new MUDError(`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 signer.getAddress()}'`);
+    }
+
+    // Set the priority fee to 0 for development chains with no base fee, to allow transactions from unfunded wallets
+    maxPriorityFeePerGas = feeData.lastBaseFeePerGas.eq(0) ? 0 : Math.floor(1_500_000_000 * multiplier);
+    maxFeePerGas = feeData.lastBaseFeePerGas.mul(2).add(maxPriorityFeePerGas);
+  } else if (feeData.gasPrice) {
+    // Legacy chains with gasPrice instead of maxFeePerGas
+    if (!feeData.gasPrice.eq(0) && (await signer.getBalance()).eq(0)) {
+      throw new MUDError(
+        `Attempting to deploy to a chain with non-zero gas price with an account that has no balance.`
+      );
+    }
+
+    gasPrice = feeData.gasPrice;
+  } else {
+    throw new MUDError("Can not fetch fee data from RPC");
+  }
+  return {
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gasPrice,
+  };
+}

package/src/utils/utils/toBytes16.ts

@@ -0,0 +1,16 @@
+// TODO: use stringToBytes16 from utils as soon as utils are usable inside cli
+// (see https://github.com/latticexyz/mud/issues/499)
+export function toBytes16(input: string) {
+  if (input.length > 16) throw new Error("String does not fit into 16 bytes");
+
+  const result = new Uint8Array(16);
+  // Set ascii bytes
+  for (let i = 0; i < input.length; i++) {
+    result[i] = input.charCodeAt(i);
+  }
+  // Set the remaining bytes to 0
+  for (let i = input.length; i < 16; i++) {
+    result[i] = 0;
+  }
+  return result;
+}

package/src/utils/utils/types.ts

@@ -0,0 +1,21 @@
+import { BigNumber, ContractInterface, ethers } from "ethers";
+
+export type CallData = {
+  func: string;
+  args: unknown[];
+};
+
+export type ContractCode = {
+  name: string;
+  abi: ContractInterface;
+  bytecode: string | { object: string };
+};
+
+export type TxConfig = {
+  signer: ethers.Wallet;
+  maxPriorityFeePerGas: number | undefined;
+  maxFeePerGas: BigNumber | undefined;
+  gasPrice: BigNumber | undefined;
+  debug: boolean;
+  confirmations: number;
+};

package/src/utils/world.ts

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+
+import WorldData from "@latticexyz/world/out/World.sol/World.json" assert { type: "json" };
+import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
+import { deployContract } from "./utils/deployContract";
+import { getContractData } from "./utils/getContractData";
+import { TxConfig } from "./utils/types";
+
+export async function deployWorldContract(
+  ip: TxConfig & {
+    nonce: number;
+    worldContractName: string | undefined;
+    forgeOutDirectory: string;
+  }
+): Promise<string> {
+  console.log(chalk.blue(`Deploying World`));
+  const contractData = ip.worldContractName
+    ? {
+        name: "World",
+        ...getContractData(ip.worldContractName, ip.forgeOutDirectory),
+      }
+    : { abi: IBaseWorldAbi, bytecode: WorldData.bytecode, name: "World" };
+  return deployContract({
+    ...ip,
+    nonce: ip.nonce,
+    contract: contractData,
+  });
+}

package/dist/chunk-OJAPOMSC.js

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