Revert "feat(world): support namespaced systems" (#2918)

examples/minimal/packages/contracts/mud.config.ts

@@ -8,6 +8,10 @@ export default defineWorld({
       openAccess: true,
     },
   },
+  excludeSystems: [
+    // Until namespace overrides, this system must be manually deployed in PostDeploy
+    "ChatNamespacedSystem",
+  ],
   tables: {
     CounterTable: {
       schema: {

examples/minimal/packages/contracts/script/PostDeploy.s.sol

@@ -6,11 +6,10 @@ import { console } from "forge-std/console.sol";
 import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
 import { ResourceId, WorldResourceIdLib, WorldResourceIdInstance } from "@latticexyz/world/src/WorldResourceId.sol";
 import { RESOURCE_SYSTEM } from "@latticexyz/world/src/worldResourceTypes.sol";
-import { Systems } from "@latticexyz/world/src/codegen/tables/Systems.sol";
 
 import { MessageTable } from "../src/codegen/index.sol";
 import { IWorld } from "../src/codegen/world/IWorld.sol";
-import { namespace__ChatSystem } from "../src/systems/namespace__ChatSystem.sol";
+import { ChatNamespacedSystem } from "../src/systems/ChatNamespacedSystem.sol";
 
 contract PostDeploy is Script {
   using WorldResourceIdInstance for ResourceId;
@@ -25,15 +24,19 @@ contract PostDeploy is Script {
     // Start broadcasting transactions from the deployer account
     vm.startBroadcast(deployerPrivateKey);
 
+    // Manually deploy a system with another namespace
+    ChatNamespacedSystem chatNamespacedSystem = new ChatNamespacedSystem();
     ResourceId systemId = WorldResourceIdLib.encode({
       typeId: RESOURCE_SYSTEM,
       namespace: "namespace",
-      name: "ChatSystem"
+      name: "ChatNamespaced"
     });
-    address chatSystem = Systems.getSystem(systemId);
+    IWorld(worldAddress).registerNamespace(systemId.getNamespaceId());
+    IWorld(worldAddress).registerSystem(systemId, chatNamespacedSystem, true);
+    IWorld(worldAddress).registerFunctionSelector(systemId, "sendMessage(string)");
 
     // Grant this system access to MessageTable
-    IWorld(worldAddress).grantAccess(MessageTable._tableId, chatSystem);
+    IWorld(worldAddress).grantAccess(MessageTable._tableId, address(chatNamespacedSystem));
 
     // ------------------ EXAMPLES ------------------
 

examples/minimal/packages/contracts/src/interfaces/IChatNamespacedSystem.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+interface IChatNamespacedSystem {
+  function namespace__sendMessage(string memory message) external;
+}

examples/minimal/packages/contracts/src/systems/namespace__ChatSystem.sol → examples/minimal/packages/contracts/src/systems/ChatNamespacedSystem.sol

@@ -3,8 +3,8 @@ pragma solidity >=0.8.24;
 import { System } from "@latticexyz/world/src/System.sol";
 import { MessageTable } from "../codegen/index.sol";
 
-// This system has a different namespace, but is otherwise identical to ChatSystem
-contract namespace__ChatSystem is System {
+// This system is supposed to have a different namespace, but otherwise be identical to ChatSystem
+contract ChatNamespacedSystem is System {
   function sendMessage(string memory message) public {
     MessageTable.set(message);
   }

examples/minimal/packages/contracts/test/ChatTest.t.sol → examples/minimal/packages/contracts/test/ChatNamespaced.t.sol

@@ -8,9 +8,9 @@ import { IStoreEvents } from "@latticexyz/store/src/IStoreEvents.sol";
 
 import { IWorld } from "../src/codegen/world/IWorld.sol";
 import { MessageTable } from "../src/codegen/index.sol";
-import { namespace__IChatSystem } from "../src/codegen/world/namespace__IChatSystem.sol";
+import { IChatNamespacedSystem } from "../src/interfaces/IChatNamespacedSystem.sol";
 
-contract ChatTest is MudTest {
+contract ChatNamespacedTest is MudTest {
   function testOffchain() public {
     bytes32[] memory keyTuple;
     string memory value = "test";
@@ -22,6 +22,6 @@ contract ChatTest is MudTest {
       MessageTable.encodeLengths(value),
       MessageTable.encodeDynamic(value)
     );
-    namespace__IChatSystem(worldAddress).namespace__sendMessage(value);
+    IChatNamespacedSystem(worldAddress).namespace__sendMessage(value);
   }
 }

examples/multiple-namespaces/src/systems/game__HealSystem.sol → examples/multiple-namespaces/src/systems/HealSystem.sol

@@ -3,7 +3,7 @@ pragma solidity >=0.8.24;
 import { System } from "@latticexyz/world/src/System.sol";
 import { Health } from "../codegen/game/tables/Health.sol";
 
-contract game__HealSystem is System {
+contract HealSystem is System {
   function heal(address player) public {
     Health.set(player, Health.get(player) + 1);
   }

examples/multiple-namespaces/src/systems/game__MoveSystem.sol → examples/multiple-namespaces/src/systems/MoveSystem.sol

@@ -3,7 +3,7 @@ pragma solidity >=0.8.24;
 import { System } from "@latticexyz/world/src/System.sol";
 import { Position } from "../codegen/game/tables/Position.sol";
 
-contract game__MoveSystem is System {
+contract MoveSystem is System {
   function move(address player, int32 x, int32 y) public {
     Position.set(player, x, y);
   }

packages/cli/src/deploy/resolveConfig.ts

@@ -44,7 +44,7 @@ export function resolveConfig<config extends ConfigInput>({
     .map(toFunctionSignature);
 
   const systems = Object.entries(resolvedConfig.systems).map(([systemName, system]): System => {
-    const namespace = system.namespace;
+    const namespace = config.namespace;
     const name = system.name;
     const systemId = resourceToHex({ type: "system", namespace, name });
     const contractData = getContractData(`${systemName}.sol`, systemName, forgeOutDir);

packages/common/src/common.ts

@@ -7,5 +7,3 @@ export type Resource = {
   readonly namespace: string;
   readonly name: string;
 };
-
-export const ROOT_NAMESPACE = "";

packages/common/src/resourceToLabel.ts

@@ -1,9 +1,9 @@
-import { ROOT_NAMESPACE } from "./common";
+const rootNamespace = "";
 
 export type ResourceLabel<
   namespace extends string = string,
   name extends string = string,
-> = namespace extends typeof ROOT_NAMESPACE ? name : `${namespace}__${name}`;
+> = namespace extends typeof rootNamespace ? name : `${namespace}__${name}`;
 
 export function resourceToLabel<namespace extends string, name extends string>({
   namespace,
@@ -12,5 +12,5 @@ export function resourceToLabel<namespace extends string, name extends string>({
   readonly namespace: namespace;
   readonly name: name;
 }): ResourceLabel<namespace, name> {
-  return (namespace === ROOT_NAMESPACE ? name : `${namespace}__${name}`) as ResourceLabel<namespace, name>;
+  return (namespace === rootNamespace ? name : `${namespace}__${name}`) as ResourceLabel<namespace, name>;
 }

packages/world/ts/config/resolveWorldConfig.ts

@@ -12,13 +12,12 @@ export type ResolvedWorldConfig = ReturnType<typeof resolveWorldConfig>;
  * splitting the access list into addresses and system names.
  */
 export function resolveWorldConfig(
-  config: Pick<StoreConfig & WorldConfig, "namespace" | "systems" | "excludeSystems">,
+  config: Pick<StoreConfig & WorldConfig, "systems" | "excludeSystems">,
   existingContracts?: string[],
 ) {
   // Include contract names ending in "System", but not the base "System" contract, and not Interfaces
   const defaultSystemNames =
-    existingContracts?.filter((name) => name.endsWith("System") && name !== "System" && !/(^|__)I[A-Z]/.test(name)) ??
-    [];
+    existingContracts?.filter((name) => name.endsWith("System") && name !== "System" && !name.match(/^I[A-Z]/)) ?? [];
   const overriddenSystemNames = Object.keys(config.systems);
 
   // Validate every key in systems refers to an existing system contract (and is not called "World")
@@ -39,12 +38,7 @@ export function resolveWorldConfig(
   const resolvedSystems: Record<string, ResolvedSystemConfig> = systemNames.reduce((acc, systemName) => {
     return {
       ...acc,
-      [systemName]: resolveSystemConfig({
-        systemName,
-        configNamespace: config.namespace,
-        config: config.systems[systemName],
-        existingContracts,
-      }),
+      [systemName]: resolveSystemConfig(systemName, config.systems[systemName], existingContracts),
     };
   }, {});
 
@@ -63,23 +57,8 @@ export function resolveWorldConfig(
  * Default value for accessListAddresses is []
  * Default value for accessListSystems is []
  */
-export function resolveSystemConfig({
-  systemName,
-  configNamespace,
-  config,
-  existingContracts,
-}: {
-  systemName: string;
-  configNamespace: string;
-  config?: SystemConfig;
-  existingContracts?: string[];
-}) {
-  // If the namespace is not set in the system name, default to the config namespace
-  const parts = systemName.split("__");
-  const namespaceIsSet = parts.length === 2;
-  const namespace = namespaceIsSet ? parts[0] : configNamespace;
-  const name = namespaceIsSet ? parts[1] : systemName;
-
+export function resolveSystemConfig(systemName: string, config?: SystemConfig, existingContracts?: string[]) {
+  const name = config?.name ?? systemName;
   const registerFunctionSelectors = config?.registerFunctionSelectors ?? true;
   const openAccess = config?.openAccess ?? true;
   const accessListAddresses: string[] = [];
@@ -99,5 +78,5 @@ export function resolveSystemConfig({
     }
   }
 
-  return { name, namespace, registerFunctionSelectors, openAccess, accessListAddresses, accessListSystems };
+  return { name, registerFunctionSelectors, openAccess, accessListAddresses, accessListSystems };
 }

packages/world/ts/node/render-solidity/worldgen.ts

@@ -6,7 +6,6 @@ import { renderWorldInterface } from "./renderWorldInterface";
 import { resolveWorldConfig } from "../../config/resolveWorldConfig";
 import { World as WorldConfig } from "../../config/v2/output";
 import { worldToV1 } from "../../config/v2/compat";
-import { ROOT_NAMESPACE } from "@latticexyz/common";
 
 export async function worldgen(
   configV2: WorldConfig,
@@ -43,13 +42,10 @@ export async function worldgen(
         };
       }
     });
-
-    const { namespace, name } = resolvedConfig.systems[system.basename];
-
-    const systemInterfaceName = namespace === ROOT_NAMESPACE ? `I${name}` : `${namespace}__I${name}`;
+    const systemInterfaceName = `I${system.basename}`;
     const output = renderSystemInterface({
       name: systemInterfaceName,
-      functionPrefix: namespace === ROOT_NAMESPACE ? "" : `${namespace}__`,
+      functionPrefix: config.namespace === "" ? "" : `${config.namespace}__`,
       functions,
       errors,
       imports,