@latticexyz/cli 2.0.0-main-257a0afc → 2.0.0-march-19-skystrife-playtest-f0a343b1

package/src/deploy/ensureFunctions.ts

@@ -29,7 +29,7 @@ export async function ensureFunctions({
         "found",
         wrongSystem.length,
         "functions already registered but pointing at a different system ID:",
-        wrongSystem.map((func) => func.signature).join(", "),
+        wrongSystem.map((func) => func.signature).join(", ")
       );
     }
   }
@@ -50,7 +50,7 @@ export async function ensureFunctions({
               abi: worldAbi,
               // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
               functionName: "registerRootFunctionSelector",
-              args: [func.systemId, func.systemFunctionSignature, func.systemFunctionSignature],
+              args: [func.systemId, func.systemFunctionSignature, func.systemFunctionSelector],
             }),
           {
             retries: 3,
@@ -59,7 +59,7 @@ export async function ensureFunctions({
               debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
               await wait(delay);
             },
-          },
+          }
         );
       }
       return pRetry(
@@ -79,8 +79,8 @@ export async function ensureFunctions({
             debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
             await wait(delay);
           },
-        },
+        }
       );
-    }),
+    })
   );
 }

package/src/deploy/ensureModules.ts

@@ -1,21 +1,17 @@
-import { Client, Transport, Chain, Account, Hex, BaseError } from "viem";
+import { Client, Transport, Chain, Account, Hex, BaseError, getAddress } from "viem";
 import { writeContract } from "@latticexyz/common";
-import { Library, Module, WorldDeploy, worldAbi } from "./common";
+import { Module, WorldDeploy, worldAbi } from "./common";
 import { debug } from "./debug";
-import { isDefined, wait } from "@latticexyz/common/utils";
+import { isDefined, uniqueBy, wait } from "@latticexyz/common/utils";
 import pRetry from "p-retry";
 import { ensureContractsDeployed } from "./ensureContractsDeployed";
 
 export async function ensureModules({
   client,
-  deployerAddress,
-  libraries,
   worldDeploy,
   modules,
 }: {
   readonly client: Client<Transport, Chain | undefined, Account>;
-  readonly deployerAddress: Hex;
-  readonly libraries: readonly Library[];
   readonly worldDeploy: WorldDeploy;
   readonly modules: readonly Module[];
 }): Promise<readonly Hex[]> {
@@ -23,9 +19,8 @@ export async function ensureModules({
 
   await ensureContractsDeployed({
     client,
-    deployerAddress,
-    contracts: modules.map((mod) => ({
-      bytecode: mod.prepareDeploy(deployerAddress, libraries).bytecode,
+    contracts: uniqueBy(modules, (mod) => getAddress(mod.address)).map((mod) => ({
+      bytecode: mod.bytecode,
       deployedBytecodeSize: mod.deployedBytecodeSize,
       label: `${mod.name} module`,
     })),
@@ -38,7 +33,6 @@ export async function ensureModules({
         pRetry(
           async () => {
             try {
-              const moduleAddress = mod.prepareDeploy(deployerAddress, libraries).address;
               return mod.installAsRoot
                 ? await writeContract(client, {
                     chain: client.chain ?? null,
@@ -46,7 +40,7 @@ export async function ensureModules({
                     abi: worldAbi,
                     // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
                     functionName: "installRootModule",
-                    args: [moduleAddress, mod.installData],
+                    args: [mod.address, mod.installData],
                   })
                 : await writeContract(client, {
                     chain: client.chain ?? null,
@@ -54,7 +48,7 @@ export async function ensureModules({
                     abi: worldAbi,
                     // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
                     functionName: "installModule",
-                    args: [moduleAddress, mod.installData],
+                    args: [mod.address, mod.installData],
                   });
             } catch (error) {
               if (error instanceof BaseError && error.message.includes("Module_AlreadyInstalled")) {
@@ -71,9 +65,9 @@ export async function ensureModules({
               debug(`failed to install module ${mod.name}, retrying in ${delay}ms...`);
               await wait(delay);
             },
-          },
-        ),
-      ),
+          }
+        )
+      )
     )
   ).filter(isDefined);
 }

package/src/deploy/ensureSystems.ts

@@ -1,25 +1,20 @@
-import { Client, Transport, Chain, Account, Hex, getAddress, Address } from "viem";
-import { writeContract, resourceToLabel } from "@latticexyz/common";
-import { Library, System, WorldDeploy, worldAbi } from "./common";
+import { Client, Transport, Chain, Account, Hex, getAddress } from "viem";
+import { writeContract } from "@latticexyz/common";
+import { System, WorldDeploy, worldAbi } from "./common";
 import { debug } from "./debug";
+import { resourceLabel } from "./resourceLabel";
 import { getSystems } from "./getSystems";
 import { getResourceAccess } from "./getResourceAccess";
-import { wait } from "@latticexyz/common/utils";
+import { uniqueBy, wait } from "@latticexyz/common/utils";
 import pRetry from "p-retry";
 import { ensureContractsDeployed } from "./ensureContractsDeployed";
 
-// TODO: move each system registration+access to batch call to be atomic
-
 export async function ensureSystems({
   client,
-  deployerAddress,
-  libraries,
   worldDeploy,
   systems,
 }: {
   readonly client: Client<Transport, Chain | undefined, Account>;
-  readonly deployerAddress: Hex;
-  readonly libraries: readonly Library[];
   readonly worldDeploy: WorldDeploy;
   readonly systems: readonly System[];
 }): Promise<readonly Hex[]> {
@@ -27,112 +22,30 @@ export async function ensureSystems({
     getSystems({ client, worldDeploy }),
     getResourceAccess({ client, worldDeploy }),
   ]);
-
-  // Register or replace systems
-
-  const existingSystems = systems.filter((system) =>
-    worldSystems.some(
-      (worldSystem) =>
-        worldSystem.systemId === system.systemId &&
-        getAddress(worldSystem.address) === getAddress(system.prepareDeploy(deployerAddress, libraries).address),
-    ),
-  );
-  if (existingSystems.length) {
-    debug("existing systems", existingSystems.map(resourceToLabel).join(", "));
-  }
-  const existingSystemIds = existingSystems.map((system) => system.systemId);
-
-  const missingSystems = systems.filter((system) => !existingSystemIds.includes(system.systemId));
-  if (!missingSystems.length) return [];
-
-  const systemsToUpgrade = missingSystems.filter((system) =>
-    worldSystems.some(
-      (worldSystem) =>
-        worldSystem.systemId === system.systemId &&
-        getAddress(worldSystem.address) !== getAddress(system.prepareDeploy(deployerAddress, libraries).address),
-    ),
-  );
-  if (systemsToUpgrade.length) {
-    debug("upgrading systems", systemsToUpgrade.map(resourceToLabel).join(", "));
-  }
-
-  const systemsToAdd = missingSystems.filter(
-    (system) => !worldSystems.some((worldSystem) => worldSystem.systemId === system.systemId),
-  );
-  if (systemsToAdd.length) {
-    debug("registering new systems", systemsToAdd.map(resourceToLabel).join(", "));
-  }
-
-  await ensureContractsDeployed({
-    client,
-    deployerAddress,
-    contracts: missingSystems.map((system) => ({
-      bytecode: system.prepareDeploy(deployerAddress, libraries).bytecode,
-      deployedBytecodeSize: system.deployedBytecodeSize,
-      label: `${resourceToLabel(system)} system`,
-    })),
-  });
-
-  const registerTxs = await Promise.all(
-    missingSystems.map((system) =>
-      pRetry(
-        () =>
-          writeContract(client, {
-            chain: client.chain ?? null,
-            address: worldDeploy.address,
-            abi: worldAbi,
-            // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
-            functionName: "registerSystem",
-            args: [system.systemId, system.prepareDeploy(deployerAddress, libraries).address, system.allowAll],
-          }),
-        {
-          retries: 3,
-          onFailedAttempt: async (error) => {
-            const delay = error.attemptNumber * 500;
-            debug(`failed to register system ${resourceToLabel(system)}, retrying in ${delay}ms...`);
-            await wait(delay);
-          },
-        },
-      ),
-    ),
-  );
-
-  // Adjust system access
-
   const systemIds = systems.map((system) => system.systemId);
   const currentAccess = worldAccess.filter(({ resourceId }) => systemIds.includes(resourceId));
-  const desiredAccess = [
-    ...systems.flatMap((system) =>
-      system.allowedAddresses.map((address) => ({ resourceId: system.systemId, address })),
-    ),
-    ...systems.flatMap((system) =>
-      system.allowedSystemIds
-        .map((systemId) => ({
-          resourceId: system.systemId,
-          address:
-            worldSystems.find((s) => s.systemId === systemId)?.address ??
-            systems.find((s) => s.systemId === systemId)?.prepareDeploy(deployerAddress, libraries).address,
-        }))
-        .filter((access): access is typeof access & { address: Address } => access.address != null),
-    ),
-  ];
+  const desiredAccess = systems.flatMap((system) =>
+    system.allowedAddresses.map((address) => ({ resourceId: system.systemId, address }))
+  );
 
   const accessToAdd = desiredAccess.filter(
     (access) =>
       !currentAccess.some(
         ({ resourceId, address }) =>
-          resourceId === access.resourceId && getAddress(address) === getAddress(access.address),
-      ),
+          resourceId === access.resourceId && getAddress(address) === getAddress(access.address)
+      )
   );
 
   const accessToRemove = currentAccess.filter(
     (access) =>
       !desiredAccess.some(
         ({ resourceId, address }) =>
-          resourceId === access.resourceId && getAddress(address) === getAddress(access.address),
-      ),
+          resourceId === access.resourceId && getAddress(address) === getAddress(access.address)
+      )
   );
 
+  // TODO: move each system access+registration to batch call to be atomic
+
   if (accessToRemove.length) {
     debug("revoking", accessToRemove.length, "access grants");
   }
@@ -140,7 +53,7 @@ export async function ensureSystems({
     debug("adding", accessToAdd.length, "access grants");
   }
 
-  const accessTxs = await Promise.all([
+  const accessTxs = [
     ...accessToRemove.map((access) =>
       pRetry(
         () =>
@@ -158,8 +71,8 @@ export async function ensureSystems({
             debug(`failed to revoke access, retrying in ${delay}ms...`);
             await wait(delay);
           },
-        },
-      ),
+        }
+      )
     ),
     ...accessToAdd.map((access) =>
       pRetry(
@@ -178,10 +91,72 @@ export async function ensureSystems({
             debug(`failed to grant access, retrying in ${delay}ms...`);
             await wait(delay);
           },
-        },
-      ),
+        }
+      )
     ),
-  ]);
+  ];
+
+  const existingSystems = systems.filter((system) =>
+    worldSystems.some(
+      (worldSystem) =>
+        worldSystem.systemId === system.systemId && getAddress(worldSystem.address) === getAddress(system.address)
+    )
+  );
+  if (existingSystems.length) {
+    debug("existing systems", existingSystems.map(resourceLabel).join(", "));
+  }
+  const existingSystemIds = existingSystems.map((system) => system.systemId);
+
+  const missingSystems = systems.filter((system) => !existingSystemIds.includes(system.systemId));
+  if (!missingSystems.length) return [];
+
+  const systemsToUpgrade = missingSystems.filter((system) =>
+    worldSystems.some(
+      (worldSystem) =>
+        worldSystem.systemId === system.systemId && getAddress(worldSystem.address) !== getAddress(system.address)
+    )
+  );
+  if (systemsToUpgrade.length) {
+    debug("upgrading systems", systemsToUpgrade.map(resourceLabel).join(", "));
+  }
+
+  const systemsToAdd = missingSystems.filter(
+    (system) => !worldSystems.some((worldSystem) => worldSystem.systemId === system.systemId)
+  );
+  if (systemsToAdd.length) {
+    debug("registering new systems", systemsToAdd.map(resourceLabel).join(", "));
+  }
+
+  await ensureContractsDeployed({
+    client,
+    contracts: uniqueBy(missingSystems, (system) => getAddress(system.address)).map((system) => ({
+      bytecode: system.bytecode,
+      deployedBytecodeSize: system.deployedBytecodeSize,
+      label: `${resourceLabel(system)} system`,
+    })),
+  });
+
+  const registerTxs = missingSystems.map((system) =>
+    pRetry(
+      () =>
+        writeContract(client, {
+          chain: client.chain ?? null,
+          address: worldDeploy.address,
+          abi: worldAbi,
+          // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+          functionName: "registerSystem",
+          args: [system.systemId, system.address, system.allowAll],
+        }),
+      {
+        retries: 3,
+        onFailedAttempt: async (error) => {
+          const delay = error.attemptNumber * 500;
+          debug(`failed to register system ${resourceLabel(system)}, retrying in ${delay}ms...`);
+          await wait(delay);
+        },
+      }
+    )
+  );
 
-  return [...registerTxs, ...accessTxs];
+  return await Promise.all([...accessTxs, ...registerTxs]);
 }

package/src/deploy/ensureTables.ts

@@ -1,9 +1,10 @@
 import { Client, Transport, Chain, Account, Hex } from "viem";
 import { Table } from "./configToTables";
-import { resourceToLabel, writeContract } from "@latticexyz/common";
+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";
@@ -22,12 +23,12 @@ export async function ensureTables({
 
   const existingTables = tables.filter((table) => worldTableIds.includes(table.tableId));
   if (existingTables.length) {
-    debug("existing tables", existingTables.map(resourceToLabel).join(", "));
+    debug("existing tables", existingTables.map(resourceLabel).join(", "));
   }
 
   const missingTables = tables.filter((table) => !worldTableIds.includes(table.tableId));
   if (missingTables.length) {
-    debug("registering tables", missingTables.map(resourceToLabel).join(", "));
+    debug("registering tables", missingTables.map(resourceLabel).join(", "));
     return await Promise.all(
       missingTables.map((table) =>
         pRetry(
@@ -51,12 +52,12 @@ export async function ensureTables({
             retries: 3,
             onFailedAttempt: async (error) => {
               const delay = error.attemptNumber * 500;
-              debug(`failed to register table ${resourceToLabel(table)}, retrying in ${delay}ms...`);
+              debug(`failed to register table ${resourceLabel(table)}, retrying in ${delay}ms...`);
               await wait(delay);
             },
-          },
-        ),
-      ),
+          }
+        )
+      )
     );
   }
 

package/src/deploy/ensureWorldFactory.ts

@@ -1,105 +1,47 @@
-import accessManagementSystemBuild from "@latticexyz/world/out/AccessManagementSystem.sol/AccessManagementSystem.json" assert { type: "json" };
-import balanceTransferSystemBuild from "@latticexyz/world/out/BalanceTransferSystem.sol/BalanceTransferSystem.json" assert { type: "json" };
-import batchCallSystemBuild from "@latticexyz/world/out/BatchCallSystem.sol/BatchCallSystem.json" assert { type: "json" };
-import registrationSystemBuild from "@latticexyz/world/out/RegistrationSystem.sol/RegistrationSystem.json" assert { type: "json" };
-import initModuleBuild from "@latticexyz/world/out/InitModule.sol/InitModule.json" assert { type: "json" };
-import initModuleAbi from "@latticexyz/world/out/InitModule.sol/InitModule.abi.json" assert { type: "json" };
+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 worldFactoryAbi from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json" assert { type: "json" };
-import { Client, Transport, Chain, Account, Hex, getCreate2Address, encodeDeployData, size, Address } from "viem";
+import { Client, Transport, Chain, Account, Hex, parseAbi, getCreate2Address, encodeDeployData, size } from "viem";
+import { deployer } from "./ensureDeployer";
 import { salt } from "./common";
 import { ensureContractsDeployed } from "./ensureContractsDeployed";
 import { Contract } from "./ensureContract";
 
-export async function ensureWorldFactory(
-  client: Client<Transport, Chain | undefined, Account>,
-  deployerAddress: Hex,
-): Promise<Address> {
-  const accessManagementSystemDeployedBytecodeSize = size(accessManagementSystemBuild.deployedBytecode.object as Hex);
-  const accessManagementSystemBytecode = accessManagementSystemBuild.bytecode.object as Hex;
-  const accessManagementSystem = getCreate2Address({
-    from: deployerAddress,
-    bytecode: accessManagementSystemBytecode,
-    salt,
-  });
-
-  const balanceTransferSystemDeployedBytecodeSize = size(balanceTransferSystemBuild.deployedBytecode.object as Hex);
-  const balanceTransferSystemBytecode = balanceTransferSystemBuild.bytecode.object as Hex;
-  const balanceTransferSystem = getCreate2Address({
-    from: deployerAddress,
-    bytecode: balanceTransferSystemBytecode,
-    salt,
-  });
-
-  const batchCallSystemDeployedBytecodeSize = size(batchCallSystemBuild.deployedBytecode.object as Hex);
-  const batchCallSystemBytecode = batchCallSystemBuild.bytecode.object as Hex;
-  const batchCallSystem = getCreate2Address({ from: deployerAddress, bytecode: batchCallSystemBytecode, salt });
-
-  const registrationDeployedBytecodeSize = size(registrationSystemBuild.deployedBytecode.object as Hex);
-  const registrationBytecode = registrationSystemBuild.bytecode.object as Hex;
-  const registration = getCreate2Address({
-    from: deployerAddress,
-    bytecode: registrationBytecode,
-    salt,
-  });
-
-  const initModuleDeployedBytecodeSize = size(initModuleBuild.deployedBytecode.object as Hex);
-  const initModuleBytecode = encodeDeployData({
-    bytecode: initModuleBuild.bytecode.object as Hex,
-    abi: initModuleAbi,
-    args: [accessManagementSystem, balanceTransferSystem, batchCallSystem, registration],
-  });
-
-  const initModule = getCreate2Address({ from: deployerAddress, bytecode: initModuleBytecode, salt });
-
-  const worldFactoryDeployedBytecodeSize = size(worldFactoryBuild.deployedBytecode.object as Hex);
-  const worldFactoryBytecode = encodeDeployData({
-    bytecode: worldFactoryBuild.bytecode.object as Hex,
-    abi: worldFactoryAbi,
-    args: [initModule],
-  });
+export const coreModuleDeployedBytecodeSize = size(coreModuleBuild.deployedBytecode.object as Hex);
+export const coreModuleBytecode = encodeDeployData({
+  bytecode: coreModuleBuild.bytecode.object as Hex,
+  abi: [],
+});
+
+export const coreModule = getCreate2Address({ from: deployer, bytecode: coreModuleBytecode, salt });
+
+export const worldFactoryDeployedBytecodeSize = size(worldFactoryBuild.deployedBytecode.object as Hex);
+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 const worldFactoryContracts: readonly Contract[] = [
+  {
+    bytecode: coreModuleBytecode,
+    deployedBytecodeSize: coreModuleDeployedBytecodeSize,
+    label: "core module",
+  },
+  {
+    bytecode: worldFactoryBytecode,
+    deployedBytecodeSize: worldFactoryDeployedBytecodeSize,
+    label: "world factory",
+  },
+];
 
-  const worldFactory = getCreate2Address({ from: deployerAddress, bytecode: worldFactoryBytecode, salt });
-
-  const worldFactoryContracts: readonly Contract[] = [
-    {
-      bytecode: accessManagementSystemBytecode,
-      deployedBytecodeSize: accessManagementSystemDeployedBytecodeSize,
-      label: "access management system",
-    },
-    {
-      bytecode: balanceTransferSystemBytecode,
-      deployedBytecodeSize: balanceTransferSystemDeployedBytecodeSize,
-      label: "balance transfer system",
-    },
-    {
-      bytecode: batchCallSystemBytecode,
-      deployedBytecodeSize: batchCallSystemDeployedBytecodeSize,
-      label: "batch call system",
-    },
-    {
-      bytecode: registrationBytecode,
-      deployedBytecodeSize: registrationDeployedBytecodeSize,
-      label: "core registration system",
-    },
-    {
-      bytecode: initModuleBytecode,
-      deployedBytecodeSize: initModuleDeployedBytecodeSize,
-      label: "core module",
-    },
-    {
-      bytecode: worldFactoryBytecode,
-      deployedBytecodeSize: worldFactoryDeployedBytecodeSize,
-      label: "world factory",
-    },
-  ];
-
-  // WorldFactory constructor doesn't call InitModule, only sets its address, so we can do these in parallel since the address is deterministic
-  await ensureContractsDeployed({
+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,
-    deployerAddress,
     contracts: worldFactoryContracts,
   });
-
-  return worldFactory;
 }

package/src/deploy/getFunctions.ts

@@ -1,4 +1,4 @@
-import { Client, toFunctionSelector, parseAbiItem } from "viem";
+import { Client, getFunctionSelector, parseAbiItem } from "viem";
 import { WorldDeploy, WorldFunction, worldTables } from "./common";
 import { debug } from "./debug";
 import { storeSetRecordEvent } from "@latticexyz/store";
@@ -34,12 +34,12 @@ export async function getFunctions({
   // TODO: parallelize with a bulk getRecords
   const functions = await Promise.all(
     signatures.map(async (signature) => {
-      const selector = toFunctionSelector(signature);
+      const selector = getFunctionSelector(signature);
       const { systemId, systemFunctionSelector } = await getTableValue({
         client,
         worldDeploy,
         table: worldTables.world_FunctionSelectors,
-        key: { worldFunctionSelector: selector },
+        key: { functionSelector: selector },
       });
       const { namespace, name } = hexToResource(systemId);
       // TODO: find away around undoing contract logic (https://github.com/latticexyz/mud/issues/1708)
@@ -51,7 +51,7 @@ export async function getFunctions({
         systemFunctionSignature,
         systemFunctionSelector,
       };
-    }),
+    })
   );
 
   return functions;

package/src/deploy/getResourceAccess.ts

@@ -35,8 +35,8 @@ export async function getResourceAccess({
     await Promise.all(
       keys.map(
         async (key) =>
-          [key, await getTableValue({ client, worldDeploy, table: worldTables.world_ResourceAccess, key })] as const,
-      ),
+          [key, await getTableValue({ client, worldDeploy, table: worldTables.world_ResourceAccess, key })] as const
+      )
     )
   )
     .filter(([, value]) => value.access)

package/src/deploy/getSystems.ts

@@ -1,9 +1,10 @@
-import { DeployedSystem, WorldDeploy, worldTables } from "./common";
+import { System, WorldDeploy, worldTables } from "./common";
 import { Client } from "viem";
 import { getResourceIds } from "./getResourceIds";
-import { hexToResource, resourceToLabel } from "@latticexyz/common";
+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";
 
@@ -13,7 +14,7 @@ export async function getSystems({
 }: {
   readonly client: Client;
   readonly worldDeploy: WorldDeploy;
-}): Promise<readonly DeployedSystem[]> {
+}): Promise<readonly Omit<System, "abi" | "bytecode" | "deployedBytecodeSize">[]> {
   const [resourceIds, functions, resourceAccess] = await Promise.all([
     getResourceIds({ client, worldDeploy }),
     getFunctions({ client, worldDeploy }),
@@ -21,9 +22,9 @@ export async function getSystems({
   ]);
   const systems = resourceIds.map(hexToResource).filter((resource) => resource.type === "system");
 
-  debug("looking up systems", systems.map(resourceToLabel).join(", "));
+  debug("looking up systems", systems.map(resourceLabel).join(", "));
   return await Promise.all(
-    systems.map(async (system): Promise<DeployedSystem> => {
+    systems.map(async (system) => {
       const { system: address, publicAccess } = await getTableValue({
         client,
         worldDeploy,
@@ -42,6 +43,6 @@ export async function getSystems({
           .map(({ address }) => address),
         functions: systemFunctions,
       };
-    }),
+    })
   );
 }

package/src/deploy/getTables.ts

@@ -45,7 +45,7 @@ export async function getTables({
     const valueAbiTypes = [...valueSchemaFields.staticFields, ...valueSchemaFields.dynamicFields];
 
     const keySchema = Object.fromEntries(
-      keySchemaFields.staticFields.map((abiType, i) => [keyNames[i], abiType]),
+      keySchemaFields.staticFields.map((abiType, i) => [keyNames[i], abiType])
     ) as KeySchema;
     const valueSchema = Object.fromEntries(valueAbiTypes.map((abiType, i) => [fieldNames[i], abiType])) as ValueSchema;
 

package/src/deploy/logsToWorldDeploy.ts

@@ -37,7 +37,7 @@ export function logsToWorldDeploy(logs: readonly Log<bigint, number, false>[]):
         ? { storeVersion: hexToString(trim(log.args.storeVersion, { dir: "right" })) }
         : null),
     }),
-    {},
+    {}
   );
 
   if (address == null) throw new Error("could not find world address");