@latticexyz/common 2.2.22-490159e880e2ac0e1ce8f5785873a25b99fb7668 → 2.2.22-4f57d5de39a17a180cd14e768cd2a56cfc8fd85f

package/dist/chains.d.ts

@@ -1,7 +1,6 @@
 import * as viem_chains from 'viem/chains';
 import { Chain } from 'viem/chains';
 import * as viem from 'viem';
-import * as viem_experimental from 'viem/experimental';
 import * as viem_op_stack from 'viem/op-stack';
 
 type MUDChain = Chain & {
@@ -36,6 +35,7 @@ declare const mudFoundry: {
         multicall3?: viem.ChainContract | undefined;
         universalSignatureVerifier?: viem.ChainContract | undefined;
     } | undefined;
+    readonly ensTlds?: readonly string[] | undefined;
     readonly id: 31337;
     readonly name: "Foundry";
     readonly nativeCurrency: {
@@ -106,6 +106,7 @@ declare const redstone: {
             readonly address: "0x4200000000000000000000000000000000000016";
         };
     };
+    readonly ensTlds?: readonly string[] | undefined;
     readonly id: 690;
     readonly name: "Redstone";
     readonly nativeCurrency: {
@@ -312,7 +313,7 @@ declare const redstone: {
                 value: bigint;
                 yParity: number;
                 accessList: viem.AccessList;
-                authorizationList: viem_experimental.SignedAuthorizationList<number>;
+                authorizationList: viem.SignedAuthorizationList<number>;
                 blobVersionedHashes?: undefined;
                 chainId: number;
                 type: "eip7702";
@@ -419,6 +420,7 @@ declare const garnet: {
             readonly address: "0x4200000000000000000000000000000000000016";
         };
     };
+    readonly ensTlds?: readonly string[] | undefined;
     readonly id: 17069;
     readonly name: "Garnet Testnet";
     readonly nativeCurrency: {
@@ -619,7 +621,7 @@ declare const garnet: {
                 value: bigint;
                 yParity: number;
                 accessList: viem.AccessList;
-                authorizationList: viem_experimental.SignedAuthorizationList<number>;
+                authorizationList: viem.SignedAuthorizationList<number>;
                 blobVersionedHashes?: undefined;
                 chainId: number;
                 type: "eip7702";
@@ -923,7 +925,7 @@ declare const rhodolite: {
                 value: bigint;
                 yParity: number;
                 accessList: viem.AccessList;
-                authorizationList: viem_experimental.SignedAuthorizationList<number>;
+                authorizationList: viem.SignedAuthorizationList<number>;
                 blobVersionedHashes?: undefined;
                 chainId: number;
                 type: "eip7702";
@@ -1216,7 +1218,7 @@ declare const pyrope: {
                 value: bigint;
                 yParity: number;
                 accessList: viem.AccessList;
-                authorizationList: viem_experimental.SignedAuthorizationList<number>;
+                authorizationList: viem.SignedAuthorizationList<number>;
                 blobVersionedHashes?: undefined;
                 chainId: number;
                 type: "eip7702";

package/dist/{chunk-NFWCLD5I.js → chunk-ETXWXV5T.js}

@@ -82,6 +82,18 @@ function unique(values) {
   return Array.from(new Set(values));
 }
 
+// src/utils/uniqueBy.ts
+function uniqueBy(values, getKey) {
+  const map = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const key = getKey(value);
+    if (!map.has(key)) {
+      map.set(key, value);
+    }
+  }
+  return Array.from(map.values());
+}
+
 // src/utils/wait.ts
 function wait(ms) {
   return new Promise((resolve) => setTimeout(() => resolve(), ms));
@@ -113,7 +125,8 @@ export {
   iteratorToArray,
   mapObject,
   unique,
+  uniqueBy,
   wait,
   waitForIdle
 };
-//# sourceMappingURL=chunk-NFWCLD5I.js.map
+//# sourceMappingURL=chunk-ETXWXV5T.js.map

package/dist/chunk-ETXWXV5T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/assertExhaustive.ts","../src/utils/bigIntMax.ts","../src/utils/bigIntMin.ts","../src/utils/bigIntSort.ts","../src/utils/chunk.ts","../src/utils/groupBy.ts","../src/utils/identity.ts","../src/utils/includes.ts","../src/utils/indent.ts","../src/utils/isDefined.ts","../src/utils/isNotNull.ts","../src/utils/iteratorToArray.ts","../src/utils/mapObject.ts","../src/utils/unique.ts","../src/utils/uniqueBy.ts","../src/utils/wait.ts","../src/utils/waitForIdle.ts"],"sourcesContent":["export function assertExhaustive(value: never, message?: string): never {\n  throw new Error(message ?? `Unexpected value: ${value}`);\n}\n","export function bigIntMax(...args: bigint[]): bigint {\n  return args.reduce((m, e) => (e > m ? e : m));\n}\n","export function bigIntMin(...args: bigint[]): bigint {\n  return args.reduce((m, e) => (e < m ? e : m));\n}\n","export function bigIntSort(a: bigint, b: bigint): -1 | 0 | 1 {\n  return a < b ? -1 : a > b ? 1 : 0;\n}\n","export function* chunk<T>(arr: readonly T[], n: number): Generator<readonly T[], void> {\n  for (let i = 0; i < arr.length; i += n) {\n    yield arr.slice(i, i + n);\n  }\n}\n","export function groupBy<value, key>(\n  values: readonly value[],\n  getKey: (value: value) => key,\n): Map<key, readonly value[]> {\n  const map = new Map<key, readonly value[]>();\n  for (const value of values) {\n    const key = getKey(value);\n    if (!map.has(key)) map.set(key, []);\n    (map.get(key) as value[]).push(value);\n  }\n  return map;\n}\n","export function identity<T>(value: T): T {\n  return value;\n}\n","// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function includes<item>(items: item[], value: any): value is item {\n  return items.includes(value);\n}\n","export function indent(message: string, indentation = \"  \"): string {\n  return message.replaceAll(/(^|\\n)/g, `$1${indentation}`);\n}\n","export function isDefined<T>(argument: T | undefined): argument is T {\n  return argument !== undefined;\n}\n","export function isNotNull<T>(argument: T | null): argument is T {\n  return argument !== null;\n}\n","export async function iteratorToArray<T>(iterator: AsyncIterable<T>): Promise<readonly T[]> {\n  const items: T[] = [];\n  for await (const item of iterator) {\n    items.push(item);\n  }\n  return items;\n}\n","/**\n * Map each key of a source object via a given valueMap function\n */\nexport function mapObject<\n  Source extends Record<string | number | symbol, unknown>,\n  Target extends { [key in keyof Source]: unknown },\n>(source: Source, valueMap: (value: Source[typeof key], key: keyof Source) => Target[typeof key]): Target {\n  return Object.fromEntries(\n    Object.entries(source).map(([key, value]) => [key, valueMap(value as Source[keyof Source], key)]),\n  ) as Target;\n}\n","export function unique<value>(values: readonly value[]): readonly value[] {\n  return Array.from(new Set(values));\n}\n","export function uniqueBy<value, key>(values: readonly value[], getKey: (value: value) => key): readonly value[] {\n  const map = new Map<key, value>();\n  for (const value of values) {\n    const key = getKey(value);\n    if (!map.has(key)) {\n      map.set(key, value);\n    }\n  }\n  return Array.from(map.values());\n}\n","export function wait(ms: number): Promise<void> {\n  return new Promise<void>((resolve) => setTimeout(() => resolve(), ms));\n}\n","export function waitForIdle(): Promise<void> {\n  return new Promise<void>((resolve) => {\n    if (typeof requestIdleCallback !== \"undefined\") {\n      requestIdleCallback(() => resolve());\n    } else {\n      setTimeout(() => resolve(), 1);\n    }\n  });\n}\n"],"mappings":";AAAO,SAAS,iBAAiB,OAAc,SAAyB;AACtE,QAAM,IAAI,MAAM,WAAW,qBAAqB,KAAK,EAAE;AACzD;;;ACFO,SAAS,aAAa,MAAwB;AACnD,SAAO,KAAK,OAAO,CAAC,GAAG,MAAO,IAAI,IAAI,IAAI,CAAE;AAC9C;;;ACFO,SAAS,aAAa,MAAwB;AACnD,SAAO,KAAK,OAAO,CAAC,GAAG,MAAO,IAAI,IAAI,IAAI,CAAE;AAC9C;;;ACFO,SAAS,WAAW,GAAW,GAAuB;AAC3D,SAAO,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI;AAClC;;;ACFO,UAAU,MAAS,KAAmB,GAA0C;AACrF,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,GAAG;AACtC,UAAM,IAAI,MAAM,GAAG,IAAI,CAAC;AAAA,EAC1B;AACF;;;ACJO,SAAS,QACd,QACA,QAC4B;AAC5B,QAAM,MAAM,oBAAI,IAA2B;AAC3C,aAAW,SAAS,QAAQ;AAC1B,UAAM,MAAM,OAAO,KAAK;AACxB,QAAI,CAAC,IAAI,IAAI,GAAG,EAAG,KAAI,IAAI,KAAK,CAAC,CAAC;AAClC,IAAC,IAAI,IAAI,GAAG,EAAc,KAAK,KAAK;AAAA,EACtC;AACA,SAAO;AACT;;;ACXO,SAAS,SAAY,OAAa;AACvC,SAAO;AACT;;;ACDO,SAAS,SAAe,OAAe,OAA2B;AACvE,SAAO,MAAM,SAAS,KAAK;AAC7B;;;ACHO,SAAS,OAAO,SAAiB,cAAc,MAAc;AAClE,SAAO,QAAQ,WAAW,WAAW,KAAK,WAAW,EAAE;AACzD;;;ACFO,SAAS,UAAa,UAAwC;AACnE,SAAO,aAAa;AACtB;;;ACFO,SAAS,UAAa,UAAmC;AAC9D,SAAO,aAAa;AACtB;;;ACFA,eAAsB,gBAAmB,UAAmD;AAC1F,QAAM,QAAa,CAAC;AACpB,mBAAiB,QAAQ,UAAU;AACjC,UAAM,KAAK,IAAI;AAAA,EACjB;AACA,SAAO;AACT;;;ACHO,SAAS,UAGd,QAAgB,UAAwF;AACxG,SAAO,OAAO;AAAA,IACZ,OAAO,QAAQ,MAAM,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,SAAS,OAA+B,GAAG,CAAC,CAAC;AAAA,EAClG;AACF;;;ACVO,SAAS,OAAc,QAA4C;AACxE,SAAO,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC;AACnC;;;ACFO,SAAS,SAAqB,QAA0B,QAAiD;AAC9G,QAAM,MAAM,oBAAI,IAAgB;AAChC,aAAW,SAAS,QAAQ;AAC1B,UAAM,MAAM,OAAO,KAAK;AACxB,QAAI,CAAC,IAAI,IAAI,GAAG,GAAG;AACjB,UAAI,IAAI,KAAK,KAAK;AAAA,IACpB;AAAA,EACF;AACA,SAAO,MAAM,KAAK,IAAI,OAAO,CAAC;AAChC;;;ACTO,SAAS,KAAK,IAA2B;AAC9C,SAAO,IAAI,QAAc,CAAC,YAAY,WAAW,MAAM,QAAQ,GAAG,EAAE,CAAC;AACvE;;;ACFO,SAAS,cAA6B;AAC3C,SAAO,IAAI,QAAc,CAAC,YAAY;AACpC,QAAI,OAAO,wBAAwB,aAAa;AAC9C,0BAAoB,MAAM,QAAQ,CAAC;AAAA,IACrC,OAAO;AACL,iBAAW,MAAM,QAAQ,GAAG,CAAC;AAAA,IAC/B;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/codegen.d.ts

@@ -1,7 +1,6 @@
 import { Hex } from 'viem';
 import { Abi } from 'abitype';
 import { SchemaType } from '@latticexyz/schema-type/deprecated';
-import { SourceUnit, ContractDefinition } from '@solidity-parser/parser/dist/src/ast-types';
 
 declare module "prettier-plugin-solidity" {}
 
@@ -168,6 +167,11 @@ declare function renderTypeHelpers(options: {
 
 declare const schemaTypesToRecsTypeStrings: Record<SchemaType, string>;
 
+interface SymbolImport {
+    symbol: string;
+    path: string;
+}
+
 interface ContractInterfaceFunction {
     name: string;
     parameters: string[];
@@ -178,10 +182,6 @@ interface ContractInterfaceError {
     name: string;
     parameters: string[];
 }
-interface SymbolImport {
-    symbol: string;
-    path: string;
-}
 /**
  * Parse the contract data to get the functions necessary to generate an interface,
  * and symbols to import from the original contract.
@@ -194,7 +194,6 @@ declare function contractToInterface(source: string, contractName: string): {
     errors: ContractInterfaceError[];
     symbolImports: SymbolImport[];
 };
-declare function findContractNode(ast: SourceUnit, contractName: string): ContractDefinition | undefined;
 
 /**
  * Formats solidity code using prettier
@@ -212,11 +211,11 @@ declare function formatTypescript(content: string): Promise<string>;
 
 /**
  * Formats solidity code using prettier and write it to a file
- * @param output solidity code
+ * @param content solidity code
  * @param fullOutputPath full path to the output file
  * @param logPrefix prefix for debug logs
  */
-declare function formatAndWriteSolidity(output: string, fullOutputPath: string, logPrefix: string): Promise<void>;
+declare function formatAndWriteSolidity(content: string, fullOutputPath: string, logPrefix: string): Promise<void>;
 /**
  * Formats typescript code using prettier and write it to a file
  * @param output typescript code
@@ -225,4 +224,8 @@ declare function formatAndWriteSolidity(output: string, fullOutputPath: string,
  */
 declare function formatAndWriteTypescript(output: string, fullOutputPath: string, logPrefix: string): Promise<void>;
 
-export { type AbiToInterfaceOptions, type ContractInterfaceError, type ContractInterfaceFunction, type ImportDatum, type RenderDynamicField, type RenderEnum, type RenderField, type RenderFieldTypeWrappingData, type RenderKeyTuple, type RenderStaticField, type RenderType, type StaticResourceData, abiToInterface, contractToInterface, findContractNode, formatAndWriteSolidity, formatAndWriteTypescript, formatSolidity, formatTypescript, getLeftPaddingBits, isLeftAligned, renderArguments, renderCommonData, renderEnums, renderImportPath, renderImports, renderList, renderTableId, renderTypeHelpers, renderValueTypeToBytes32, renderWithFieldSuffix, renderWithStore, renderedSolidityHeader, schemaTypesToRecsTypeStrings };
+declare function parseSystem(source: string, contractName: string): undefined | {
+    contractType: "contract" | "abstract";
+};
+
+export { type AbiToInterfaceOptions, type ContractInterfaceError, type ContractInterfaceFunction, type ImportDatum, type RenderDynamicField, type RenderEnum, type RenderField, type RenderFieldTypeWrappingData, type RenderKeyTuple, type RenderStaticField, type RenderType, type StaticResourceData, abiToInterface, contractToInterface, formatAndWriteSolidity, formatAndWriteTypescript, formatSolidity, formatTypescript, getLeftPaddingBits, isLeftAligned, parseSystem, renderArguments, renderCommonData, renderEnums, renderImportPath, renderImports, renderList, renderTableId, renderTypeHelpers, renderValueTypeToBytes32, renderWithFieldSuffix, renderWithStore, renderedSolidityHeader, schemaTypesToRecsTypeStrings };

package/dist/codegen.js

@@ -10,8 +10,7 @@ import {
 } from "./chunk-GRGLAPN2.js";
 import {
   isDefined
-} from "./chunk-NFWCLD5I.js";
-import "./chunk-CHXZROA7.js";
+} from "./chunk-ETXWXV5T.js";
 
 // src/codegen/render-solidity/abiToInterface.ts
 import { formatAbiItem, formatAbiParameter } from "abitype";
@@ -520,7 +519,47 @@ var schemaTypesToRecsTypeStrings = {
 };
 
 // src/codegen/utils/contractToInterface.ts
-import { parse, visit } from "@solidity-parser/parser";
+import { parse, visit as visit3 } from "@solidity-parser/parser";
+
+// src/codegen/utils/findContractNode.ts
+import { visit } from "@solidity-parser/parser";
+function findContractNode(ast, contractName) {
+  let contract = void 0;
+  visit(ast, {
+    ContractDefinition(node) {
+      if (node.name === contractName) {
+        contract = node;
+      }
+    }
+  });
+  return contract;
+}
+
+// src/codegen/utils/findSymbolImport.ts
+import { visit as visit2 } from "@solidity-parser/parser";
+function findSymbolImport(ast, symbol) {
+  let symbolImport;
+  visit2(ast, {
+    ImportDirective({ path: path3, symbolAliases }) {
+      if (symbolAliases) {
+        for (const symbolAndAlias of symbolAliases) {
+          const symbolAlias = symbolAndAlias[1] ?? symbolAndAlias[0];
+          if (symbol === symbolAlias) {
+            symbolImport = {
+              // always use the original symbol for interface imports
+              symbol: symbolAndAlias[0],
+              path: path3
+            };
+            return;
+          }
+        }
+      }
+    }
+  });
+  return symbolImport;
+}
+
+// src/codegen/utils/contractToInterface.ts
 function contractToInterface(source, contractName) {
   const ast = parse(source);
   const contractNode = findContractNode(ast, contractName);
@@ -530,7 +569,7 @@ function contractToInterface(source, contractName) {
   if (!contractNode) {
     throw new MUDError(`Contract not found: ${contractName}`);
   }
-  visit(contractNode, {
+  visit3(contractNode, {
     FunctionDefinition({
       name,
       visibility,
@@ -580,17 +619,6 @@ function contractToInterface(source, contractName) {
     symbolImports
   };
 }
-function findContractNode(ast, contractName) {
-  let contract = void 0;
-  visit(ast, {
-    ContractDefinition(node) {
-      if (node.name === contractName) {
-        contract = node;
-      }
-    }
-  });
-  return contract;
-}
 function parseParameter({ name, typeName, storageLocation }) {
   let typedNameWithLocation = "";
   const { name: flattenedTypeName, stateMutability } = flattenTypeName(typeName);
@@ -655,33 +683,11 @@ function typeNameToSymbols(typeName) {
   }
 }
 function symbolsToImports(ast, symbols) {
-  const imports = [];
-  for (const symbol of symbols) {
-    let symbolImport;
-    visit(ast, {
-      ImportDirective({ path: path3, symbolAliases }) {
-        if (symbolAliases) {
-          for (const symbolAndAlias of symbolAliases) {
-            const symbolAlias = symbolAndAlias[1] || symbolAndAlias[0];
-            if (symbol === symbolAlias) {
-              symbolImport = {
-                // always use the original symbol for interface imports
-                symbol: symbolAndAlias[0],
-                path: path3
-              };
-              return;
-            }
-          }
-        }
-      }
-    });
-    if (symbolImport) {
-      imports.push(symbolImport);
-    } else {
-      throw new MUDError(`Symbol "${symbol}" has no explicit import`);
-    }
-  }
-  return imports;
+  return symbols.map((symbol) => {
+    const symbolImport = findSymbolImport(ast, symbol);
+    if (!symbolImport) throw new MUDError(`Symbol "${symbol}" has no explicit import`);
+    return symbolImport;
+  });
 }
 
 // src/codegen/utils/format.ts
@@ -731,10 +737,15 @@ debug2.log = console.debug.bind(console);
 error.log = console.error.bind(console);
 
 // src/codegen/utils/formatAndWrite.ts
-async function formatAndWriteSolidity(output, fullOutputPath, logPrefix) {
-  const formattedOutput = await formatSolidity(output);
+async function formatAndWriteSolidity(content, fullOutputPath, logPrefix) {
+  let output = content;
+  try {
+    output = await formatSolidity(output);
+  } catch (e) {
+    error(`Error while attempting to format ${fullOutputPath}`, e);
+  }
   await fs.mkdir(path2.dirname(fullOutputPath), { recursive: true });
-  await fs.writeFile(fullOutputPath, formattedOutput);
+  await fs.writeFile(fullOutputPath, output);
   debug2(`${logPrefix}: ${fullOutputPath}`);
 }
 async function formatAndWriteTypescript(output, fullOutputPath, logPrefix) {
@@ -743,16 +754,43 @@ async function formatAndWriteTypescript(output, fullOutputPath, logPrefix) {
   await fs.writeFile(fullOutputPath, formattedOutput);
   debug2(`${logPrefix}: ${fullOutputPath}`);
 }
+
+// src/codegen/utils/parseSystem.ts
+import { parse as parse2, visit as visit4 } from "@solidity-parser/parser";
+var baseSystemName = "System";
+var baseSystemPath = "@latticexyz/world/src/System.sol";
+function parseSystem(source, contractName) {
+  const ast = parse2(source);
+  const contractNode = findContractNode(ast, contractName);
+  if (!contractNode) return;
+  const contractType = contractNode.kind;
+  if (contractType !== "contract" && contractType !== "abstract") return;
+  const isSystem = (() => {
+    if (contractName.endsWith("System") && contractName !== baseSystemName) return true;
+    let extendsBaseSystem = false;
+    visit4(contractNode, {
+      InheritanceSpecifier(node) {
+        if (node.baseName.namePath === baseSystemName) {
+          extendsBaseSystem = true;
+        }
+      }
+    });
+    return extendsBaseSystem && findSymbolImport(ast, baseSystemName)?.path === baseSystemPath;
+  })();
+  if (isSystem) {
+    return { contractType };
+  }
+}
 export {
   abiToInterface,
   contractToInterface,
-  findContractNode,
   formatAndWriteSolidity,
   formatAndWriteTypescript,
   formatSolidity,
   formatTypescript,
   getLeftPaddingBits,
   isLeftAligned,
+  parseSystem,
   renderArguments,
   renderCommonData,
   renderEnums,