fix(worldgen): correctly resolve remappings when going through the inheritance chain (#3791)

Author: vdrg

.changeset/hip-garlics-ring.md

@@ -0,0 +1,6 @@
+---
+"@latticexyz/common": patch
+"@latticexyz/world": patch
+---
+
+Correctly resolve remappings when going through the inheritance chain during worldgen.

packages/common/src/codegen/utils/index.ts

@@ -4,3 +4,4 @@ export * from "./formatAndWrite";
 export * from "./parseSystem";
 export * from "./resolveInheritedSymbols";
 export * from "./applyTypeQualifiers";
+export * from "./resolveRemapping";

packages/common/src/codegen/utils/resolveInheritedSymbols.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { findContractNode } from "./findContractNode";
 import { QualifiedSymbol } from "./contractToInterface";
 import { findSymbolImport } from "./findSymbolImport";
+import { resolveRemapping } from "./resolveRemapping";
 
 interface InheritanceInfo {
   baseContracts: string[];
@@ -22,17 +23,20 @@ interface InheritanceInfo {
 export async function createInheritanceResolver(
   contractPath: string,
   contractName: string,
+  rootDir: string,
+  remappings: string[] = [],
 ): Promise<(symbol: string) => QualifiedSymbol | undefined> {
   const resolvedContracts = new Map<string, InheritanceInfo>();
   const visitedPaths = new Set<string>();
 
   async function parseContract(filePath: string, targetContractName?: string): Promise<InheritanceInfo | undefined> {
     // Prevent infinite recursion
     const normalizedPath = path.resolve(filePath);
-    if (visitedPaths.has(normalizedPath)) {
+    const visitKey = targetContractName ? `${normalizedPath}:${targetContractName}` : normalizedPath;
+    if (visitedPaths.has(visitKey)) {
       return undefined;
     }
-    visitedPaths.add(normalizedPath);
+    visitedPaths.add(visitKey);
 
     try {
       const source = await readFile(filePath, "utf8");
@@ -80,7 +84,7 @@ export async function createInheritanceResolver(
           }
         }
 
-        // Extract symbols defined in this contract
+        // Extract symbols defined in this contract/interface
         visit(contractNode, {
           StructDefinition(node) {
             if (node.name) {
@@ -109,11 +113,11 @@ export async function createInheritanceResolver(
             // Store the original import path
             info.baseContractImports.set(baseName, importInfo.path);
 
-            const importPath = importInfo.path.startsWith(".")
+            const resolvedPath = importInfo.path.startsWith(".")
               ? path.resolve(path.dirname(filePath), importInfo.path)
-              : importInfo.path;
+              : resolveRemapping(importInfo.path, remappings, rootDir);
 
-            await parseContract(importPath, baseName);
+            await parseContract(resolvedPath, baseName);
           }
         }
       }
@@ -157,8 +161,24 @@ export async function createInheritanceResolver(
         const baseInfo = resolvedContracts.get(baseName);
         if (baseInfo?.symbols.has(symbol)) {
           // Found the symbol in a base contract
-          // Get the import path from the main contract to this base contract
-          const importPath = mainInfo?.baseContractImports.get(baseName) || `./${baseName}.sol`;
+          // Find the import path for this base contract
+          let importPath: string | undefined;
+
+          for (const [, info] of resolvedContracts) {
+            const baseImportPath = info.baseContractImports.get(baseName);
+            if (baseImportPath) {
+              importPath = baseImportPath;
+              break;
+            }
+          }
+
+          // If we still don't have an import path, throw an error
+          if (!importPath) {
+            throw new Error(
+              `Could not find import path for base contract "${baseName}" which defines "${symbol}". ` +
+                `Make sure "${baseName}" is properly imported in your contract or its dependencies.`,
+            );
+          }
 
           return {
             symbol,

packages/common/src/codegen/utils/resolveRemapping.ts

@@ -0,0 +1,32 @@
+import path from "path";
+
+/**
+ * Resolves an import path using forge remappings
+ * @param importPath The import path to resolve (e.g., "@latticexyz/store/src/Store.sol")
+ * @param remappings Array of forge remapping strings (e.g., ["@latticexyz/=node_modules/@latticexyz/"])
+ * @param rootDir The root directory to resolve relative to
+ * @returns The resolved file path, or the original path if no remapping applies
+ */
+export function resolveRemapping(importPath: string, remappings: string[], rootDir: string): string {
+  // Parse remappings into { from, to } objects
+  const parsedRemappings = remappings.map((remapping) => {
+    const [from, to] = remapping.split("=");
+    return { from, to };
+  });
+
+  // Sort by length descending to match longest prefix first
+  parsedRemappings.sort((a, b) => b.from.length - a.from.length);
+
+  // Find the first matching remapping
+  for (const { from, to } of parsedRemappings) {
+    if (importPath.startsWith(from)) {
+      // Replace the prefix with the mapped path
+      const resolvedPath = importPath.replace(from, to);
+      // Resolve to absolute path
+      return path.resolve(rootDir, resolvedPath);
+    }
+  }
+
+  // No remapping found, return original path
+  return importPath;
+}

packages/common/src/foundry/index.ts

@@ -76,3 +76,12 @@ export async function getRpcUrl(profile?: string): Promise<string> {
     "http://127.0.0.1:8545"
   );
 }
+
+/**
+ * Get the remappings from forge config.
+ * @param profile The foundry profile to use
+ * @returns Array of remapping strings (e.g., ["@latticexyz/=node_modules/@latticexyz/"])
+ */
+export async function getRemappings(profile?: string): Promise<string[]> {
+  return (await getForgeConfig(profile)).remappings;
+}

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

@@ -7,6 +7,7 @@ import {
   applyTypeQualifiers,
   type ImportDatum,
 } from "@latticexyz/common/codegen";
+import { getRemappings } from "@latticexyz/common/foundry";
 import { renderSystemInterface } from "./renderSystemInterface";
 import { renderWorldInterface } from "./renderWorldInterface";
 import { renderSystemLibrary } from "./renderSystemLibrary";
@@ -23,6 +24,8 @@ export async function worldgen({
   config: WorldConfig;
   clean?: boolean;
 }) {
+  // Get forge remappings for resolving npm packages
+  const remappings = await getRemappings();
   const worldgenOutDir = path.join(
     rootDir,
     config.sourceDirectory,
@@ -88,7 +91,12 @@ export async function worldgen({
       const source = await fs.readFile(path.join(rootDir, system.sourcePath), "utf8");
 
       // Create inheritance resolver for this system
-      const findInheritedSymbol = await createInheritanceResolver(path.join(rootDir, system.sourcePath), system.label);
+      const findInheritedSymbol = await createInheritanceResolver(
+        path.join(rootDir, system.sourcePath),
+        system.label,
+        rootDir,
+        remappings,
+      );
 
       // get external functions from a contract
       let functions, errors, symbolImports, qualifiedSymbols;