@latticexyz/cli 2.0.0-next.11 → 2.0.0-next.12

package/src/deploy/ensureTables.ts

@@ -0,0 +1,65 @@
+import { Client, Transport, Chain, Account, Hex } from "viem";
+import { Table } from "./configToTables";
+import { writeContract } from "@latticexyz/common";
+import { WorldDeploy, worldAbi } from "./common";
+import { valueSchemaToFieldLayoutHex, keySchemaToHex, valueSchemaToHex } from "@latticexyz/protocol-parser";
+import { debug } from "./debug";
+import { resourceLabel } from "./resourceLabel";
+import { getTables } from "./getTables";
+import pRetry from "p-retry";
+import { wait } from "@latticexyz/common/utils";
+
+export async function ensureTables({
+  client,
+  worldDeploy,
+  tables,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly tables: readonly Table[];
+}): Promise<readonly Hex[]> {
+  const worldTables = await getTables({ client, worldDeploy });
+  const worldTableIds = worldTables.map((table) => table.tableId);
+
+  const existingTables = tables.filter((table) => worldTableIds.includes(table.tableId));
+  if (existingTables.length) {
+    debug("existing tables", existingTables.map(resourceLabel).join(", "));
+  }
+
+  const missingTables = tables.filter((table) => !worldTableIds.includes(table.tableId));
+  if (missingTables.length) {
+    debug("registering tables", missingTables.map(resourceLabel).join(", "));
+    return await Promise.all(
+      missingTables.map((table) =>
+        pRetry(
+          () =>
+            writeContract(client, {
+              chain: client.chain ?? null,
+              address: worldDeploy.address,
+              abi: worldAbi,
+              // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+              functionName: "registerTable",
+              args: [
+                table.tableId,
+                valueSchemaToFieldLayoutHex(table.valueSchema),
+                keySchemaToHex(table.keySchema),
+                valueSchemaToHex(table.valueSchema),
+                Object.keys(table.keySchema),
+                Object.keys(table.valueSchema),
+              ],
+            }),
+          {
+            retries: 3,
+            onFailedAttempt: async (error) => {
+              const delay = error.attemptNumber * 500;
+              debug(`failed to register table ${resourceLabel(table)}, retrying in ${delay}ms...`);
+              await wait(delay);
+            },
+          }
+        )
+      )
+    );
+  }
+
+  return [];
+}

package/src/deploy/ensureWorldFactory.ts

@@ -0,0 +1,34 @@
+import coreModuleBuild from "@latticexyz/world/out/CoreModule.sol/CoreModule.json" assert { type: "json" };
+import worldFactoryBuild from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.json" assert { type: "json" };
+import { Client, Transport, Chain, Account, Hex, parseAbi, getCreate2Address, encodeDeployData } from "viem";
+import { deployer } from "./ensureDeployer";
+import { salt } from "./common";
+import { ensureContractsDeployed } from "./ensureContractsDeployed";
+
+export const coreModuleBytecode = encodeDeployData({
+  bytecode: coreModuleBuild.bytecode.object as Hex,
+  abi: [],
+});
+
+export const coreModule = getCreate2Address({ from: deployer, bytecode: coreModuleBytecode, salt });
+
+export const worldFactoryBytecode = encodeDeployData({
+  bytecode: worldFactoryBuild.bytecode.object as Hex,
+  abi: parseAbi(["constructor(address)"]),
+  args: [coreModule],
+});
+
+export const worldFactory = getCreate2Address({ from: deployer, bytecode: worldFactoryBytecode, salt });
+
+export async function ensureWorldFactory(
+  client: Client<Transport, Chain | undefined, Account>
+): Promise<readonly Hex[]> {
+  // WorldFactory constructor doesn't call CoreModule, only sets its address, so we can do these in parallel since the address is deterministic
+  return await ensureContractsDeployed({
+    client,
+    contracts: [
+      { bytecode: coreModuleBytecode, label: "core module" },
+      { bytecode: worldFactoryBytecode, label: "world factory" },
+    ],
+  });
+}

package/src/deploy/getFunctions.ts

@@ -0,0 +1,58 @@
+import { Client, getFunctionSelector, 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";
+import { getTableValue } from "./getTableValue";
+import { hexToResource } from "@latticexyz/common";
+
+export async function getFunctions({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  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, {
+    strict: true,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    event: parseAbiItem(storeSetRecordEvent),
+    args: { tableId: worldTables.world_FunctionSignatures.tableId },
+  });
+
+  const signatures = logs.map((log) => {
+    const value = decodeValueArgs(worldTables.world_FunctionSignatures.valueSchema, log.args);
+    return value.functionSignature;
+  });
+  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 = getFunctionSelector(signature);
+      const { systemId, systemFunctionSelector } = await getTableValue({
+        client,
+        worldDeploy,
+        table: worldTables.world_FunctionSelectors,
+        key: { functionSelector: 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,
+      };
+    })
+  );
+
+  return functions;
+}

package/src/deploy/getResourceAccess.ts

@@ -0,0 +1,51 @@
+import { Client, parseAbiItem, Hex, Address, getAddress } from "viem";
+import { WorldDeploy, worldTables } from "./common";
+import { debug } from "./debug";
+import { storeSpliceStaticDataEvent } from "@latticexyz/store";
+import { getLogs } from "viem/actions";
+import { decodeKey } from "@latticexyz/protocol-parser";
+import { getTableValue } from "./getTableValue";
+
+export async function getResourceAccess({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly { readonly resourceId: Hex; readonly address: Address }[]> {
+  // This assumes we only use `ResourceAccess._set(...)`, which is true as of this writing.
+  // TODO: PR to viem's getLogs to accept topics array so we can filter on all store events and quickly recreate this table's current state
+
+  debug("looking up resource access for", worldDeploy.address);
+
+  const logs = await getLogs(client, {
+    strict: true,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    // our usage of `ResourceAccess._set(...)` emits a splice instead of set record
+    // TODO: https://github.com/latticexyz/mud/issues/479
+    event: parseAbiItem(storeSpliceStaticDataEvent),
+    args: { tableId: worldTables.world_ResourceAccess.tableId },
+  });
+
+  const keys = logs.map((log) => decodeKey(worldTables.world_ResourceAccess.keySchema, log.args.keyTuple));
+
+  const access = (
+    await Promise.all(
+      keys.map(
+        async (key) =>
+          [key, await getTableValue({ client, worldDeploy, table: worldTables.world_ResourceAccess, key })] as const
+      )
+    )
+  )
+    .filter(([, value]) => value.access)
+    .map(([key]) => ({
+      resourceId: key.resourceId,
+      address: getAddress(key.caller),
+    }));
+
+  debug("found", access.length, "resource<>address access pairs");
+
+  return access;
+}

package/src/deploy/getResourceIds.ts

@@ -0,0 +1,31 @@
+import { Client, parseAbiItem, Hex } from "viem";
+import { getLogs } from "viem/actions";
+import { storeSpliceStaticDataEvent } from "@latticexyz/store";
+import { WorldDeploy, storeTables } from "./common";
+import { debug } from "./debug";
+
+export async function getResourceIds({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly Hex[]> {
+  // This assumes we only use `ResourceIds._setExists(true)`, which is true as of this writing.
+  // TODO: PR to viem's getLogs to accept topics array so we can filter on all store events and quickly recreate this table's current state
+
+  debug("looking up resource IDs for", worldDeploy.address);
+  const logs = await getLogs(client, {
+    strict: true,
+    address: worldDeploy.address,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    event: parseAbiItem(storeSpliceStaticDataEvent),
+    args: { tableId: storeTables.store_ResourceIds.tableId },
+  });
+
+  const resourceIds = logs.map((log) => log.args.keyTuple[0]);
+  debug("found", resourceIds.length, "resource IDs for", worldDeploy.address);
+
+  return resourceIds;
+}

package/src/deploy/getSystems.ts

@@ -0,0 +1,48 @@
+import { System, WorldDeploy, worldTables } from "./common";
+import { Client } from "viem";
+import { getResourceIds } from "./getResourceIds";
+import { hexToResource } from "@latticexyz/common";
+import { getTableValue } from "./getTableValue";
+import { debug } from "./debug";
+import { resourceLabel } from "./resourceLabel";
+import { getFunctions } from "./getFunctions";
+import { getResourceAccess } from "./getResourceAccess";
+
+export async function getSystems({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly Omit<System, "abi" | "bytecode">[]> {
+  const [resourceIds, functions, resourceAccess] = await Promise.all([
+    getResourceIds({ client, worldDeploy }),
+    getFunctions({ client, worldDeploy }),
+    getResourceAccess({ client, worldDeploy }),
+  ]);
+  const systems = resourceIds.map(hexToResource).filter((resource) => resource.type === "system");
+
+  debug("looking up systems", systems.map(resourceLabel).join(", "));
+  return await Promise.all(
+    systems.map(async (system) => {
+      const { system: address, publicAccess } = await getTableValue({
+        client,
+        worldDeploy,
+        table: worldTables.world_Systems,
+        key: { systemId: system.resourceId },
+      });
+      const systemFunctions = functions.filter((func) => func.systemId === system.resourceId);
+      return {
+        address,
+        namespace: system.namespace,
+        name: system.name,
+        systemId: system.resourceId,
+        allowAll: publicAccess,
+        allowedAddresses: resourceAccess
+          .filter(({ resourceId }) => resourceId === system.resourceId)
+          .map(({ address }) => address),
+        functions: systemFunctions,
+      };
+    })
+  );
+}

package/src/deploy/getTableValue.ts

@@ -0,0 +1,30 @@
+import { SchemaToPrimitives, decodeValueArgs, encodeKey } from "@latticexyz/protocol-parser";
+import { WorldDeploy, worldAbi } from "./common";
+import { Client } from "viem";
+import { readContract } from "viem/actions";
+import { Table } from "./configToTables";
+
+export async function getTableValue<table extends Table>({
+  client,
+  worldDeploy,
+  table,
+  key,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+  readonly table: table;
+  readonly key: SchemaToPrimitives<table["keySchema"]>;
+}): Promise<SchemaToPrimitives<table["valueSchema"]>> {
+  const [staticData, encodedLengths, dynamicData] = await readContract(client, {
+    blockNumber: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    abi: worldAbi,
+    functionName: "getRecord",
+    args: [table.tableId, encodeKey(table.keySchema, key)],
+  });
+  return decodeValueArgs(table.valueSchema, {
+    staticData,
+    encodedLengths,
+    dynamicData,
+  });
+}

package/src/deploy/getTables.ts

@@ -0,0 +1,59 @@
+import { Client, parseAbiItem, decodeAbiParameters, parseAbiParameters } from "viem";
+import { Table } from "./configToTables";
+import { hexToResource } from "@latticexyz/common";
+import { WorldDeploy, storeTables } from "./common";
+import { debug } from "./debug";
+import { storeSetRecordEvent } from "@latticexyz/store";
+import { getLogs } from "viem/actions";
+import { KeySchema, ValueSchema, decodeKey, decodeValueArgs, hexToSchema } from "@latticexyz/protocol-parser";
+
+export async function getTables({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly Table[]> {
+  // This assumes we only use `Tables._set(...)`, which is true as of this writing.
+  // TODO: PR to viem's getLogs to accept topics array so we can filter on all store events and quickly recreate this table's current state
+  // TODO: consider moving this to a batched getRecord for Tables table
+
+  debug("looking up tables for", worldDeploy.address);
+  const logs = await getLogs(client, {
+    strict: true,
+    // this may fail for certain RPC providers with block range limits
+    // if so, could potentially use our fetchLogs helper (which does pagination)
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    event: parseAbiItem(storeSetRecordEvent),
+    args: { tableId: storeTables.store_Tables.tableId },
+  });
+
+  // TODO: combine with store-sync logToTable and export from somewhere
+  const tables = logs.map((log) => {
+    const { tableId } = decodeKey(storeTables.store_Tables.keySchema, log.args.keyTuple);
+    const { namespace, name } = hexToResource(tableId);
+    const value = decodeValueArgs(storeTables.store_Tables.valueSchema, log.args);
+
+    // TODO: migrate to better helper
+    const keySchemaFields = hexToSchema(value.keySchema);
+    const valueSchemaFields = hexToSchema(value.valueSchema);
+    const keyNames = decodeAbiParameters(parseAbiParameters("string[]"), value.abiEncodedKeyNames)[0];
+    const fieldNames = decodeAbiParameters(parseAbiParameters("string[]"), value.abiEncodedFieldNames)[0];
+
+    const valueAbiTypes = [...valueSchemaFields.staticFields, ...valueSchemaFields.dynamicFields];
+
+    const keySchema = Object.fromEntries(
+      keySchemaFields.staticFields.map((abiType, i) => [keyNames[i], abiType])
+    ) as KeySchema;
+    const valueSchema = Object.fromEntries(valueAbiTypes.map((abiType, i) => [fieldNames[i], abiType])) as ValueSchema;
+
+    return { namespace, name, tableId, keySchema, valueSchema } as const;
+  });
+  // TODO: filter/detect duplicates?
+
+  debug("found", tables.length, "tables for", worldDeploy.address);
+
+  return tables;
+}

package/src/deploy/getWorldDeploy.ts

@@ -0,0 +1,39 @@
+import { Client, Address, getAddress, parseAbi } from "viem";
+import { getBlockNumber, getLogs } from "viem/actions";
+import { WorldDeploy, worldDeployEvents } from "./common";
+import { debug } from "./debug";
+import { logsToWorldDeploy } from "./logsToWorldDeploy";
+
+const deploys = new Map<Address, WorldDeploy>();
+
+export async function getWorldDeploy(client: Client, worldAddress: Address): Promise<WorldDeploy> {
+  const address = getAddress(worldAddress);
+
+  let deploy = deploys.get(address);
+  if (deploy != null) {
+    return deploy;
+  }
+
+  debug("looking up world deploy for", address);
+
+  const stateBlock = await getBlockNumber(client);
+  const logs = await getLogs(client, {
+    strict: true,
+    address,
+    events: parseAbi(worldDeployEvents),
+    // this may fail for certain RPC providers with block range limits
+    // if so, could potentially use our fetchLogs helper (which does pagination)
+    fromBlock: "earliest",
+    toBlock: stateBlock,
+  });
+
+  deploy = {
+    ...logsToWorldDeploy(logs),
+    stateBlock,
+  };
+  deploys.set(address, deploy);
+
+  debug("found world deploy for", address, "at block", deploy.deployBlock);
+
+  return deploy;
+}

package/src/deploy/logsToWorldDeploy.ts

@@ -0,0 +1,49 @@
+import { AbiEventSignatureNotFoundError, Log, decodeEventLog, hexToString, parseAbi, trim } from "viem";
+import { WorldDeploy, worldDeployEvents } from "./common";
+import { isDefined } from "@latticexyz/common/utils";
+
+export function logsToWorldDeploy(logs: readonly Log<bigint, number, false>[]): Omit<WorldDeploy, "stateBlock"> {
+  const deployLogs = logs
+    .map((log) => {
+      try {
+        return {
+          ...log,
+          ...decodeEventLog({
+            strict: true,
+            abi: parseAbi(worldDeployEvents),
+            topics: log.topics,
+            data: log.data,
+          }),
+        };
+      } catch (error: unknown) {
+        if (error instanceof AbiEventSignatureNotFoundError) {
+          return;
+        }
+        throw error;
+      }
+    })
+    .filter(isDefined);
+
+  // TODO: should this test for/validate that only one of each of these events is present? and that the address/block number don't change between each?
+  const { address, deployBlock, worldVersion, storeVersion } = deployLogs.reduce<Partial<WorldDeploy>>(
+    (deploy, log) => ({
+      ...deploy,
+      address: log.address,
+      deployBlock: log.blockNumber,
+      ...(log.eventName === "HelloWorld"
+        ? { worldVersion: hexToString(trim(log.args.worldVersion, { dir: "right" })) }
+        : null),
+      ...(log.eventName === "HelloStore"
+        ? { storeVersion: hexToString(trim(log.args.storeVersion, { dir: "right" })) }
+        : null),
+    }),
+    {}
+  );
+
+  if (address == null) throw new Error("could not find world address");
+  if (deployBlock == null) throw new Error("could not find world deploy block number");
+  if (worldVersion == null) throw new Error("could not find world version");
+  if (storeVersion == null) throw new Error("could not find store version");
+
+  return { address, deployBlock, worldVersion, storeVersion };
+}

package/src/deploy/resolveConfig.ts

@@ -0,0 +1,154 @@
+import { resolveWorldConfig } from "@latticexyz/world";
+import { Config, ConfigInput, WorldFunction, salt } from "./common";
+import { resourceToHex, hexToResource } from "@latticexyz/common";
+import { resolveWithContext } from "@latticexyz/config";
+import { encodeField } from "@latticexyz/protocol-parser";
+import { SchemaAbiType, SchemaAbiTypeToPrimitiveType } from "@latticexyz/schema-type";
+import {
+  getFunctionSelector,
+  Hex,
+  getCreate2Address,
+  getAddress,
+  hexToBytes,
+  Abi,
+  bytesToHex,
+  getFunctionSignature,
+} from "viem";
+import { getExistingContracts } from "../utils/getExistingContracts";
+import { defaultModuleContracts } from "../utils/modules/constants";
+import { getContractData } from "../utils/utils/getContractData";
+import { configToTables } from "./configToTables";
+import { deployer } from "./ensureDeployer";
+import { resourceLabel } from "./resourceLabel";
+
+// TODO: this should be replaced by https://github.com/latticexyz/mud/issues/1668
+
+export function resolveConfig<config extends ConfigInput>({
+  config,
+  forgeSourceDir,
+  forgeOutDir,
+}: {
+  config: config;
+  forgeSourceDir: string;
+  forgeOutDir: string;
+}): Config<config> {
+  const tables = configToTables(config);
+
+  // TODO: should the config parser/loader help with resolving systems?
+  const contractNames = getExistingContracts(forgeSourceDir).map(({ basename }) => basename);
+  const resolvedConfig = resolveWorldConfig(config, contractNames);
+  const baseSystemContractData = getContractData("System", forgeOutDir);
+  const baseSystemFunctions = baseSystemContractData.abi
+    .filter((item): item is typeof item & { type: "function" } => item.type === "function")
+    .map(getFunctionSignature);
+
+  const systems = Object.entries(resolvedConfig.systems).map(([systemName, system]) => {
+    const namespace = config.namespace;
+    const name = system.name;
+    const systemId = resourceToHex({ type: "system", namespace, name });
+    const contractData = getContractData(systemName, forgeOutDir);
+
+    const systemFunctions = contractData.abi
+      .filter((item): item is typeof item & { type: "function" } => item.type === "function")
+      .map(getFunctionSignature)
+      .filter((sig) => !baseSystemFunctions.includes(sig))
+      .map((sig): WorldFunction => {
+        // TODO: figure out how to not duplicate contract behavior (https://github.com/latticexyz/mud/issues/1708)
+        const worldSignature = namespace === "" ? sig : `${namespace}_${name}_${sig}`;
+        return {
+          signature: worldSignature,
+          selector: getFunctionSelector(worldSignature),
+          systemId,
+          systemFunctionSignature: sig,
+          systemFunctionSelector: getFunctionSelector(sig),
+        };
+      });
+
+    return {
+      namespace,
+      name,
+      systemId,
+      allowAll: system.openAccess,
+      allowedAddresses: system.accessListAddresses as Hex[],
+      allowedSystemIds: system.accessListSystems.map((name) =>
+        resourceToHex({ type: "system", namespace, name: resolvedConfig.systems[name].name })
+      ),
+      address: getCreate2Address({ from: deployer, bytecode: contractData.bytecode, salt }),
+      bytecode: contractData.bytecode,
+      abi: contractData.abi,
+      functions: systemFunctions,
+    };
+  });
+
+  // resolve allowedSystemIds
+  // TODO: resolve this at deploy time so we can allow for arbitrary system IDs registered in the world as the source-of-truth rather than config
+  const systemsWithAccess = systems.map(({ allowedAddresses, allowedSystemIds, ...system }) => {
+    const allowedSystemAddresses = allowedSystemIds.map((systemId) => {
+      const targetSystem = systems.find((s) => s.systemId === systemId);
+      if (!targetSystem) {
+        throw new Error(
+          `System ${resourceLabel(system)} wanted access to ${resourceLabel(
+            hexToResource(systemId)
+          )}, but it wasn't found in the config.`
+        );
+      }
+      return targetSystem.address;
+    });
+    return {
+      ...system,
+      allowedAddresses: Array.from(
+        new Set([...allowedAddresses, ...allowedSystemAddresses].map((addr) => getAddress(addr)))
+      ),
+    };
+  });
+
+  // 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 defaultModules = defaultModuleContracts.map((mod) => ({
+    name: mod.name,
+    bytecode: (typeof mod.bytecode === "string" ? mod.bytecode : mod.bytecode.object) as Hex,
+    abi: mod.abi as Abi,
+  }));
+
+  const modules = config.modules.map((mod) => {
+    const contractData =
+      defaultModules.find((defaultMod) => defaultMod.name === mod.name) ?? getContractData(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],
+      address: getCreate2Address({ from: deployer, bytecode: contractData.bytecode, salt }),
+      bytecode: contractData.bytecode,
+      abi: contractData.abi,
+    };
+  });
+
+  return {
+    tables,
+    systems: systemsWithAccess,
+    modules,
+  };
+}

package/src/deploy/resourceLabel.ts

@@ -0,0 +1,3 @@
+export function resourceLabel({ namespace, name }: { readonly namespace: string; readonly name: string }): string {
+  return `${namespace}:${name}`;
+}

package/src/index.ts

@@ -1 +1 @@
-export * from "./utils/deployHandler";
+// nothing to export