@latticexyz/cli 1.40.0 → 1.41.1-alpha.0

package/src/utils/foundry.ts

@@ -0,0 +1,94 @@
+import { execa, Options } from "execa";
+import { execLog } from "./execLog.js";
+
+export interface ForgeConfig {
+  // project
+  src: string;
+  test: string;
+  script: string;
+  out: string;
+  libs: string[];
+  eth_rpc_url: string | null;
+
+  // all unspecified keys (this interface is far from comprehensive)
+  [key: string]: unknown;
+}
+
+/**
+ * Get forge config as a parsed json object.
+ */
+export async function getForgeConfig(profile?: string) {
+  const { stdout } = await execa("forge", ["config", "--json"], {
+    stdio: ["inherit", "pipe", "pipe"],
+    env: { FOUNDRY_PROFILE: profile },
+  });
+
+  return JSON.parse(stdout) as ForgeConfig;
+}
+
+/**
+ * Get the value of "src" from forge config.
+ * The path to the contract sources relative to the root of the project.
+ */
+export async function getSrcDirectory(profile?: string) {
+  return (await getForgeConfig(profile)).src;
+}
+
+/**
+ * Get the value of "script" from forge config.
+ * The path to the contract sources relative to the root of the project.
+ */
+export async function getScriptDirectory(profile?: string) {
+  return (await getForgeConfig(profile)).script;
+}
+
+/**
+ * Get the value of "test" from forge config.
+ * The path to the test contract sources relative to the root of the project.
+ */
+export async function getTestDirectory(profile?: string) {
+  return (await getForgeConfig(profile)).test;
+}
+
+/**
+ * Get the value of "out" from forge config.
+ * The path to put contract artifacts in, relative to the root of the project.
+ */
+export async function getOutDirectory(profile?: string) {
+  return (await getForgeConfig(profile)).out;
+}
+
+/**
+ * Get the value of "eth_rpc_url" from forge config, default to "http://127.0.0.1:8545"
+ * @param profile The foundry profile to use
+ * @returns The rpc url
+ */
+export async function getRpcUrl(profile?: string) {
+  return (await getForgeConfig(profile)).eth_rpc_url || "http://127.0.0.1:8545";
+}
+
+/**
+ * Execute a forge command
+ * @param args The arguments to pass to forge
+ * @param options { profile?: The foundry profile to use; silent?: If true, nothing will be logged to the console }
+ */
+export async function forge(args: string[], options?: { profile?: string; silent?: boolean }): Promise<void> {
+  const execOptions: Options<string> = {
+    env: { FOUNDRY_PROFILE: options?.profile },
+    stdout: "inherit",
+    stderr: "pipe",
+  };
+
+  await (options?.silent ? execa("forge", args, execOptions) : execLog("forge", args, execOptions));
+}
+
+/**
+ * Execute a cast command
+ * @param args The arguments to pass to cast
+ * @returns Stdout of the command
+ */
+export async function cast(args: string[], options?: { profile?: string }): Promise<string> {
+  return execLog("cast", args, {
+    env: { FOUNDRY_PROFILE: options?.profile },
+  });
+}

package/src/utils/getChainId.ts

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

@@ -1,3 +1,4 @@
 export * from "./errors.js";
-export * from "./forgeConfig.js";
+export * from "./foundry.js";
 export * from "./format.js";
+export * from "./deploy-v2.js";

package/src/utils/typeUtils.ts

@@ -0,0 +1,17 @@
+import { AbiType, StaticAbiType } from "@latticexyz/schema-type";
+
+export type RequireKeys<T extends Record<string, unknown>, P extends string> = T & Required<Pick<T, P>>;
+
+// This allows unions between string literals and `string` without sacrificing autocompletion.
+// Workaround for https://github.com/Microsoft/TypeScript/issues/29729
+export type StringForUnion = string & Record<never, never>;
+
+export type StaticArray = `${StaticAbiType}[${number}]`;
+// static arrays and inferred enum names get mixed together - this helper separates them
+export type ExtractUserTypes<UnknownTypes extends StringForUnion> = Exclude<UnknownTypes, AbiType | StaticArray>;
+
+// When type inference sees multiple uses of 1 generic, it can only guess
+// which of those are supposed to define the generic (and it will be wrong in complex situations).
+// This helper explicitly makes a type that's dependent on some generic,
+// and will not be inferred as the generic's definition.
+export type AsDependent<T> = T extends infer P ? P : never;

package/dist/chunk-B6VWCGHZ.js

@@ -1,199 +0,0 @@
-import {
-  SchemaType,
-  getStaticByteLength
-} from "./chunk-6AQ6LFVZ.js";
-import {
-  NotESMConfigError,
-  NotInsideProjectError,
-  fromZodErrorCustom
-} from "./chunk-JKAA3WMC.js";
-
-// src/config/validation.ts
-import { ZodIssueCode } from "zod";
-function validateName(name, ctx) {
-  if (!/^\w+$/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must contain only alphanumeric & underscore characters`
-    });
-  }
-}
-function validateCapitalizedName(name, ctx) {
-  validateName(name, ctx);
-  if (!/^[A-Z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a capital letter`
-    });
-  }
-}
-function validateUncapitalizedName(name, ctx) {
-  validateName(name, ctx);
-  if (!/^[a-z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a lowercase letter`
-    });
-  }
-}
-function _factoryForValidateRoute(requireNonEmpty, requireSingleLevel) {
-  return (route, ctx) => {
-    if (route === "") {
-      if (requireNonEmpty) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not be empty`
-        });
-      }
-      return;
-    }
-    if (route[0] !== "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must start with "/"`
-      });
-    }
-    if (route[route.length - 1] === "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must not end with "/"`
-      });
-    }
-    const parts = route.split("/");
-    if (requireSingleLevel && parts.length > 2) {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must only have one level (e.g. "/foo")`
-      });
-    }
-    for (let i = 1; i < parts.length; i++) {
-      if (parts[i] === "") {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not contain empty route fragments (e.g. "//")`
-        });
-      }
-      if (!/^\w+$/.test(parts[i])) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must contain only alphanumeric & underscore characters`
-        });
-      }
-    }
-  };
-}
-var validateRoute = _factoryForValidateRoute(true, false);
-var validateBaseRoute = _factoryForValidateRoute(false, false);
-var validateSingleLevelRoute = _factoryForValidateRoute(true, true);
-
-// src/config/commonSchemas.ts
-import { z } from "zod";
-var ObjectName = z.string().superRefine(validateCapitalizedName);
-var ValueName = z.string().superRefine(validateUncapitalizedName);
-var OrdinaryRoute = z.string().superRefine(validateRoute);
-var SingleLevelRoute = z.string().superRefine(validateSingleLevelRoute);
-var BaseRoute = z.string().superRefine(validateBaseRoute);
-
-// src/config/loadConfig.ts
-import { findUp } from "find-up";
-import path from "path";
-var configFiles = ["mud.config.ts", "mud.config.mts"];
-async function loadConfig(configPath) {
-  configPath = await resolveConfigPath(configPath);
-  try {
-    return (await import(configPath)).default;
-  } catch (error) {
-    if (error instanceof SyntaxError && error.message === "Cannot use import statement outside a module") {
-      throw new NotESMConfigError();
-    } else {
-      throw error;
-    }
-  }
-}
-async function resolveConfigPath(configPath) {
-  if (configPath === void 0) {
-    configPath = await getUserConfigPath();
-  } else {
-    if (!path.isAbsolute(configPath)) {
-      configPath = path.join(process.cwd(), configPath);
-      configPath = path.normalize(configPath);
-    }
-  }
-  return configPath;
-}
-async function getUserConfigPath() {
-  const tsConfigPath = await findUp(configFiles);
-  if (tsConfigPath === void 0) {
-    throw new NotInsideProjectError();
-  }
-  return tsConfigPath;
-}
-
-// src/config/loadStoreConfig.ts
-import { z as z2, ZodError } from "zod";
-var TableName = ObjectName;
-var KeyName = ValueName;
-var ColumnName = ValueName;
-var PrimaryKey = z2.nativeEnum(SchemaType).refine((arg) => getStaticByteLength(arg) > 0, "Primary key must not use dynamic SchemaType");
-var PrimaryKeys = z2.record(KeyName, PrimaryKey).default({ key: 95 /* BYTES32 */ });
-var Schema = z2.record(ColumnName, z2.nativeEnum(SchemaType)).refine((arg) => Object.keys(arg).length > 0, "Table schema may not be empty");
-var FullTable = z2.object({
-  route: OrdinaryRoute.default("/tables"),
-  tableIdArgument: z2.boolean().default(false),
-  storeArgument: z2.boolean().default(false),
-  primaryKeys: PrimaryKeys,
-  schema: Schema,
-  dataStruct: z2.boolean().optional()
-}).transform((arg) => {
-  if (Object.keys(arg.schema).length === 1) {
-    arg.dataStruct ??= false;
-  } else {
-    arg.dataStruct ??= true;
-  }
-  return arg;
-});
-var DefaultSingleValueTable = z2.nativeEnum(SchemaType).transform((schemaType) => {
-  return FullTable.parse({
-    schema: {
-      value: schemaType
-    }
-  });
-});
-var StoreConfig = z2.object({
-  baseRoute: BaseRoute.default(""),
-  storeImportPath: z2.string().default("@latticexyz/store/src/"),
-  tables: z2.record(TableName, z2.union([DefaultSingleValueTable, FullTable]))
-});
-async function loadStoreConfig(configPath) {
-  const config = await loadConfig(configPath);
-  try {
-    return parseStoreConfig(config);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      throw fromZodErrorCustom(error, "StoreConfig Validation Error");
-    } else {
-      throw error;
-    }
-  }
-}
-async function parseStoreConfig(config) {
-  return StoreConfig.parse(config);
-}
-
-export {
-  validateName,
-  validateCapitalizedName,
-  validateUncapitalizedName,
-  validateRoute,
-  validateBaseRoute,
-  validateSingleLevelRoute,
-  ObjectName,
-  ValueName,
-  OrdinaryRoute,
-  SingleLevelRoute,
-  BaseRoute,
-  loadConfig,
-  StoreConfig,
-  loadStoreConfig,
-  parseStoreConfig
-};

package/dist/chunk-JKAA3WMC.js

@@ -1,55 +0,0 @@
-// src/utils/errors.ts
-import chalk from "chalk";
-import { ZodError } from "zod";
-import { fromZodError, ValidationError } from "zod-validation-error";
-function fromZodErrorCustom(error, prefix) {
-  return fromZodError(error, {
-    prefix: chalk.red(prefix),
-    prefixSeparator: "\n- ",
-    issueSeparator: "\n- "
-  });
-}
-var NotInsideProjectError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "NotInsideProjectError";
-    this.message = "You are not inside a MUD project";
-  }
-};
-var NotESMConfigError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "NotESMConfigError";
-    this.message = "MUD config must be an ES module";
-  }
-};
-function logError(error) {
-  if (error instanceof ValidationError) {
-    console.log(chalk.redBright(error.message));
-  } else if (error instanceof ZodError) {
-    const validationError = fromZodError(error, {
-      prefixSeparator: "\n- ",
-      issueSeparator: "\n- "
-    });
-    console.log(chalk.redBright(validationError.message));
-  } else if (error instanceof NotInsideProjectError) {
-    console.log(chalk.red(error.message));
-    console.log("");
-    console.log(chalk.blue(`To learn more about MUD's configuration, please go to https://mud.dev/packages/cli/`));
-  } else if (error instanceof NotESMConfigError) {
-    console.log(chalk.red(error.message));
-    console.log("");
-    console.log(
-      chalk.blue(`Please name your config file \`mud.config.mts\`, or use \`type: "module"\` in package.json`)
-    );
-  } else {
-    console.log(error);
-  }
-}
-
-export {
-  fromZodErrorCustom,
-  NotInsideProjectError,
-  NotESMConfigError,
-  logError
-};