@latticexyz/cli 0.10.0 → 0.12.0

package/src/commands/system-types.ts

@@ -0,0 +1,98 @@
+import fs from "fs";
+import glob from "glob";
+import type { CommandBuilder } from "yargs";
+import { deferred, extractIdFromFile } from "../utils";
+
+type Options = Record<string, never>;
+
+export const command = "system-types";
+export const desc =
+  "Generates system type file. Note: assumes ABIs of all systems in ./abi and typechain generated types in ./types/ethers-contracts";
+
+export const builder: CommandBuilder<Options, Options> = (yargs) =>
+  yargs.options({
+    include: { type: "array" },
+    exclude: { type: "array" },
+    out: { type: "string" },
+  });
+
+export const handler = async (): Promise<void> => {
+  const wd = process.cwd();
+  let abis: string[] = [];
+  let systems: string[] = [];
+  let ids: string[] = [];
+  let typePaths: string[] = [];
+
+  const systemsPath = `${wd}/src/systems/*.sol`;
+
+  const [resolve, , promise] = deferred<void>();
+  glob(systemsPath, {}, (_, matches) => {
+    systems = matches.map((path) => {
+      const fragments = path.split("/");
+      return fragments[fragments.length - 1].split(".sol")[0];
+    });
+
+    ids = matches.map((path, index) => {
+      const id = extractIdFromFile(path);
+      if (!id) {
+        console.log("Path:", path);
+        console.log("ID:", id);
+        throw new Error(
+          "No ID found for" +
+            matches[index] +
+            ". Make sure your system source file includes a ID definition (uint256 constant ID = uint256(keccak256(<ID>));)"
+        );
+      }
+      return id;
+    });
+
+    abis = systems.map((system) => `../abi/${system}.json`);
+
+    typePaths = systems.map((system) => `./ethers-contracts/${system}.ts`);
+
+    resolve();
+  });
+
+  // Make the callback synchronous
+  await promise;
+
+  console.log("Matches", systems);
+  console.log("Solidity", ids);
+  console.log("Type paths", typePaths);
+  console.log("ABIs", abis);
+
+  const SystemMappings = `// Autogenerated using mud system-types
+export const systemToId = {
+${systems.map((system, index) => `  ${system}: "${ids[index]}",`).join("\n")}
+};
+
+export const idToSystem = {
+${ids.map((id, index) => `  "${id}": "${systems[index]}",`).join("\n")}
+};
+  `;
+
+  const SystemTypes = `// Autogenerated using mud system-types
+${typePaths.map((path, index) => `import { ${systems[index]} } from "${path.replace(".ts", "")}";`).join("\n")}
+ 
+export type SystemTypes = {
+${systems.map((system, index) => `  "${ids[index]}": ${system};`).join("\n")}
+};
+`;
+
+  const SystemAbis = `// Autogenerated using mud system-types
+${abis.map((path, index) => `import ${systems[index]} from "${path}";`).join("\n")}
+
+export const SystemAbis = {
+${systems.map((system, index) => `  "${ids[index]}": ${system}.abi,`).join("\n")}
+};
+`;
+
+  console.log("Generating files:");
+  console.log("SystemTypes.ts", SystemTypes);
+  console.log("SystemAbis.mts", SystemAbis);
+  console.log("SystemMappings.ts", SystemMappings);
+
+  fs.writeFileSync("./types/SystemTypes.ts", SystemTypes);
+  fs.writeFileSync("./types/SystemAbis.mts", SystemAbis);
+  fs.writeFileSync("./types/SystemMappings.ts", SystemMappings);
+};

package/src/commands/trace.ts

@@ -0,0 +1,69 @@
+import { Arguments, CommandBuilder } from "yargs";
+import { execLog, extractIdFromFile, keccak256 } from "../utils";
+import { readFileSync } from "fs";
+import { Contract } from "ethers";
+import { JsonRpcProvider } from "@ethersproject/providers";
+import { abi as WorldAbi } from "@latticexyz/solecs/abi/World.json";
+
+type Options = {
+  config?: string;
+  world: string;
+  tx: string;
+  rpc?: string;
+  debug?: boolean;
+};
+
+export const command = "trace";
+export const desc = "Display the trace of a transaction";
+
+export const builder: CommandBuilder<Options, Options> = (yargs) =>
+  yargs.options({
+    config: { type: "string", description: "path to mud deploy config (deploy.json)" },
+    world: { type: "string", required: true, description: "world contract address" },
+    tx: { type: "string", required: true, description: "tx hash to replay" },
+    rpc: { type: "string", description: "json rpc endpoint, defaults to http://localhost:8545" },
+    debug: { type: "boolean", description: "open debugger" },
+  });
+
+export const handler = async (argv: Arguments<Options>): Promise<void> => {
+  const { config, world, rpc, tx, debug } = argv;
+  const wd = process.cwd();
+  const deployData = config && JSON.parse(readFileSync(config, { encoding: "utf8" }));
+  const labels = [];
+
+  const provider = new JsonRpcProvider(rpc || "http://localhost:8545");
+  const World = new Contract(world, WorldAbi, provider);
+
+  if (deployData) {
+    // Create component labels
+    const componentPromises = deployData.components.map(async (component: string) => {
+      const path = `${wd}/src/components/${component}.sol`;
+      const id = extractIdFromFile(path);
+      if (!id) return;
+      const address = await World.getComponent(keccak256(id));
+      return [component, address];
+    });
+    // Create system labels
+    const systemPromises = deployData.systems.map(async (system: { name: string }) => {
+      const path = `${wd}/src/systems/${system.name}.sol`;
+      const id = extractIdFromFile(path);
+      if (!id) return;
+      const address = await World.getSystemAddress(keccak256(id));
+      return [system.name, address];
+    });
+
+    const components = await Promise.all(componentPromises);
+    const systems = await Promise.all(systemPromises);
+
+    labels.push(...components, ...systems);
+  }
+
+  await execLog("cast", [
+    "run",
+    ...labels.map((label) => ["--label", `${label[1]}:${label[0]}`]).flat(),
+    ...(debug ? ["--debug"] : []),
+    `${tx}`,
+  ]);
+
+  process.exit(0);
+};

package/src/contracts/BulkUpload.sol

@@ -0,0 +1,183 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity >=0.8.0;
+
+import "ds-test/test.sol";
+import {console} from "forge-std/console.sol";
+import {Cheats} from "./Cheats.sol";
+import {BulkSetStateSystem, ID as BulkSetStateSystemID, ECSEvent} from "std-contracts/systems/BulkSetStateSystem.sol";
+import {World} from "solecs/World.sol";
+import {System} from "solecs/System.sol";
+import {getAddressById} from "solecs/utils.sol";
+import {Set} from "solecs/Set.sol";
+
+struct ParsedState {
+  string[] componentIds;
+  string[] entities;
+  ParsedECSEvent[] state;
+}
+
+struct ParsedECSEvent {
+  uint8 component;
+  uint32 entity;
+  string value;
+}
+
+struct State {
+  uint256[] componentIds;
+  uint256[] entities;
+  ECSEvent[] state;
+}
+
+/**
+ * Usage:
+ * forge script --sig "run(string, address)" --rpc-url http://localhost:8545 src/contracts/BulkUpload.sol:BulkUpload path/to/ecs-map-test.json <WORLD_ADDRESS>
+ */
+contract BulkUpload is DSTest {
+  Cheats internal immutable vm = Cheats(HEVM_ADDRESS);
+
+  function run(
+    string memory path,
+    address worldAddress,
+    uint256 eventsPerTx
+  ) public {
+    vm.startBroadcast();
+
+    // Read JSON
+    console.log(path);
+    string memory json = vm.readFile(path);
+
+    console.log(worldAddress);
+
+    // Parse JSON
+    ParsedState memory parsedState = abi.decode(vm.parseJson(json), (ParsedState));
+
+    // Convert component ids
+    uint256[] memory componentIds = new uint256[](parsedState.componentIds.length);
+    for (uint256 i; i < componentIds.length; i++) {
+      componentIds[i] = hexToUint256(parsedState.componentIds[i]);
+    }
+
+    // Convert entitiy ids
+    uint256[] memory entities = new uint256[](parsedState.entities.length);
+    for (uint256 i; i < entities.length; i++) {
+      entities[i] = hexToUint256(parsedState.entities[i]);
+    }
+    World world = World(worldAddress);
+    System bulkSetStateSystem = System(getAddressById(world.systems(), BulkSetStateSystemID));
+
+    // Convert state
+    ECSEvent[] memory allEvents = new ECSEvent[](parsedState.state.length);
+    for (uint256 i; i < parsedState.state.length; i++) {
+      ParsedECSEvent memory p = parsedState.state[i];
+
+      // Convert value hex string to bytes
+      bytes memory value = hexToBytes(substring(p.value, 2, bytes(p.value).length));
+      allEvents[i] = ECSEvent(p.component, p.entity, value);
+    }
+
+    uint256 numTxs = allEvents.length / eventsPerTx;
+
+    for (uint256 i = 0; i < numTxs; i++) {
+      ECSEvent[] memory events = new ECSEvent[](eventsPerTx);
+      for (uint256 j = 0; j < eventsPerTx; j++) {
+        events[j] = allEvents[i * eventsPerTx + j];
+      }
+
+      (uint256[] memory newEntities, ECSEvent[] memory newEvents) = transformEventsToOnlyUseNeededEntities(
+        entities,
+        events
+      );
+
+      bulkSetStateSystem.execute(abi.encode(componentIds, newEntities, newEvents));
+    }
+
+    // overflow tx
+    uint256 overflowEventCount = allEvents.length - numTxs * eventsPerTx;
+
+    ECSEvent[] memory overflowEvents = new ECSEvent[](overflowEventCount);
+    for (uint256 j = 0; j < overflowEventCount; j++) {
+      overflowEvents[j] = allEvents[numTxs * eventsPerTx + j];
+    }
+
+    (
+      uint256[] memory newOverflowEntities,
+      ECSEvent[] memory newOverflowEvents
+    ) = transformEventsToOnlyUseNeededEntities(entities, overflowEvents);
+
+    bulkSetStateSystem.execute(abi.encode(componentIds, newOverflowEntities, newOverflowEvents));
+
+    vm.stopBroadcast();
+  }
+}
+
+function transformEventsToOnlyUseNeededEntities(uint256[] memory entities, ECSEvent[] memory events)
+  returns (uint256[] memory, ECSEvent[] memory)
+{
+  Set uniqueEntityIndices = new Set();
+
+  // Find unique entity indices
+  for (uint256 i = 0; i < events.length; i++) {
+    ECSEvent memory e = events[i];
+
+    uniqueEntityIndices.add(e.entity);
+  }
+
+  // Grab the Entity IDs from the big entities array and put them into our new array
+  uint256[] memory relevantEntities = new uint256[](uniqueEntityIndices.size());
+  for (uint256 i = 0; i < uniqueEntityIndices.size(); i++) {
+    relevantEntities[i] = entities[uniqueEntityIndices.getItems()[i]];
+  }
+
+  // Re-assign event entity indices to point to our new array
+  for (uint256 i = 0; i < events.length; i++) {
+    (, uint256 index) = uniqueEntityIndices.getIndex(events[i].entity);
+    events[i].entity = uint32(index);
+  }
+
+  return (relevantEntities, events);
+}
+
+function hexToUint8(bytes1 b) pure returns (uint8 res) {
+  if (b >= "0" && b <= "9") {
+    return uint8(b) - uint8(bytes1("0"));
+  } else if (b >= "A" && b <= "F") {
+    return 10 + uint8(b) - uint8(bytes1("A"));
+  } else if (b >= "a" && b <= "f") {
+    return 10 + uint8(b) - uint8(bytes1("a"));
+  }
+  return uint8(b); // or return error ...
+}
+
+function hexToUint256(string memory str) pure returns (uint256 value) {
+  bytes memory b = bytes(str);
+  uint256 number = 0;
+  for (uint256 i = 0; i < b.length; i++) {
+    number = number << 4; // or number = number * 16
+    number |= hexToUint8(b[i]); // or number += numberFromAscII(b[i]);
+  }
+  return number;
+}
+
+// Convert an hexadecimal string to raw bytes
+function hexToBytes(string memory s) pure returns (bytes memory) {
+  bytes memory ss = bytes(s);
+  require(ss.length % 2 == 0); // length must be even
+  bytes memory r = new bytes(ss.length / 2);
+  for (uint256 i = 0; i < ss.length / 2; ++i) {
+    r[i] = bytes1(hexToUint8(ss[2 * i]) * 16 + hexToUint8(ss[2 * i + 1]));
+  }
+  return r;
+}
+
+function substring(
+  string memory str,
+  uint256 start,
+  uint256 end
+) pure returns (string memory) {
+  bytes memory strBytes = bytes(str);
+  bytes memory result = new bytes(end - start);
+  for (uint256 i = start; i < end; i++) {
+    result[i - start] = strBytes[i];
+  }
+  return string(result);
+}

package/src/contracts/Cheats.sol

@@ -0,0 +1,320 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity >=0.8.0;
+
+interface Cheats {
+  // This allows us to getRecordedLogs()
+  struct Log {
+    bytes32[] topics;
+    bytes data;
+  }
+
+  // Set block.timestamp (newTimestamp)
+  function warp(uint256) external;
+
+  // Set block.height (newHeight)
+  function roll(uint256) external;
+
+  // Set block.basefee (newBasefee)
+  function fee(uint256) external;
+
+  // Set block.coinbase (who)
+  function coinbase(address) external;
+
+  // Loads a storage slot from an address (who, slot)
+  function load(address, bytes32) external returns (bytes32);
+
+  // Stores a value to an address' storage slot, (who, slot, value)
+  function store(
+    address,
+    bytes32,
+    bytes32
+  ) external;
+
+  // Signs data, (privateKey, digest) => (v, r, s)
+  function sign(uint256, bytes32)
+    external
+    returns (
+      uint8,
+      bytes32,
+      bytes32
+    );
+
+  // Gets address for a given private key, (privateKey) => (address)
+  function addr(uint256) external returns (address);
+
+  // Derive a private key from a provided mnenomic string (or mnenomic file path) at the derivation path m/44'/60'/0'/0/{index}
+  function deriveKey(string calldata, uint32) external returns (uint256);
+
+  // Derive a private key from a provided mnenomic string (or mnenomic file path) at the derivation path {path}{index}
+  function deriveKey(
+    string calldata,
+    string calldata,
+    uint32
+  ) external returns (uint256);
+
+  // Performs a foreign function call via terminal, (stringInputs) => (result)
+  function ffi(string[] calldata) external returns (bytes memory);
+
+  // Set environment variables, (name, value)
+  function setEnv(string calldata, string calldata) external;
+
+  // Read environment variables, (name) => (value)
+  function envBool(string calldata) external returns (bool);
+
+  function envUint(string calldata) external returns (uint256);
+
+  function envInt(string calldata) external returns (int256);
+
+  function envAddress(string calldata) external returns (address);
+
+  function envBytes32(string calldata) external returns (bytes32);
+
+  function envString(string calldata) external returns (string memory);
+
+  function envBytes(string calldata) external returns (bytes memory);
+
+  // Read environment variables as arrays, (name, delim) => (value[])
+  function envBool(string calldata, string calldata) external returns (bool[] memory);
+
+  function envUint(string calldata, string calldata) external returns (uint256[] memory);
+
+  function envInt(string calldata, string calldata) external returns (int256[] memory);
+
+  function envAddress(string calldata, string calldata) external returns (address[] memory);
+
+  function envBytes32(string calldata, string calldata) external returns (bytes32[] memory);
+
+  function envString(string calldata, string calldata) external returns (string[] memory);
+
+  function envBytes(string calldata, string calldata) external returns (bytes[] memory);
+
+  // Sets the *next* call's msg.sender to be the input address
+  function prank(address) external;
+
+  // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
+  function startPrank(address) external;
+
+  // Sets the *next* call's msg.sender to be the input address, and the tx.origin to be the second input
+  function prank(address, address) external;
+
+  // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called, and the tx.origin to be the second input
+  function startPrank(address, address) external;
+
+  // Resets subsequent calls' msg.sender to be `address(this)`
+  function stopPrank() external;
+
+  // Sets an address' balance, (who, newBalance)
+  function deal(address, uint256) external;
+
+  // Sets an address' code, (who, newCode)
+  function etch(address, bytes calldata) external;
+
+  // Expects an error on next call
+  function expectRevert() external;
+
+  function expectRevert(bytes calldata) external;
+
+  function expectRevert(bytes4) external;
+
+  // Record all storage reads and writes
+  function record() external;
+
+  // Gets all accessed reads and write slot from a recording session, for a given address
+  function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
+
+  // Record all the transaction logs
+  function recordLogs() external;
+
+  // Gets all the recorded logs
+  function getRecordedLogs() external returns (Log[] memory);
+
+  // Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData).
+  // Call this function, then emit an event, then call a function. Internally after the call, we check if
+  // logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
+  // Second form also checks supplied address against emitting contract.
+  function expectEmit(
+    bool,
+    bool,
+    bool,
+    bool
+  ) external;
+
+  function expectEmit(
+    bool,
+    bool,
+    bool,
+    bool,
+    address
+  ) external;
+
+  // Mocks a call to an address, returning specified data.
+  // Calldata can either be strict or a partial match, e.g. if you only
+  // pass a Solidity selector to the expected calldata, then the entire Solidity
+  // function will be mocked.
+  function mockCall(
+    address,
+    bytes calldata,
+    bytes calldata
+  ) external;
+
+  // Mocks a call to an address with a specific msg.value, returning specified data.
+  // Calldata match takes precedence over msg.value in case of ambiguity.
+  function mockCall(
+    address,
+    uint256,
+    bytes calldata,
+    bytes calldata
+  ) external;
+
+  // Clears all mocked calls
+  function clearMockedCalls() external;
+
+  // Expect a call to an address with the specified calldata.
+  // Calldata can either be strict or a partial match
+  function expectCall(address, bytes calldata) external;
+
+  // Expect a call to an address with the specified msg.value and calldata
+  function expectCall(
+    address,
+    uint256,
+    bytes calldata
+  ) external;
+
+  // Gets the code from an artifact file. Takes in the relative path to the json file
+  function getCode(string calldata) external returns (bytes memory);
+
+  // Labels an address in call traces
+  function label(address, string calldata) external;
+
+  // If the condition is false, discard this run's fuzz inputs and generate new ones
+  function assume(bool) external;
+
+  // Set nonce for an account
+  function setNonce(address, uint64) external;
+
+  // Get nonce for an account
+  function getNonce(address) external returns (uint64);
+
+  // Set block.chainid (newChainId)
+  function chainId(uint256) external;
+
+  // Using the address that calls the test contract, has the next call (at this call depth only) create a transaction that can later be signed and sent onchain
+  function broadcast() external;
+
+  // Has the next call (at this call depth only) create a transaction with the address provided as the sender that can later be signed and sent onchain
+  function broadcast(address) external;
+
+  // Using the address that calls the test contract, has the all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain
+  function startBroadcast() external;
+
+  // Has the all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain
+  function startBroadcast(address) external;
+
+  // Stops collecting onchain transactions
+  function stopBroadcast() external;
+
+  // Reads the entire content of file to string. Path is relative to the project root. (path) => (data)
+  function readFile(string calldata) external returns (string memory);
+
+  // Reads next line of file to string, (path) => (line)
+  function readLine(string calldata) external returns (string memory);
+
+  // Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.
+  // Path is relative to the project root. (path, data) => ()
+  function writeFile(string calldata, string calldata) external;
+
+  // Writes line to file, creating a file if it does not exist.
+  // Path is relative to the project root. (path, data) => ()
+  function writeLine(string calldata, string calldata) external;
+
+  // Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.
+  // Path is relative to the project root. (path) => ()
+  function closeFile(string calldata) external;
+
+  // Removes file. This cheatcode will revert in the following situations, but is not limited to just these cases:
+  // - Path points to a directory.
+  // - The file doesn't exist.
+  // - The user lacks permissions to remove the file.
+  // Path is relative to the project root. (path) => ()
+  function removeFile(string calldata) external;
+
+  function toString(address) external returns (string memory);
+
+  function toString(bytes calldata) external returns (string memory);
+
+  function toString(bytes32) external returns (string memory);
+
+  function toString(bool) external returns (string memory);
+
+  function toString(uint256) external returns (string memory);
+
+  function toString(int256) external returns (string memory);
+
+  // Snapshot the current state of the evm.
+  // Returns the id of the snapshot that was created.
+  // To revert a snapshot use `revertTo`
+  function snapshot() external returns (uint256);
+
+  // Revert the state of the evm to a previous snapshot
+  // Takes the snapshot id to revert to.
+  // This deletes the snapshot and all snapshots taken after the given snapshot id.
+  function revertTo(uint256) external returns (bool);
+
+  // Creates a new fork with the given endpoint and block and returns the identifier of the fork
+  function createFork(string calldata, uint256) external returns (uint256);
+
+  // Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork
+  function createFork(string calldata) external returns (uint256);
+
+  // Creates _and_ also selects a new fork with the given endpoint and block and returns the identifier of the fork
+  function createSelectFork(string calldata, uint256) external returns (uint256);
+
+  // Creates _and_ also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork
+  function createSelectFork(string calldata) external returns (uint256);
+
+  // Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
+  function selectFork(uint256) external;
+
+  // Returns the currently active fork
+  // Reverts if no fork is currently active
+  function activeFork() external returns (uint256);
+
+  // Marks that the account(s) should use persistent storage across fork swaps.
+  // Meaning, changes made to the state of this account will be kept when switching forks
+  function makePersistent(address) external;
+
+  function makePersistent(address, address) external;
+
+  function makePersistent(
+    address,
+    address,
+    address
+  ) external;
+
+  function makePersistent(address[] calldata) external;
+
+  // Revokes persistent status from the address, previously added via `makePersistent`
+  function revokePersistent(address) external;
+
+  function revokePersistent(address[] calldata) external;
+
+  // Returns true if the account is marked as persistent
+  function isPersistent(address) external returns (bool);
+
+  // Updates the currently active fork to given block number
+  // This is similar to `roll` but for the currently active fork
+  function rollFork(uint256) external;
+
+  // Updates the given fork to given block number
+  function rollFork(uint256 forkId, uint256 blockNumber) external;
+
+  /// Returns the RPC url for the given alias
+  function rpcUrl(string calldata) external returns (string memory);
+
+  /// Returns all rpc urls and their aliases `[alias, url][]`
+  function rpcUrls() external returns (string[2][] memory);
+
+  function parseJson(string calldata, string calldata) external returns (bytes memory);
+
+  function parseJson(string calldata) external returns (bytes memory);
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+yargs(hideBin(process.argv))
+  // Use the commands directory to scaffold.
+  .commandDir("commands")
+  // Enable strict mode.
+  .strict()
+  // Useful aliases.
+  .alias({ h: "help" }).argv;