@latticexyz/cli 2.0.12-main-9be2bb86 → 2.0.12-main-96e7bf43

package/src/deploy/findLibraries.ts

@@ -1,36 +0,0 @@
-import { readFileSync } from "fs";
-import glob from "glob";
-import { orderByDependencies } from "./orderByDependencies";
-import { LinkReferences } from "../utils/findPlaceholders";
-
-export function findLibraries(forgeOutDir: string): readonly {
-  readonly path: string;
-  readonly name: string;
-}[] {
-  const artifacts = glob
-    .sync(`${forgeOutDir}/**/*.json`, { ignore: "**/*.abi.json" })
-    .map((path) => JSON.parse(readFileSync(path, "utf8")));
-
-  const libraries = artifacts.flatMap((artifact) => {
-    if (!artifact.metadata) return [];
-
-    const contractPath = Object.keys(artifact.metadata.settings.compilationTarget)[0];
-    const contractName = artifact.metadata.settings.compilationTarget[contractPath];
-    const linkReferences = artifact.bytecode.linkReferences as LinkReferences;
-
-    return Object.entries(linkReferences).flatMap(([libraryPath, reference]) =>
-      Object.keys(reference).map((libraryName) => ({
-        path: libraryPath,
-        name: libraryName,
-        dependentPath: contractPath,
-        dependentName: contractName,
-      })),
-    );
-  });
-
-  return orderByDependencies(
-    libraries,
-    (lib) => `${lib.path}:${lib.name}`,
-    (lib) => [`${lib.dependentPath}:${lib.dependentName}`],
-  );
-}

package/src/deploy/getDeployer.ts

@@ -1,20 +0,0 @@
-import { Address, Chain, Client, Transport, sliceHex } from "viem";
-import { getBytecode } from "viem/actions";
-import deployment from "./create2/deployment.json";
-import { debug } from "./debug";
-
-const deployer = `0x${deployment.address}` as const;
-
-export async function getDeployer(client: Client<Transport, Chain | undefined>): Promise<Address | undefined> {
-  const bytecode = await getBytecode(client, { address: deployer });
-  if (bytecode) {
-    debug("found CREATE2 deployer at", deployer);
-    // check if deployed bytecode is the same as the expected bytecode (minus 14-bytes creation code prefix)
-    if (bytecode !== sliceHex(`0x${deployment.creationCode}`, 14)) {
-      console.warn(
-        `\n  ⚠️ Bytecode for deployer at ${deployer} did not match the expected CREATE2 bytecode. You may have unexpected results.\n`,
-      );
-    }
-    return deployer;
-  }
-}

package/src/deploy/getFunctions.ts

@@ -1,64 +0,0 @@
-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 { decodeKey, decodeValueArgs } from "@latticexyz/protocol-parser/internal";
-
-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 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_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);
-
-  // 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 },
-  });
-
-  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/getResourceAccess.ts

@@ -1,51 +0,0 @@
-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/internal";
-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

@@ -1,45 +0,0 @@
-import { Client, parseAbiItem, Hex, HttpRequestError } from "viem";
-import { getLogs } from "viem/actions";
-import { storeSpliceStaticDataEvent } from "@latticexyz/store";
-import { WorldDeploy, storeTables } from "./common";
-import { debug } from "./debug";
-import pRetry from "p-retry";
-
-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 pRetry(
-    () =>
-      getLogs(client, {
-        strict: true,
-        address: worldDeploy.address,
-        fromBlock: worldDeploy.deployBlock,
-        toBlock: worldDeploy.stateBlock,
-        event: parseAbiItem(storeSpliceStaticDataEvent),
-        args: { tableId: storeTables.store_ResourceIds.tableId },
-      }),
-    {
-      retries: 3,
-      onFailedAttempt: async (error) => {
-        const shouldRetry =
-          error instanceof HttpRequestError && error.status === 400 && error.message.includes("block is out of range");
-
-        if (!shouldRetry) {
-          throw error;
-        }
-      },
-    },
-  );
-  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

@@ -1,47 +0,0 @@
-import { DeployedSystem, WorldDeploy, worldTables } from "./common";
-import { Client } from "viem";
-import { getResourceIds } from "./getResourceIds";
-import { hexToResource, resourceToLabel } from "@latticexyz/common";
-import { getTableValue } from "./getTableValue";
-import { debug } from "./debug";
-import { getFunctions } from "./getFunctions";
-import { getResourceAccess } from "./getResourceAccess";
-
-export async function getSystems({
-  client,
-  worldDeploy,
-}: {
-  readonly client: Client;
-  readonly worldDeploy: WorldDeploy;
-}): Promise<readonly DeployedSystem[]> {
-  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(resourceToLabel).join(", "));
-  return await Promise.all(
-    systems.map(async (system): Promise<DeployedSystem> => {
-      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

@@ -1,31 +0,0 @@
-import { SchemaToPrimitives, decodeValueArgs, encodeKey } from "@latticexyz/protocol-parser/internal";
-import { WorldDeploy, worldAbi } from "./common";
-import { Client, Hex } 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)],
-    // TODO: remove cast once https://github.com/wevm/viem/issues/2125 is resolved
-  })) as [Hex, Hex, Hex];
-  return decodeValueArgs(table.valueSchema, {
-    staticData,
-    encodedLengths,
-    dynamicData,
-  });
-}

package/src/deploy/getTables.ts

@@ -1,59 +0,0 @@
-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/internal";
-
-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/getWorldContracts.ts

@@ -1,79 +0,0 @@
-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 { Hex, getCreate2Address, encodeDeployData, size } from "viem";
-import { salt } from "./common";
-
-export function getWorldContracts(deployerAddress: Hex) {
-  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 });
-
-  return {
-    AccessManagementSystem: {
-      bytecode: accessManagementSystemBytecode,
-      deployedBytecodeSize: accessManagementSystemDeployedBytecodeSize,
-      label: "access management system",
-      address: accessManagementSystem,
-    },
-    BalanceTransferSystem: {
-      bytecode: balanceTransferSystemBytecode,
-      deployedBytecodeSize: balanceTransferSystemDeployedBytecodeSize,
-      label: "balance transfer system",
-      address: balanceTransferSystem,
-    },
-    BatchCallSystem: {
-      bytecode: batchCallSystemBytecode,
-      deployedBytecodeSize: batchCallSystemDeployedBytecodeSize,
-      label: "batch call system",
-      address: batchCallSystem,
-    },
-    RegistrationSystem: {
-      bytecode: registrationBytecode,
-      deployedBytecodeSize: registrationDeployedBytecodeSize,
-      label: "core registration system",
-      address: registration,
-    },
-    InitModule: {
-      bytecode: initModuleBytecode,
-      deployedBytecodeSize: initModuleDeployedBytecodeSize,
-      label: "core module",
-      address: initModule,
-    },
-  };
-}

package/src/deploy/getWorldDeploy.ts

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

@@ -1,27 +0,0 @@
-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 { Hex, getCreate2Address, encodeDeployData, size } from "viem";
-import { salt } from "./common";
-import { getWorldContracts } from "./getWorldContracts";
-
-export function getWorldFactoryContracts(deployerAddress: Hex) {
-  const worldContracts = getWorldContracts(deployerAddress);
-
-  const worldFactoryDeployedBytecodeSize = size(worldFactoryBuild.deployedBytecode.object as Hex);
-  const worldFactoryBytecode = encodeDeployData({
-    bytecode: worldFactoryBuild.bytecode.object as Hex,
-    abi: worldFactoryAbi,
-    args: [worldContracts.InitModule.address],
-  });
-  const worldFactory = getCreate2Address({ from: deployerAddress, bytecode: worldFactoryBytecode, salt });
-
-  return {
-    ...worldContracts,
-    WorldFactory: {
-      bytecode: worldFactoryBytecode,
-      deployedBytecodeSize: worldFactoryDeployedBytecodeSize,
-      label: "world factory",
-      address: worldFactory,
-    },
-  };
-}

package/src/deploy/getWorldProxyFactoryContracts.ts

@@ -1,27 +0,0 @@
-import worldProxyFactoryBuild from "@latticexyz/world/out/WorldProxyFactory.sol/WorldProxyFactory.json" assert { type: "json" };
-import worldProxyFactoryAbi from "@latticexyz/world/out/WorldProxyFactory.sol/WorldProxyFactory.abi.json" assert { type: "json" };
-import { Hex, getCreate2Address, encodeDeployData, size } from "viem";
-import { salt } from "./common";
-import { getWorldContracts } from "./getWorldContracts";
-
-export function getWorldProxyFactoryContracts(deployerAddress: Hex) {
-  const worldContracts = getWorldContracts(deployerAddress);
-
-  const worldProxyFactoryDeployedBytecodeSize = size(worldProxyFactoryBuild.deployedBytecode.object as Hex);
-  const worldProxyFactoryBytecode = encodeDeployData({
-    bytecode: worldProxyFactoryBuild.bytecode.object as Hex,
-    abi: worldProxyFactoryAbi,
-    args: [worldContracts.InitModule.address],
-  });
-  const worldProxyFactory = getCreate2Address({ from: deployerAddress, bytecode: worldProxyFactoryBytecode, salt });
-
-  return {
-    ...worldContracts,
-    WorldProxyFactory: {
-      bytecode: worldProxyFactoryBytecode,
-      deployedBytecodeSize: worldProxyFactoryDeployedBytecodeSize,
-      label: "world proxy factory",
-      address: worldProxyFactory,
-    },
-  };
-}

package/src/deploy/logsToWorldDeploy.ts

@@ -1,49 +0,0 @@
-import { AbiEventSignatureNotFoundError, Log, decodeEventLog, hexToString, parseAbi } 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(log.args.worldVersion).replace(/\0+$/, "") }
-        : null),
-      ...(log.eventName === "HelloStore"
-        ? { storeVersion: hexToString(log.args.storeVersion).replace(/\0+$/, "") }
-        : 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/orderByDependencies.ts

@@ -1,12 +0,0 @@
-import toposort from "toposort";
-
-export function orderByDependencies<T>(
-  items: readonly T[],
-  itemKey: (item: T) => string,
-  dependencyKeys: (item: T) => string[],
-): readonly T[] {
-  const dependencyOrder = toposort(
-    items.flatMap((item) => dependencyKeys(item).map((dependency) => [itemKey(item), dependency] as [string, string])),
-  );
-  return [...items].sort((a, b) => dependencyOrder.indexOf(itemKey(a)) - dependencyOrder.indexOf(itemKey(b)));
-}