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

package/src/utils/deployHandler.ts

@@ -1,93 +0,0 @@
-import chalk from "chalk";
-import path from "path";
-import { MUDError } from "@latticexyz/common/errors";
-import { loadConfig } from "@latticexyz/config/node";
-import { StoreConfig } from "@latticexyz/store";
-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 { getExistingContracts } from "./getExistingContracts";
-import { execa } from "execa";
-import { getChainId } from "./utils/getChainId";
-
-export type DeployOptions = {
-  configPath?: string;
-  printConfig?: boolean;
-  profile?: string;
-  priorityFeeMultiplier: number;
-  clean?: boolean;
-  debug?: boolean;
-  saveDeployment: boolean;
-  rpc?: string;
-  worldAddress?: string;
-  srcDir?: string;
-  disableTxWait: boolean;
-  pollInterval: number;
-  skipBuild?: boolean;
-};
-
-export async function deployHandler(args: DeployOptions) {
-  args.profile ??= process.env.FOUNDRY_PROFILE;
-  const { configPath, printConfig, profile, clean, skipBuild } = args;
-
-  const rpc = args.rpc ?? (await getRpcUrl(profile));
-  console.log(
-    chalk.bgBlue(
-      chalk.whiteBright(`\n Deploying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} \n`)
-    )
-  );
-
-  if (clean) {
-    await forge(["clean"], { profile });
-  }
-
-  // Run forge build
-  if (!skipBuild) {
-    await forge(["build", "--skip", "test", "script"], { profile });
-    await execa("mud", ["abi-ts"], { stdio: "inherit" });
-  }
-
-  // Get a list of all contract names
-  const srcDir = args?.srcDir ?? (await getSrcDirectory());
-  const existingContractNames = getExistingContracts(srcDir).map(({ basename }) => basename);
-
-  // Load the config
-  const mudConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
-
-  if (printConfig) console.log(chalk.green("\nResolved config:\n"), JSON.stringify(mudConfig, null, 2));
-
-  const privateKey = process.env.PRIVATE_KEY;
-  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 deploymentInfo = await deploy(mudConfig, existingContractNames, { ...args, rpc, privateKey });
-
-  if (args.saveDeployment) {
-    // Write deployment result to file (latest and timestamp)
-    const chainId = await getChainId(rpc);
-    const outputDir = path.join(mudConfig.deploysDirectory, chainId.toString());
-    mkdirSync(outputDir, { recursive: true });
-    writeFileSync(path.join(outputDir, "latest.json"), JSON.stringify(deploymentInfo, null, 2));
-    writeFileSync(path.join(outputDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2));
-
-    const localChains = [1337, 31337];
-    const deploys = existsSync(mudConfig.worldsFile) ? JSON.parse(readFileSync(mudConfig.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(mudConfig.worldsFile, JSON.stringify(deploys, null, 2));
-
-    console.log(
-      chalk.bgGreen(chalk.whiteBright(`\n Deployment result (written to ${mudConfig.worldsFile} and ${outputDir}): \n`))
-    );
-  }
-
-  console.log(deploymentInfo);
-  return deploymentInfo;
-}

package/src/utils/modules/getInstallModuleCallData.ts

@@ -1,27 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,18 +0,0 @@
-import { StoreConfig } from "@latticexyz/store";
-import { TableIds } from "./types";
-import { resourceIdToHex } from "@latticexyz/common";
-import { hexToBytes } from "viem";
-
-export function getTableIds(storeConfig: StoreConfig): TableIds {
-  const tableIds: TableIds = {};
-  for (const [tableName, { name, offchainOnly }] of Object.entries(storeConfig.tables)) {
-    tableIds[tableName] = hexToBytes(
-      resourceIdToHex({
-        type: offchainOnly ? "offchainTable" : "table",
-        namespace: storeConfig.namespace,
-        name,
-      })
-    );
-  }
-  return tableIds;
-}

package/src/utils/tables/types.ts

@@ -1,12 +0,0 @@
-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

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

@@ -1,33 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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/getChainId.ts

@@ -1,10 +0,0 @@
-import { ethers } from "ethers";
-
-// TODO: Use viem's getChainId
-export async function getChainId(rpc: string) {
-  const { result: chainId } = await ethers.utils.fetchJson(
-    rpc,
-    '{ "id": 42, "jsonrpc": "2.0", "method": "eth_chainId", "params": [ ] }'
-  );
-  return Number(chainId);
-}

package/src/utils/utils/setInternalFeePerGas.ts

@@ -1,49 +0,0 @@
-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/types.ts

@@ -1,21 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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,
-  });
-}