@latticexyz/cli 1.41.0 → 1.41.1-alpha.41

package/dist/deploy-v2-b7b3207d.d.ts

@@ -1,92 +0,0 @@
-import { ZodError, z } from 'zod';
-import { ValidationError } from 'zod-validation-error';
-import { MUDConfig } from './config/index.js';
-
-declare function fromZodErrorCustom(error: ZodError, prefix: string): ValidationError;
-declare class NotInsideProjectError extends Error {
-    name: string;
-    message: string;
-}
-declare class NotESMConfigError extends Error {
-    name: string;
-    message: string;
-}
-declare class MUDError extends Error {
-    name: string;
-}
-declare function UnrecognizedSystemErrorFactory(path: string[], systemName: string): z.ZodError<any>;
-declare function logError(error: unknown): void;
-
-interface ForgeConfig {
-    src: string;
-    test: string;
-    script: string;
-    out: string;
-    libs: string[];
-    eth_rpc_url: string | null;
-    [key: string]: unknown;
-}
-/**
- * Get forge config as a parsed json object.
- */
-declare function getForgeConfig(profile?: string): Promise<ForgeConfig>;
-/**
- * Get the value of "src" from forge config.
- * The path to the contract sources relative to the root of the project.
- */
-declare function getSrcDirectory(profile?: string): Promise<string>;
-/**
- * Get the value of "script" from forge config.
- * The path to the contract sources relative to the root of the project.
- */
-declare function getScriptDirectory(profile?: string): Promise<string>;
-/**
- * Get the value of "test" from forge config.
- * The path to the test contract sources relative to the root of the project.
- */
-declare function getTestDirectory(profile?: string): Promise<string>;
-/**
- * Get the value of "out" from forge config.
- * The path to put contract artifacts in, relative to the root of the project.
- */
-declare function getOutDirectory(profile?: string): Promise<string>;
-/**
- * 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
- */
-declare function getRpcUrl(profile?: string): Promise<string>;
-/**
- * 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 }
- */
-declare function forge(args: string[], options?: {
-    profile?: string;
-    silent?: boolean;
-}): Promise<void>;
-/**
- * Execute a cast command
- * @param args The arguments to pass to cast
- * @returns Stdout of the command
- */
-declare function cast(args: string[], options?: {
-    profile?: string;
-}): Promise<string>;
-
-declare function formatSolidity(content: string, prettierConfigPath?: string): Promise<string>;
-
-interface DeployConfig {
-    profile?: string;
-    rpc: string;
-    privateKey: string;
-    priorityFeeMultiplier: number;
-}
-interface DeploymentInfo {
-    blockNumber: number;
-    worldAddress: string;
-    rpc: string;
-}
-declare function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig): Promise<DeploymentInfo>;
-
-export { DeployConfig as D, ForgeConfig as F, MUDError as M, NotInsideProjectError as N, UnrecognizedSystemErrorFactory as U, NotESMConfigError as a, getSrcDirectory as b, getScriptDirectory as c, getTestDirectory as d, getOutDirectory as e, fromZodErrorCustom as f, getForgeConfig as g, getRpcUrl as h, forge as i, cast as j, formatSolidity as k, logError as l, DeploymentInfo as m, deploy as n };

package/src/config/loadWorldConfig.ts

@@ -1,178 +0,0 @@
-import { z, ZodError } from "zod";
-import { fromZodErrorCustom, UnrecognizedSystemErrorFactory } from "../utils/errors.js";
-import { BaseRoute, EthereumAddress, ObjectName } from "./commonSchemas.js";
-import { loadConfig } from "./loadConfig.js";
-
-const SystemName = ObjectName;
-const SystemRoute = BaseRoute.optional();
-const SystemAccessList = z.array(SystemName.or(EthereumAddress)).default([]);
-
-// The system config is a combination of a route config and access config
-const SystemConfig = z.intersection(
-  z.object({
-    route: SystemRoute,
-  }),
-  z.discriminatedUnion("openAccess", [
-    z.object({
-      openAccess: z.literal(true),
-    }),
-    z.object({
-      openAccess: z.literal(false),
-      accessList: SystemAccessList,
-    }),
-  ])
-);
-
-// The parsed world config is the result of parsing the user config
-export const WorldConfig = z.object({
-  baseRoute: BaseRoute.default(""),
-  worldContractName: z.string().optional(),
-  overrideSystems: z.record(SystemName, SystemConfig).default({}),
-  excludeSystems: z.array(SystemName).default([]),
-  postDeployScript: z.string().default("PostDeploy"),
-  deploymentInfoDirectory: z.string().default("."),
-});
-
-/**
- * Resolves the system config by combining the default and overridden system configs,
- * @param systemName name of the system
- * @param config optional SystemConfig object, if none is provided the default config is used
- * @param existingContracts optional list of existing contract names, used to validate system names in the access list. If not provided, no validation is performed.
- * @returns ResolvedSystemConfig object
- * Default value for route is `/${systemName}`
- * Default value for openAccess is true
- * Default value for accessListAddresses is []
- * Default value for accessListSystems is []
- */
-export function resolveSystemConfig(systemName: string, config?: SystemUserConfig, existingContracts?: string[]) {
-  const route = config?.route ?? `/${systemName}`;
-  const openAccess = config?.openAccess ?? true;
-  const accessListAddresses: string[] = [];
-  const accessListSystems: string[] = [];
-  const accessList = config && !config.openAccess ? config.accessList : [];
-
-  // Split the access list into addresses and system names
-  for (const accessListItem of accessList) {
-    if (accessListItem.startsWith("0x")) {
-      accessListAddresses.push(accessListItem);
-    } else {
-      // Validate every system refers to an existing system contract
-      if (existingContracts && !existingContracts.includes(accessListItem)) {
-        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName, "accessList"], accessListItem);
-      }
-      accessListSystems.push(accessListItem);
-    }
-  }
-
-  return { route, openAccess, accessListAddresses, accessListSystems };
-}
-
-/**
- * Resolves the world config by combining the default and overridden system configs,
- * filtering out excluded systems, validate system names refer to existing contracts, and
- * splitting the access list into addresses and system names.
- */
-export function resolveWorldConfig(config: ParsedWorldConfig, existingContracts?: string[]) {
-  // Include contract names ending in "System", but not the base "System" contract
-  const defaultSystemNames = existingContracts?.filter((name) => name.endsWith("System") && name !== "System") ?? [];
-  const overriddenSystemNames = Object.keys(config.overrideSystems);
-
-  // Validate every key in overrideSystems refers to an existing system contract (and is not called "World")
-  if (existingContracts) {
-    for (const systemName of overriddenSystemNames) {
-      if (!existingContracts.includes(systemName) || systemName === "World") {
-        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName], systemName);
-      }
-    }
-  }
-
-  // Combine the default and overridden system names and filter out excluded systems
-  const systemNames = [...new Set([...defaultSystemNames, ...overriddenSystemNames])].filter(
-    (name) => !config.excludeSystems.includes(name)
-  );
-
-  // Resolve the config
-  const resolvedSystems: Record<string, ResolvedSystemConfig> = systemNames.reduce((acc, systemName) => {
-    return {
-      ...acc,
-      [systemName]: resolveSystemConfig(systemName, config.overrideSystems[systemName], existingContracts),
-    };
-  }, {});
-
-  const { overrideSystems, excludeSystems, ...otherConfig } = config;
-  return { ...otherConfig, systems: resolvedSystems };
-}
-
-/**
- * Loads and resolves the world config.
- * @param configPath Path to load the config from. Defaults to "mud.config.mts" or "mud.config.ts"
- * @param existingContracts Optional list of existing contract names to validate system names against. If not provided, no validation is performed. Contract names ending in `System` will be added to the config with default values.
- * @returns Promise of ResolvedWorldConfig object
- */
-export async function loadWorldConfig(configPath?: string, existingContracts?: string[]) {
-  const config = await loadConfig(configPath);
-
-  try {
-    const parsedConfig = WorldConfig.parse(config);
-    return resolveWorldConfig(parsedConfig, existingContracts);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      throw fromZodErrorCustom(error, "WorldConfig Validation Error");
-    } else {
-      throw error;
-    }
-  }
-}
-
-export async function parseWorldConfig(config: unknown) {
-  return WorldConfig.parse(config);
-}
-
-// zod doesn't preserve doc comments
-export type SystemUserConfig =
-  | {
-      /** The system will be deployed at `baseRoute + route` */
-      route?: string;
-    } & (
-      | {
-          /** If openAccess is true, any address can call the system */
-          openAccess: true;
-        }
-      | {
-          /** If openAccess is false, only the addresses or systems in `access` can call the system */
-          openAccess: false;
-          /** An array of addresses or system names that can access the system */
-          accessList: string[];
-        }
-    );
-
-// zod doesn't preserve doc comments
-export interface WorldUserConfig {
-  /** The base route to register tables and systems at. Defaults to the root route (empty string) */
-  baseRoute?: string;
-  /** The name of the World contract to deploy. If no name is provided, a vanilla World is deployed */
-  worldContractName?: string;
-  /**
-   * Contracts named *System will be deployed by default
-   * as public systems at `baseRoute/ContractName`, unless overridden
-   *
-   * The key is the system name (capitalized).
-   * The value is a SystemConfig object.
-   */
-  overrideSystems?: Record<string, SystemUserConfig>;
-  /** Systems to exclude from automatic deployment */
-  excludeSystems?: string[];
-  /**
-   * Script to execute after the deployment is complete (Default "PostDeploy").
-   * Script must be placed in the forge scripts directory (see foundry.toml) and have a ".s.sol" extension.
-   */
-  postDeployScript?: string;
-  /** Directory to write the deployment info to (Default ".") */
-  deploymentInfoDirectory?: string;
-}
-
-export type ParsedWorldConfig = z.output<typeof WorldConfig>;
-
-export type ResolvedSystemConfig = ReturnType<typeof resolveSystemConfig>;
-
-export type ResolvedWorldConfig = ReturnType<typeof resolveWorldConfig>;

package/src/constants.ts

@@ -1 +0,0 @@
-export const deploymentInfoFilenamePrefix = "mud-deployment-";