@latticexyz/cli 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/chunk-VQTZJIFF.js

@@ -0,0 +1,353 @@
+import {
+  getOutDirectory,
+  getSrcDirectory
+} from "./chunk-FPG73MVN.js";
+
+// src/utils/deprecated/exec.ts
+import { execa } from "execa";
+function execLog(command, options) {
+  console.log("Cmd:");
+  console.log([command, ...options].join(" "));
+  return execa(command, options, {
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+}
+
+// src/utils/deprecated/ids.ts
+import { keccak256 as keccak256Bytes, toUtf8Bytes } from "ethers/lib/utils.js";
+import { readFileSync } from "fs";
+var IDregex = new RegExp(/(?<=uint256 constant ID = uint256\(keccak256\(")(.*)(?="\))/);
+function extractIdFromFile(path5) {
+  const content = readFileSync(path5).toString();
+  const regexResult = IDregex.exec(content);
+  return regexResult && regexResult[0];
+}
+function keccak256(data) {
+  return keccak256Bytes(toUtf8Bytes(data));
+}
+
+// src/utils/deprecated/codegen.ts
+import { readFile, writeFile } from "fs/promises";
+import ejs from "ejs";
+import path from "path";
+var contractsDirectory = new URL("../src/contracts", import.meta.url).pathname;
+var stubLibDeploy = readFile(path.join(contractsDirectory, "LibDeployStub.sol"));
+async function generateLibDeploy(configPath, out, systems) {
+  const config = JSON.parse(await readFile(configPath, { encoding: "utf8" }));
+  config.initializers ??= [];
+  if (systems) {
+    const systemsArray = Array.isArray(systems) ? systems : [systems];
+    config.systems = config.systems.filter((system) => systemsArray.includes(system.name));
+  }
+  console.log(`Deploy config: 
+`, JSON.stringify(config, null, 2));
+  console.log("Generating deployment script");
+  const LibDeploy = await ejs.renderFile(path.join(contractsDirectory, "LibDeploy.ejs"), config, { async: true });
+  const libDeployPath = path.join(out, "LibDeploy.sol");
+  await writeFile(libDeployPath, LibDeploy);
+  return libDeployPath;
+}
+async function resetLibDeploy(out) {
+  await writeFile(path.join(out, "LibDeploy.sol"), await stubLibDeploy);
+}
+
+// src/utils/deprecated/deploy.ts
+import { constants, Wallet } from "ethers";
+
+// src/utils/deprecated/findLog.ts
+function findLog(deployLogLines, log) {
+  for (const logLine of deployLogLines) {
+    if (logLine.includes(log)) {
+      return logLine.split(log)[1].trim();
+    }
+  }
+  throw new Error("Can not find log");
+}
+
+// src/utils/deprecated/typegen.ts
+import { runTypeChain, glob as typechainGlob } from "typechain";
+import glob from "glob";
+import { rmSync as rmSync2, writeFileSync } from "fs";
+import path3 from "path";
+
+// src/utils/deprecated/build.ts
+import { execa as execa2 } from "execa";
+import { copyFileSync, mkdirSync, readdirSync, rmSync } from "fs";
+import path2 from "path";
+async function forgeBuild(options) {
+  if (options?.clear) {
+    const out = await getOutDirectory();
+    console.log("Clearing forge build output directory", out);
+    rmSync(out, { recursive: true, force: true });
+  }
+  console.log("Running forge build");
+  const child = execa2("forge", ["build"], {
+    stdio: ["inherit", "pipe", "inherit"]
+  });
+  return (await child).stdout;
+}
+function getContractsInDirectory(dir, exclude) {
+  return readdirSync(dir).filter((item) => item.includes(".sol")).map((item) => item.replace(".sol", "")).filter((item) => !exclude?.includes(item));
+}
+function copyAbi(inDir, outDir, contract) {
+  try {
+    return copyFileSync(path2.join(inDir, contract + ".sol", contract + ".json"), path2.join(outDir, contract + ".json"));
+  } catch (e) {
+    console.log("Skipping", contract);
+  }
+}
+function filterAbi(abiIn = "./out", abiOut = "./abi", exclude = ["Component", "IComponent"]) {
+  console.log(`Cleaning output directory (${abiOut}})`);
+  rmSync(abiOut, { recursive: true, force: true });
+  mkdirSync(abiOut);
+  const include = ["Component", "System", "World", "LibQuery"];
+  const contracts = getContractsInDirectory(abiIn, exclude).filter((item) => include.find((i) => item.includes(i)));
+  console.log("Selected ABIs: ", contracts);
+  for (const contract of contracts) {
+    if (contract.includes(".t"))
+      continue;
+    copyAbi(abiIn, abiOut, contract);
+  }
+  console.log("Successfully moved selected ABIs to ./abi");
+}
+
+// src/utils/deprecated/constants.ts
+var systemsDir = "systems";
+var componentsDir = "components";
+
+// src/utils/deprecated/typegen.ts
+async function generateAbiTypes(inputDir, outputDir, options) {
+  if (options?.clear) {
+    console.log("Clearing typechain output directory", outputDir);
+    rmSync2(outputDir, { recursive: true, force: true });
+  }
+  const cwd = options?.cwd ?? process.cwd();
+  const allFiles = typechainGlob(cwd, [`${inputDir}/**/+([a-zA-Z0-9_]).json`]);
+  const result = await runTypeChain({
+    cwd,
+    filesToProcess: allFiles,
+    allFiles,
+    outDir: outputDir,
+    target: "ethers-v5"
+  });
+  console.log(`Successfully generated ${result.filesGenerated} files`);
+}
+async function generateSystemTypes(outputDir, options) {
+  if (options?.clear) {
+    console.log("Clearing system type output files", outputDir);
+    rmSync2(path3.join(outputDir, "/SystemTypes.ts"), { force: true });
+    rmSync2(path3.join(outputDir, "/SystemAbis.mts"), { force: true });
+    rmSync2(path3.join(outputDir, "/SystemAbis.mjs"), { force: true });
+    rmSync2(path3.join(outputDir, "/SystemMappings.ts"), { force: true });
+  }
+  let abis = [];
+  let systems = [];
+  let ids = [];
+  let typePaths = [];
+  const srcDir = await getSrcDirectory();
+  const systemsPath = path3.join(srcDir, systemsDir, "*.sol");
+  const matches = glob.sync(systemsPath);
+  systems = matches.map((path5) => {
+    const fragments = path5.split("/");
+    return fragments[fragments.length - 1].split(".sol")[0];
+  });
+  ids = matches.map((path5, index) => {
+    const id = extractIdFromFile(path5);
+    if (!id) {
+      console.log("Path:", path5);
+      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`);
+  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((path5, index) => `import { ${systems[index]} } from "${path5.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((path5, index) => `import ${systems[index]} from "${path5}";`).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);
+  writeFileSync(`${outputDir}/SystemTypes.ts`, SystemTypes);
+  writeFileSync(`${outputDir}/SystemAbis.mts`, SystemAbis);
+  writeFileSync(`${outputDir}/SystemAbis.mjs`, SystemAbis);
+  writeFileSync(`${outputDir}/SystemMappings.ts`, SystemMappings);
+}
+async function generateTypes(abiDir, outputDir = "./types", options) {
+  if (!abiDir) {
+    console.log("Compiling contracts");
+    const buildOutput = await getOutDirectory();
+    abiDir = "./abi";
+    await forgeBuild(options);
+    filterAbi(buildOutput, abiDir);
+  }
+  await generateAbiTypes(abiDir, path3.join(outputDir, "ethers-contracts"), options);
+  await generateSystemTypes(outputDir, options);
+}
+
+// src/utils/deprecated/deploy.ts
+import { execa as execa3 } from "execa";
+import { StaticJsonRpcProvider } from "@ethersproject/providers";
+import path4 from "path";
+var contractsDirectory2 = new URL("../src/contracts", import.meta.url).pathname;
+async function deploy(deployerPrivateKey, rpc = "http://localhost:8545", worldAddress, reuseComponents, gasPrice) {
+  const address = deployerPrivateKey ? new Wallet(deployerPrivateKey).address : constants.AddressZero;
+  if (gasPrice == null) {
+    try {
+      console.log("Fetching gas price...");
+      const provider = new StaticJsonRpcProvider(rpc, { name: "AnyNetwork", chainId: 1234 });
+      gasPrice = (await provider.getGasPrice()).toNumber() * 1.3;
+      console.log("Gas price:", gasPrice);
+    } catch (e) {
+      console.log("Could not fetch gas price");
+    }
+  }
+  const child = execa3(
+    "forge",
+    [
+      "script",
+      path4.join(contractsDirectory2, "/Deploy.sol"),
+      "--target-contract",
+      "Deploy",
+      "-vvv",
+      ...!deployerPrivateKey ? [] : ["--broadcast", "--private-keys", deployerPrivateKey],
+      "--sig",
+      "broadcastDeploy(address,address,bool)",
+      address,
+      // Deployer
+      worldAddress || constants.AddressZero,
+      // World address (0 = deploy a new world)
+      reuseComponents ? "true" : "false",
+      // Reuse components?
+      "--fork-url",
+      rpc,
+      ...gasPrice != null ? ["--with-gas-price", String(Math.round(gasPrice))] : []
+    ],
+    { stdio: ["inherit", "pipe", "pipe"] }
+  );
+  child.stderr?.on("data", (data) => console.log("stderr:", data.toString()));
+  child.stdout?.on("data", (data) => console.log(data.toString()));
+  const lines = (await child).stdout?.split("\n");
+  const deployedWorldAddress = findLog(lines, "world: address");
+  const initialBlockNumber = findLog(lines, "initialBlockNumber: uint256");
+  return { child: await child, deployedWorldAddress, initialBlockNumber };
+}
+async function generateAndDeploy(args) {
+  let libDeployPath;
+  let deployedWorldAddress;
+  let initialBlockNumber;
+  try {
+    libDeployPath = await generateLibDeploy(args.config, contractsDirectory2, args.systems);
+    await generateTypes(void 0, "./types", { clear: args.clear });
+    const result = await deploy(
+      args.deployerPrivateKey,
+      args.rpc,
+      args.worldAddress,
+      Boolean(args.reuseComponents),
+      args.gasPrice
+    );
+    deployedWorldAddress = result.deployedWorldAddress;
+    initialBlockNumber = result.initialBlockNumber;
+  } finally {
+    console.log("Cleaning up deployment script");
+    if (libDeployPath)
+      await resetLibDeploy(contractsDirectory2);
+  }
+  return { deployedWorldAddress, initialBlockNumber };
+}
+
+// src/utils/deprecated/hsr.ts
+import chokidar from "chokidar";
+import { readFileSync as readFileSync2 } from "fs";
+var ImportsRegex = new RegExp(/(?<=import ").*(?=";)|(?<=from ").*(?=";)/g);
+function extractImports(path5) {
+  const content = readFileSync2(path5).toString();
+  const regexResult = [...content.matchAll(ImportsRegex)].map((match) => match[0]).map((path6) => path6.split("/").at(-1));
+  return regexResult;
+}
+function findDependencies(file, dependencyGraph, visited = []) {
+  const dependencies = dependencyGraph[file] ?? [];
+  const subDependencies = dependencies.flatMap((d) => {
+    if (visited.includes(d)) {
+      console.warn("Circular dependency detected: ", d, dependencyGraph[d]);
+      return [];
+    }
+    return findDependencies(d, dependencyGraph, [...visited, d]);
+  });
+  return [.../* @__PURE__ */ new Set([...dependencies, ...subDependencies])];
+}
+function hsr(root, replaceSystems) {
+  const dependencyGraph = {};
+  const systems = /* @__PURE__ */ new Set();
+  console.log("Watching system file changes...");
+  chokidar.watch(root).on("all", async (event, path5) => {
+    console.log(`[${event}]: ${path5}`);
+    const changedFile = path5.split("/").at(-1);
+    if (["add", "change"].includes(event)) {
+      const imports = extractImports(path5);
+      for (const importedFile of imports) {
+        dependencyGraph[importedFile] ??= [];
+        dependencyGraph[importedFile].push(changedFile);
+      }
+      if (path5.includes("systems") && path5.includes(".sol"))
+        systems.add(changedFile);
+    }
+    if (event === "change") {
+      const dependencies = findDependencies(changedFile, dependencyGraph);
+      const changedSystems = [
+        ...new Set([changedFile, ...dependencies].filter((f) => systems.has(f)).map((f) => f.replace(".sol", "")))
+      ];
+      console.log("Systems to replace", changedSystems);
+      if (changedSystems.length > 0)
+        await replaceSystems(changedSystems);
+      console.log("Watching system file changes...");
+    }
+  });
+}
+
+export {
+  execLog,
+  IDregex,
+  extractIdFromFile,
+  keccak256,
+  generateLibDeploy,
+  resetLibDeploy,
+  findLog,
+  forgeBuild,
+  filterAbi,
+  systemsDir,
+  componentsDir,
+  generateAbiTypes,
+  generateSystemTypes,
+  generateTypes,
+  deploy,
+  generateAndDeploy,
+  hsr
+};