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

package/src/utils/deployHandler.ts

@@ -7,8 +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;
@@ -37,10 +38,15 @@ export async function deployHandler(args: DeployOptions) {
     )
   );
 
-  if (clean) await forge(["clean"], { profile });
+  if (clean) {
+    await forge(["clean"], { profile });
+  }
 
   // Run forge build
-  if (!skipBuild) await forge(["build"], { profile });
+  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());

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,18 @@
+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

@@ -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/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,
+  });
+}