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

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

@@ -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/toBytes16.ts

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

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