@latticexyz/cli 2.0.9 → 2.0.10-230513-threejs-template-use-namespace-d6ab6d80

package/src/commands/verify.ts

@@ -7,9 +7,9 @@ import { worldToV1 } from "@latticexyz/world/config/v2";
 import { getOutDirectory, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
 import { getExistingContracts } from "../utils/getExistingContracts";
 import { getContractData } from "../utils/getContractData";
-import { defaultModuleContracts } from "../utils/defaultModuleContracts";
 import { Hex, createWalletClient, http } from "viem";
 import chalk from "chalk";
+import { configToModules } from "../deploy/configToModules";
 
 const verifyOptions = {
   deployerAddress: {
@@ -82,17 +82,7 @@ const commandModule: CommandModule<Options, Options> = {
       };
     });
 
-    // Get modules
-    const modules = config.modules.map((mod) => {
-      const contractData =
-        defaultModuleContracts.find((defaultMod) => defaultMod.name === mod.name) ??
-        getContractData(`${mod.name}.sol`, mod.name, outDir);
-
-      return {
-        name: mod.name,
-        bytecode: contractData.bytecode,
-      };
-    });
+    const modules = await configToModules(configV2, outDir);
 
     await verify({
       client,

package/src/deploy/common.ts

@@ -117,6 +117,5 @@ export type ConfigInput = StoreConfig & WorldConfig;
 export type Config<config extends ConfigInput> = {
   readonly tables: Tables<config>;
   readonly systems: readonly System[];
-  readonly modules: readonly Module[];
   readonly libraries: readonly Library[];
 };

package/src/deploy/configToModules.ts

@@ -0,0 +1,81 @@
+import path from "node:path";
+import { Module } from "./common";
+import { resolveWithContext } from "@latticexyz/config/library";
+import { encodeField } from "@latticexyz/protocol-parser/internal";
+import { SchemaAbiType, SchemaAbiTypeToPrimitiveType } from "@latticexyz/schema-type/internal";
+import { bytesToHex, hexToBytes } from "viem";
+import { createPrepareDeploy } from "./createPrepareDeploy";
+import { World } from "@latticexyz/world";
+import { getContractArtifact } from "../utils/getContractArtifact";
+import { knownModuleArtifacts } from "../utils/knownModuleArtifacts";
+
+export async function configToModules<config extends World>(
+  config: config,
+  forgeOutDir: string,
+): Promise<readonly Module[]> {
+  // this expects a namespaced table name when used with `resolveTableId`
+  const resolveContext = {
+    tableIds: Object.fromEntries(
+      Object.entries(config.tables).map(([tableName, table]) => [tableName, hexToBytes(table.tableId)]),
+    ),
+  };
+
+  const modules = await Promise.all(
+    config.modules.map(async (mod): Promise<Module> => {
+      let artifactPath = mod.artifactPath;
+
+      // Backwards compatibility
+      // TODO: move this up a level so we don't need `forgeOutDir` in here?
+      if (!artifactPath) {
+        if (mod.name) {
+          artifactPath =
+            knownModuleArtifacts[mod.name as keyof typeof knownModuleArtifacts] ??
+            path.join(forgeOutDir, `${mod.name}.sol`, `${mod.name}.json`);
+          console.warn(
+            [
+              "",
+              `⚠️ Your \`mud.config.ts\` is using a module with a \`name\`, but this option is deprecated.`,
+              "",
+              "To resolve this, you can replace this:",
+              "",
+              `  name: ${JSON.stringify(mod.name)}`,
+              "",
+              "with this:",
+              "",
+              `  artifactPath: ${JSON.stringify(artifactPath)}`,
+              "",
+            ].join("\n"),
+          );
+        } else {
+          throw new Error("No `artifactPath` provided for module.");
+        }
+      }
+
+      const name = path.basename(artifactPath, ".json");
+      const artifact = await getContractArtifact({ artifactPath });
+
+      // TODO: replace args with something more strongly typed
+      const installArgs = mod.args
+        .map((arg) => resolveWithContext(arg, resolveContext))
+        .map((arg) => {
+          const value = arg.value instanceof Uint8Array ? bytesToHex(arg.value) : arg.value;
+          return encodeField(arg.type as SchemaAbiType, value as SchemaAbiTypeToPrimitiveType<SchemaAbiType>);
+        });
+
+      if (installArgs.length > 1) {
+        throw new Error(`${name} module should only have 0-1 args, but had ${installArgs.length} args.`);
+      }
+
+      return {
+        name,
+        installAsRoot: mod.root,
+        installData: installArgs.length === 0 ? "0x" : installArgs[0],
+        prepareDeploy: createPrepareDeploy(artifact.bytecode, artifact.placeholders),
+        deployedBytecodeSize: artifact.deployedBytecodeSize,
+        abi: artifact.abi,
+      };
+    }),
+  );
+
+  return modules;
+}

package/src/deploy/deploy.ts

@@ -2,7 +2,7 @@ import { Account, Address, Chain, Client, Hex, Transport } from "viem";
 import { ensureDeployer } from "./ensureDeployer";
 import { deployWorld } from "./deployWorld";
 import { ensureTables } from "./ensureTables";
-import { Config, ConfigInput, WorldDeploy, supportedStoreVersions, supportedWorldVersions } from "./common";
+import { Config, ConfigInput, Module, WorldDeploy, supportedStoreVersions, supportedWorldVersions } from "./common";
 import { ensureSystems } from "./ensureSystems";
 import { waitForTransactionReceipt } from "viem/actions";
 import { getWorldDeploy } from "./getWorldDeploy";
@@ -19,6 +19,7 @@ import { ensureWorldFactory } from "./ensureWorldFactory";
 type DeployOptions<configInput extends ConfigInput> = {
   client: Client<Transport, Chain | undefined, Account>;
   config: Config<configInput>;
+  modules?: readonly Module[];
   salt?: Hex;
   worldAddress?: Address;
   /**
@@ -40,6 +41,7 @@ type DeployOptions<configInput extends ConfigInput> = {
 export async function deploy<configInput extends ConfigInput>({
   client,
   config,
+  modules = [],
   salt,
   worldAddress: existingWorldAddress,
   deployerAddress: initialDeployerAddress,
@@ -66,7 +68,7 @@ export async function deploy<configInput extends ConfigInput>({
         deployedBytecodeSize: system.deployedBytecodeSize,
         label: `${resourceToLabel(system)} system`,
       })),
-      ...config.modules.map((mod) => ({
+      ...modules.map((mod) => ({
         bytecode: mod.prepareDeploy(deployerAddress, config.libraries).bytecode,
         deployedBytecodeSize: mod.deployedBytecodeSize,
         label: `${mod.name} module`,
@@ -118,7 +120,7 @@ export async function deploy<configInput extends ConfigInput>({
     deployerAddress,
     libraries: config.libraries,
     worldDeploy,
-    modules: config.modules,
+    modules,
   });
 
   const txs = [...tableTxs, ...systemTxs, ...functionTxs, ...moduleTxs];

package/src/deploy/ensureModules.ts

@@ -38,12 +38,13 @@ export async function ensureModules({
         pRetry(
           async () => {
             try {
+              const abi = [...worldAbi, ...mod.abi];
               const moduleAddress = mod.prepareDeploy(deployerAddress, libraries).address;
               return mod.installAsRoot
                 ? await writeContract(client, {
                     chain: client.chain ?? null,
                     address: worldDeploy.address,
-                    abi: worldAbi,
+                    abi,
                     // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
                     functionName: "installRootModule",
                     args: [moduleAddress, mod.installData],
@@ -51,7 +52,7 @@ export async function ensureModules({
                 : await writeContract(client, {
                     chain: client.chain ?? null,
                     address: worldDeploy.address,
-                    abi: worldAbi,
+                    abi,
                     // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
                     functionName: "installModule",
                     args: [moduleAddress, mod.installData],

package/src/deploy/getFunctions.ts

@@ -1,11 +1,9 @@
-import { Client, toFunctionSelector, parseAbiItem } from "viem";
+import { Client, parseAbiItem } from "viem";
 import { WorldDeploy, WorldFunction, worldTables } from "./common";
 import { debug } from "./debug";
 import { storeSetRecordEvent } from "@latticexyz/store";
 import { getLogs } from "viem/actions";
-import { decodeValueArgs } from "@latticexyz/protocol-parser/internal";
-import { getTableValue } from "./getTableValue";
-import { hexToResource } from "@latticexyz/common";
+import { decodeKey, decodeValueArgs } from "@latticexyz/protocol-parser/internal";
 
 export async function getFunctions({
   client,
@@ -15,44 +13,52 @@ export async function getFunctions({
   readonly worldDeploy: WorldDeploy;
 }): Promise<readonly WorldFunction[]> {
   // This assumes we only use `FunctionSelectors._set(...)`, which is true as of this writing.
-  debug("looking up function signatures for", worldDeploy.address);
-  const logs = await getLogs(client, {
+  debug("looking up function selectors for", worldDeploy.address);
+  const selectorLogs = await getLogs(client, {
     strict: true,
     fromBlock: worldDeploy.deployBlock,
     toBlock: worldDeploy.stateBlock,
     address: worldDeploy.address,
     event: parseAbiItem(storeSetRecordEvent),
-    args: { tableId: worldTables.world_FunctionSignatures.tableId },
+    args: { tableId: worldTables.world_FunctionSelectors.tableId },
+  });
+
+  const selectors = selectorLogs.map((log) => {
+    return {
+      ...decodeValueArgs(worldTables.world_FunctionSelectors.valueSchema, log.args),
+      ...decodeKey(worldTables.world_FunctionSelectors.keySchema, log.args.keyTuple),
+    };
   });
+  debug("found", selectors.length, "function selectors for", worldDeploy.address);
 
-  const signatures = logs.map((log) => {
-    const value = decodeValueArgs(worldTables.world_FunctionSignatures.valueSchema, log.args);
-    return value.functionSignature;
+  // This assumes we only use `FunctionSignatures._set(...)`, which is true as of this writing.
+  debug("looking up function signatures for", worldDeploy.address);
+  const signatureLogs = await getLogs(client, {
+    strict: true,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    event: parseAbiItem(storeSetRecordEvent),
+    args: { tableId: worldTables.world_FunctionSignatures.tableId },
   });
-  debug("found", signatures.length, "function signatures for", worldDeploy.address);
 
-  // TODO: parallelize with a bulk getRecords
-  const functions = await Promise.all(
-    signatures.map(async (signature) => {
-      const selector = toFunctionSelector(signature);
-      const { systemId, systemFunctionSelector } = await getTableValue({
-        client,
-        worldDeploy,
-        table: worldTables.world_FunctionSelectors,
-        key: { worldFunctionSelector: selector },
-      });
-      const { namespace, name } = hexToResource(systemId);
-      // TODO: find away around undoing contract logic (https://github.com/latticexyz/mud/issues/1708)
-      const systemFunctionSignature = namespace === "" ? signature : signature.replace(`${namespace}_${name}_`, "");
-      return {
-        signature,
-        selector,
-        systemId,
-        systemFunctionSignature,
-        systemFunctionSelector,
-      };
+  const selectorToSignature = Object.fromEntries(
+    signatureLogs.map((log) => {
+      return [
+        decodeKey(worldTables.world_FunctionSignatures.keySchema, log.args.keyTuple).functionSelector,
+        decodeValueArgs(worldTables.world_FunctionSignatures.valueSchema, log.args).functionSignature,
+      ];
     }),
   );
+  debug("found", signatureLogs.length, "function signatures for", worldDeploy.address);
+
+  const functions = selectors.map(({ worldFunctionSelector, systemFunctionSelector, systemId }) => ({
+    selector: worldFunctionSelector,
+    signature: selectorToSignature[worldFunctionSelector],
+    systemFunctionSelector,
+    systemFunctionSignature: selectorToSignature[systemFunctionSelector],
+    systemId,
+  }));
 
   return functions;
 }

package/src/deploy/resolveConfig.ts

@@ -1,13 +1,9 @@
 import path from "path";
 import { resolveWorldConfig } from "@latticexyz/world/internal";
-import { Config, ConfigInput, Library, Module, System, WorldFunction } from "./common";
+import { Config, ConfigInput, Library, System, WorldFunction } from "./common";
 import { resourceToHex } from "@latticexyz/common";
-import { resolveWithContext } from "@latticexyz/config/library";
-import { encodeField } from "@latticexyz/protocol-parser/internal";
-import { SchemaAbiType, SchemaAbiTypeToPrimitiveType } from "@latticexyz/schema-type/internal";
-import { Hex, hexToBytes, bytesToHex, toFunctionSelector, toFunctionSignature } from "viem";
+import { Hex, toFunctionSelector, toFunctionSignature } from "viem";
 import { getExistingContracts } from "../utils/getExistingContracts";
-import { defaultModuleContracts } from "../utils/defaultModuleContracts";
 import { getContractData } from "../utils/getContractData";
 import { configToTables } from "./configToTables";
 import { groupBy } from "@latticexyz/common/utils";
@@ -100,49 +96,9 @@ export function resolveConfig<config extends ConfigInput>({
     );
   }
 
-  // ugh (https://github.com/latticexyz/mud/issues/1668)
-  const resolveContext = {
-    tableIds: Object.fromEntries(
-      Object.entries(config.tables).map(([tableName, table]) => [
-        tableName,
-        hexToBytes(
-          resourceToHex({
-            type: table.offchainOnly ? "offchainTable" : "table",
-            namespace: config.namespace,
-            name: table.name,
-          }),
-        ),
-      ]),
-    ),
-  };
-
-  const modules = config.modules.map((mod): Module => {
-    const contractData =
-      defaultModuleContracts.find((defaultMod) => defaultMod.name === mod.name) ??
-      getContractData(`${mod.name}.sol`, mod.name, forgeOutDir);
-    const installArgs = mod.args
-      .map((arg) => resolveWithContext(arg, resolveContext))
-      .map((arg) => {
-        const value = arg.value instanceof Uint8Array ? bytesToHex(arg.value) : arg.value;
-        return encodeField(arg.type as SchemaAbiType, value as SchemaAbiTypeToPrimitiveType<SchemaAbiType>);
-      });
-    if (installArgs.length > 1) {
-      throw new Error(`${mod.name} module should only have 0-1 args, but had ${installArgs.length} args.`);
-    }
-    return {
-      name: mod.name,
-      installAsRoot: mod.root,
-      installData: installArgs.length === 0 ? "0x" : installArgs[0],
-      prepareDeploy: createPrepareDeploy(contractData.bytecode, contractData.placeholders),
-      deployedBytecodeSize: contractData.deployedBytecodeSize,
-      abi: contractData.abi,
-    };
-  });
-
   return {
     tables,
     systems,
-    modules,
     libraries,
   };
 }

package/src/runDeploy.ts

@@ -16,6 +16,7 @@ import { postDeploy } from "./utils/postDeploy";
 import { WorldDeploy } from "./deploy/common";
 import { build } from "./build";
 import { kmsKeyToAccount } from "@latticexyz/common/kms";
+import { configToModules } from "./deploy/configToModules";
 
 export const deployOptions = {
   configPath: { type: "string", desc: "Path to the MUD config file" },
@@ -85,6 +86,7 @@ export async function runDeploy(opts: DeployOptions): Promise<WorldDeploy> {
   }
 
   const resolvedConfig = resolveConfig({ config, forgeSourceDir: srcDir, forgeOutDir: outDir });
+  const modules = await configToModules(configV2, outDir);
 
   const account = await (async () => {
     if (opts.kms) {
@@ -131,6 +133,7 @@ export async function runDeploy(opts: DeployOptions): Promise<WorldDeploy> {
     worldAddress: opts.worldAddress as Hex | undefined,
     client,
     config: resolvedConfig,
+    modules,
     withWorldProxy: configV2.deploy.upgradeableWorldImplementation,
   });
   if (opts.worldAddress == null || opts.alwaysRunPostDeploy) {

package/src/utils/getContractArtifact.ts

@@ -0,0 +1,73 @@
+import { Abi, Hex, isHex, size } from "viem";
+import { LibraryPlaceholder } from "../deploy/common";
+import { findPlaceholders } from "./findPlaceholders";
+import { z } from "zod";
+import { Abi as abiSchema } from "abitype/zod";
+
+export type GetContractArtifactOptions = {
+  /**
+   * Import path to contract's forge/solc JSON artifact with the contract's compiled bytecode.
+   *
+   * This path is resolved using node's contract resolution, so this supports both relative file paths (`../path/to/MyModule.json`) as well as JS import paths
+   * (`@latticexyz/world-contracts/out/CallWithSignatureModule.sol/CallWithSignatureModule.json`).
+   */
+  artifactPath: string;
+};
+
+export type GetContractArtifactResult = {
+  bytecode: Hex;
+  placeholders: readonly LibraryPlaceholder[];
+  abi: Abi;
+  deployedBytecodeSize: number;
+};
+
+const bytecodeSchema = z.object({
+  object: z.string().refine(isHex),
+  linkReferences: z.record(
+    z.record(
+      z.array(
+        z.object({
+          start: z.number(),
+          length: z.number(),
+        }),
+      ),
+    ),
+  ),
+});
+
+const artifactSchema = z.object({
+  bytecode: bytecodeSchema,
+  deployedBytecode: bytecodeSchema,
+  abi: abiSchema,
+});
+
+export async function getContractArtifact({
+  artifactPath,
+}: GetContractArtifactOptions): Promise<GetContractArtifactResult> {
+  let importedArtifact;
+  try {
+    importedArtifact = (
+      await import(artifactPath, {
+        with: { type: "json" },
+        // `with` is the new approach, but `assert` is kept for backwards-compatibility with Node 18
+        assert: { type: "json" },
+      })
+    ).default;
+  } catch (error) {
+    console.error();
+    console.error("Could not import contract artifact at", artifactPath);
+    console.error();
+    throw error;
+  }
+
+  // TODO: improve errors or replace with arktype?
+  const artifact = artifactSchema.parse(importedArtifact);
+  const placeholders = findPlaceholders(artifact.bytecode.linkReferences);
+
+  return {
+    abi: artifact.abi,
+    bytecode: artifact.bytecode.object,
+    placeholders,
+    deployedBytecodeSize: size(artifact.deployedBytecode.object),
+  };
+}

package/src/utils/knownModuleArtifacts.ts

@@ -0,0 +1,8 @@
+/** @deprecated Please don't add to this list! These are kept for backwards compatibility and assumes the downstream project has this module installed as a dependency. */
+export const knownModuleArtifacts = {
+  KeysWithValueModule: "@latticexyz/world-modules/out/KeysWithValueModule.sol/KeysWithValueModule.json",
+  KeysInTableModule: "@latticexyz/world-modules/out/KeysInTableModule.sol/KeysInTableModule.json",
+  UniqueEntityModule: "@latticexyz/world-modules/out/UniqueEntityModule.sol/UniqueEntityModule.json",
+  Unstable_CallWithSignatureModule:
+    "@latticexyz/world-modules/out/Unstable_CallWithSignatureModule.sol/Unstable_CallWithSignatureModule.json",
+};

package/src/verify.ts

@@ -5,7 +5,7 @@ import PQueue from "p-queue";
 import { getWorldProxyFactoryContracts } from "./deploy/getWorldProxyFactoryContracts";
 import { getDeployer } from "./deploy/getDeployer";
 import { MUDError } from "@latticexyz/common/errors";
-import { salt } from "./deploy/common";
+import { Module, salt } from "./deploy/common";
 import { getStorageAt } from "viem/actions";
 import { execa } from "execa";
 
@@ -15,7 +15,7 @@ type VerifyOptions = {
   verifier: string;
   verifierUrl?: string;
   systems: { name: string; bytecode: Hex }[];
-  modules: { name: string; bytecode: Hex }[];
+  modules: readonly Module[];
   worldAddress: Hex;
   /**
    * Address of determinstic deployment proxy: https://github.com/Arachnid/deterministic-deployment-proxy
@@ -39,7 +39,7 @@ export async function verify({
 }: VerifyOptions): Promise<void> {
   const deployerAddress = initialDeployerAddress ?? (await getDeployer(client));
   if (!deployerAddress) {
-    throw new MUDError(`No deployer`);
+    throw new MUDError("No deployer address provided or found.");
   }
 
   // If the proxy implementation storage slot is set on the World, the World was deployed as a proxy.
@@ -104,24 +104,22 @@ export async function verify({
       ),
     );
 
-    modules.map(({ name, bytecode }) =>
-      verifyQueue.add(() =>
+    modules.map(({ name, prepareDeploy }) => {
+      const { address } = prepareDeploy(deployerAddress, []);
+      return verifyQueue.add(() =>
         verifyContract({
+          // TODO: figure out dir from artifactPath via import.meta.resolve?
           cwd: "node_modules/@latticexyz/world-modules",
-          name: name,
+          name,
           rpc,
           verifier,
           verifierUrl,
-          address: getCreate2Address({
-            from: deployerAddress,
-            bytecode: bytecode,
-            salt,
-          }),
+          address,
         }).catch((error) => {
           console.error(`Error verifying module contract ${name}:`, error);
         }),
-      ),
-    );
+      );
+    });
 
     // If the world was deployed as a Proxy, verify the proxy and implementation.
     if (usesProxy) {