@latticexyz/common 2.2.21-f4db683f90214b03bb8d68635a3825cc9bf58263 → 2.2.22-01a4d064e5fd8e579d54bb3aa8997f225c6960d3

package/dist/chains.d.ts

@@ -970,4 +970,297 @@ declare const rhodolite: {
     };
 };
 
-export { type MUDChain, garnet, mudFoundry, redstone, rhodolite };
+declare const pyrope: {
+    readonly name: "Pyrope Testnet";
+    readonly testnet: true;
+    readonly id: 695569;
+    readonly sourceId: 11155111;
+    readonly nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    readonly rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.pyropechain.com"];
+            readonly webSocket: readonly ["wss://rpc.pyropechain.com"];
+        };
+        readonly bundler: {
+            readonly http: readonly ["https://rpc.pyropechain.com"];
+            readonly webSocket: readonly ["wss://rpc.pyropechain.com"];
+        };
+    };
+    readonly contracts: {
+        readonly l1StandardBridge: {
+            readonly 11155111: {
+                readonly address: "0xC24932c31D9621aE9e792576152B7ef010cFC2F8";
+            };
+        };
+        readonly gasPriceOracle: {
+            readonly address: "0x420000000000000000000000000000000000000F";
+        };
+        readonly l1Block: {
+            readonly address: "0x4200000000000000000000000000000000000015";
+        };
+        readonly l2CrossDomainMessenger: {
+            readonly address: "0x4200000000000000000000000000000000000007";
+        };
+        readonly l2Erc721Bridge: {
+            readonly address: "0x4200000000000000000000000000000000000014";
+        };
+        readonly l2StandardBridge: {
+            readonly address: "0x4200000000000000000000000000000000000010";
+        };
+        readonly l2ToL1MessagePasser: {
+            readonly address: "0x4200000000000000000000000000000000000016";
+        };
+    };
+    readonly blockExplorers: {
+        readonly default: {
+            readonly name: "Blockscout";
+            readonly url: "https://explorer.pyropechain.com";
+        };
+        readonly worldsExplorer: {
+            readonly name: "MUD Worlds Explorer";
+            readonly url: "https://explorer.mud.dev/pyrope/worlds";
+        };
+    };
+    readonly iconUrls: readonly ["https://lattice.xyz/brand/color/pyrope.svg"];
+    readonly indexerUrl: "https://indexer.mud.pyropechain.com";
+    readonly formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: viem_op_stack.OpStackRpcBlock<viem.BlockTag, boolean>) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: `0x${string}`;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: `0x${string}`;
+                mixHash: `0x${string}`;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentBeaconBlockRoot?: `0x${string}` | undefined;
+                parentHash: `0x${string}`;
+                receiptsRoot: `0x${string}`;
+                sealFields: `0x${string}`[];
+                sha3Uncles: `0x${string}`;
+                size: bigint;
+                stateRoot: `0x${string}`;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | viem_op_stack.OpStackTransaction<boolean>[];
+                transactionsRoot: `0x${string}`;
+                uncles: `0x${string}`[];
+                withdrawals?: viem.Withdrawal[] | undefined;
+                withdrawalsRoot?: `0x${string}` | undefined;
+            };
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: viem_op_stack.OpStackRpcTransaction<boolean>) => {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: `0x${string}`;
+                gas: bigint;
+                hash: `0x${string}`;
+                input: `0x${string}`;
+                nonce: number;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                transactionIndex: number | null;
+                typeHex: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean | undefined;
+                mint?: bigint | undefined;
+                sourceHash: `0x${string}`;
+                type: "deposit";
+            } | {
+                r: `0x${string}`;
+                s: `0x${string}`;
+                v: bigint;
+                to: `0x${string}` | null;
+                from: `0x${string}`;
+                gas: bigint;
+                nonce: number;
+                value: bigint;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                hash: `0x${string}`;
+                input: `0x${string}`;
+                transactionIndex: number | null;
+                typeHex: `0x${string}` | null;
+                accessList?: undefined;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId?: number | undefined;
+                yParity?: undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: `0x${string}`;
+                gas: bigint;
+                hash: `0x${string}`;
+                input: `0x${string}`;
+                nonce: number;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                transactionIndex: number | null;
+                typeHex: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: `0x${string}`;
+                gas: bigint;
+                hash: `0x${string}`;
+                input: `0x${string}`;
+                nonce: number;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                transactionIndex: number | null;
+                typeHex: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: `0x${string}`;
+                gas: bigint;
+                hash: `0x${string}`;
+                input: `0x${string}`;
+                nonce: number;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                transactionIndex: number | null;
+                typeHex: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined;
+                blobVersionedHashes: readonly `0x${string}`[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: `0x${string}`;
+                gas: bigint;
+                hash: `0x${string}`;
+                input: `0x${string}`;
+                nonce: number;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                transactionIndex: number | null;
+                typeHex: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList: viem_experimental.SignedAuthorizationList<number>;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            };
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: viem_op_stack.OpStackRpcTransactionReceipt) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: `0x${string}`;
+                blockNumber: bigint;
+                contractAddress: `0x${string}` | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: `0x${string}`;
+                gasUsed: bigint;
+                logs: viem.Log<bigint, number, false, undefined, undefined, undefined, undefined>[];
+                logsBloom: `0x${string}`;
+                root?: `0x${string}` | undefined;
+                status: "success" | "reverted";
+                to: `0x${string}` | null;
+                transactionHash: `0x${string}`;
+                transactionIndex: number;
+                type: viem.TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            };
+            type: "transactionReceipt";
+        };
+    };
+    readonly serializers: {
+        readonly transaction: typeof viem_op_stack.serializeTransaction;
+    };
+};
+
+export { type MUDChain, garnet, mudFoundry, pyrope, redstone, rhodolite };

package/dist/chains.js

@@ -71,9 +71,50 @@ var rhodolite = {
   iconUrls: ["https://redstone.xyz/chain-icons/rhodolite.png"],
   indexerUrl: "https://indexer.mud.rhodolitechain.com"
 };
+
+// src/chains/pyrope.ts
+import { chainConfig as chainConfig2 } from "viem/op-stack";
+var sourceId2 = 11155111;
+var defaultRpcUrls2 = {
+  http: ["https://rpc.pyropechain.com"],
+  webSocket: ["wss://rpc.pyropechain.com"]
+};
+var pyrope = {
+  ...chainConfig2,
+  name: "Pyrope Testnet",
+  testnet: true,
+  id: 695569,
+  sourceId: sourceId2,
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: defaultRpcUrls2,
+    bundler: defaultRpcUrls2
+  },
+  contracts: {
+    ...chainConfig2.contracts,
+    l1StandardBridge: {
+      [sourceId2]: {
+        address: "0xC24932c31D9621aE9e792576152B7ef010cFC2F8"
+      }
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Blockscout",
+      url: "https://explorer.pyropechain.com"
+    },
+    worldsExplorer: {
+      name: "MUD Worlds Explorer",
+      url: "https://explorer.mud.dev/pyrope/worlds"
+    }
+  },
+  iconUrls: ["https://lattice.xyz/brand/color/pyrope.svg"],
+  indexerUrl: "https://indexer.mud.pyropechain.com"
+};
 export {
   garnet,
   mudFoundry,
+  pyrope,
   redstone,
   rhodolite
 };

package/dist/chains.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/chains/mudFoundry.ts","../src/chains/redstone.ts","../src/chains/garnet.ts","../src/chains/rhodolite.ts"],"sourcesContent":["import { foundry } from \"viem/chains\";\nimport { MUDChain } from \"./types\";\n\nexport const mudFoundry = {\n  ...foundry,\n  fees: {\n    defaultPriorityFee: 0n,\n  },\n} as const satisfies MUDChain;\n","import { redstone as redstoneConfig } from \"viem/chains\";\nimport type { MUDChain } from \"./types\";\n\nexport const redstone = {\n  ...redstoneConfig,\n  iconUrls: [\"https://redstone.xyz/chain-icons/redstone.png\"],\n  indexerUrl: \"https://indexer.mud.redstonechain.com\",\n} as const satisfies MUDChain;\n","import { garnet as garnetConfig } from \"viem/chains\";\nimport type { MUDChain } from \"./types\";\n\nexport const garnet = {\n  ...garnetConfig,\n  rpcUrls: {\n    ...garnetConfig.rpcUrls,\n    bundler: garnetConfig.rpcUrls.default,\n  },\n  iconUrls: [\"https://redstone.xyz/chain-icons/garnet.png\"],\n  indexerUrl: \"https://indexer.mud.garnetchain.com\",\n} as const satisfies MUDChain;\n","import { chainConfig } from \"viem/op-stack\";\nimport { MUDChain } from \"./types\";\nimport { Chain } from \"viem\";\n\nconst sourceId = 17000;\n\nconst defaultRpcUrls = {\n  http: [\"https://rpc.rhodolitechain.com\"],\n  webSocket: [\"wss://rpc.rhodolitechain.com\"],\n} as const satisfies Chain[\"rpcUrls\"][\"default\"];\n\nexport const rhodolite = {\n  ...chainConfig,\n  name: \"Rhodolite Devnet\",\n  testnet: true,\n  id: 17420,\n  sourceId,\n  nativeCurrency: { name: \"Ether\", symbol: \"ETH\", decimals: 18 },\n  rpcUrls: {\n    default: defaultRpcUrls,\n    bundler: defaultRpcUrls,\n    quarryPassIssuer: defaultRpcUrls,\n    wiresaw: defaultRpcUrls,\n  },\n  contracts: {\n    ...chainConfig.contracts,\n    l1StandardBridge: {\n      [sourceId]: {\n        address: \"0x6487446e0B9FAEa90F6a9772A6448cFa780E30F9\",\n      },\n    },\n    quarryPaymaster: {\n      address: \"0x7ca1b85aca23fccf2fbac14c02b5e8a6432639b9\",\n    },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Blockscout\",\n      url: \"https://explorer.rhodolitechain.com\",\n    },\n    worldsExplorer: {\n      name: \"MUD Worlds Explorer\",\n      url: \"https://explorer.mud.dev/rhodolite/worlds\",\n    },\n  },\n  iconUrls: [\"https://redstone.xyz/chain-icons/rhodolite.png\"],\n  indexerUrl: \"https://indexer.mud.rhodolitechain.com\",\n} as const satisfies MUDChain;\n"],"mappings":";AAAA,SAAS,eAAe;AAGjB,IAAM,aAAa;AAAA,EACxB,GAAG;AAAA,EACH,MAAM;AAAA,IACJ,oBAAoB;AAAA,EACtB;AACF;;;ACRA,SAAS,YAAY,sBAAsB;AAGpC,IAAM,WAAW;AAAA,EACtB,GAAG;AAAA,EACH,UAAU,CAAC,+CAA+C;AAAA,EAC1D,YAAY;AACd;;;ACPA,SAAS,UAAU,oBAAoB;AAGhC,IAAM,SAAS;AAAA,EACpB,GAAG;AAAA,EACH,SAAS;AAAA,IACP,GAAG,aAAa;AAAA,IAChB,SAAS,aAAa,QAAQ;AAAA,EAChC;AAAA,EACA,UAAU,CAAC,6CAA6C;AAAA,EACxD,YAAY;AACd;;;ACXA,SAAS,mBAAmB;AAI5B,IAAM,WAAW;AAEjB,IAAM,iBAAiB;AAAA,EACrB,MAAM,CAAC,gCAAgC;AAAA,EACvC,WAAW,CAAC,8BAA8B;AAC5C;AAEO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,MAAM;AAAA,EACN,SAAS;AAAA,EACT,IAAI;AAAA,EACJ;AAAA,EACA,gBAAgB,EAAE,MAAM,SAAS,QAAQ,OAAO,UAAU,GAAG;AAAA,EAC7D,SAAS;AAAA,IACP,SAAS;AAAA,IACT,SAAS;AAAA,IACT,kBAAkB;AAAA,IAClB,SAAS;AAAA,EACX;AAAA,EACA,WAAW;AAAA,IACT,GAAG,YAAY;AAAA,IACf,kBAAkB;AAAA,MAChB,CAAC,QAAQ,GAAG;AAAA,QACV,SAAS;AAAA,MACX;AAAA,IACF;AAAA,IACA,iBAAiB;AAAA,MACf,SAAS;AAAA,IACX;AAAA,EACF;AAAA,EACA,gBAAgB;AAAA,IACd,SAAS;AAAA,MACP,MAAM;AAAA,MACN,KAAK;AAAA,IACP;AAAA,IACA,gBAAgB;AAAA,MACd,MAAM;AAAA,MACN,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EACA,UAAU,CAAC,gDAAgD;AAAA,EAC3D,YAAY;AACd;","names":[]}
+{"version":3,"sources":["../src/chains/mudFoundry.ts","../src/chains/redstone.ts","../src/chains/garnet.ts","../src/chains/rhodolite.ts","../src/chains/pyrope.ts"],"sourcesContent":["import { foundry } from \"viem/chains\";\nimport { MUDChain } from \"./types\";\n\nexport const mudFoundry = {\n  ...foundry,\n  fees: {\n    defaultPriorityFee: 0n,\n  },\n} as const satisfies MUDChain;\n","import { redstone as redstoneConfig } from \"viem/chains\";\nimport type { MUDChain } from \"./types\";\n\nexport const redstone = {\n  ...redstoneConfig,\n  iconUrls: [\"https://redstone.xyz/chain-icons/redstone.png\"],\n  indexerUrl: \"https://indexer.mud.redstonechain.com\",\n} as const satisfies MUDChain;\n","import { garnet as garnetConfig } from \"viem/chains\";\nimport type { MUDChain } from \"./types\";\n\nexport const garnet = {\n  ...garnetConfig,\n  rpcUrls: {\n    ...garnetConfig.rpcUrls,\n    bundler: garnetConfig.rpcUrls.default,\n  },\n  iconUrls: [\"https://redstone.xyz/chain-icons/garnet.png\"],\n  indexerUrl: \"https://indexer.mud.garnetchain.com\",\n} as const satisfies MUDChain;\n","import { chainConfig } from \"viem/op-stack\";\nimport { MUDChain } from \"./types\";\nimport { Chain } from \"viem\";\n\nconst sourceId = 17000;\n\nconst defaultRpcUrls = {\n  http: [\"https://rpc.rhodolitechain.com\"],\n  webSocket: [\"wss://rpc.rhodolitechain.com\"],\n} as const satisfies Chain[\"rpcUrls\"][\"default\"];\n\nexport const rhodolite = {\n  ...chainConfig,\n  name: \"Rhodolite Devnet\",\n  testnet: true,\n  id: 17420,\n  sourceId,\n  nativeCurrency: { name: \"Ether\", symbol: \"ETH\", decimals: 18 },\n  rpcUrls: {\n    default: defaultRpcUrls,\n    bundler: defaultRpcUrls,\n    quarryPassIssuer: defaultRpcUrls,\n    wiresaw: defaultRpcUrls,\n  },\n  contracts: {\n    ...chainConfig.contracts,\n    l1StandardBridge: {\n      [sourceId]: {\n        address: \"0x6487446e0B9FAEa90F6a9772A6448cFa780E30F9\",\n      },\n    },\n    quarryPaymaster: {\n      address: \"0x7ca1b85aca23fccf2fbac14c02b5e8a6432639b9\",\n    },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Blockscout\",\n      url: \"https://explorer.rhodolitechain.com\",\n    },\n    worldsExplorer: {\n      name: \"MUD Worlds Explorer\",\n      url: \"https://explorer.mud.dev/rhodolite/worlds\",\n    },\n  },\n  iconUrls: [\"https://redstone.xyz/chain-icons/rhodolite.png\"],\n  indexerUrl: \"https://indexer.mud.rhodolitechain.com\",\n} as const satisfies MUDChain;\n","import { chainConfig } from \"viem/op-stack\";\nimport { MUDChain } from \"./types\";\nimport { Chain } from \"viem\";\n\nconst sourceId = 11155111;\n\nconst defaultRpcUrls = {\n  http: [\"https://rpc.pyropechain.com\"],\n  webSocket: [\"wss://rpc.pyropechain.com\"],\n} as const satisfies Chain[\"rpcUrls\"][\"default\"];\n\nexport const pyrope = {\n  ...chainConfig,\n  name: \"Pyrope Testnet\",\n  testnet: true,\n  id: 695569,\n  sourceId,\n  nativeCurrency: { name: \"Ether\", symbol: \"ETH\", decimals: 18 },\n  rpcUrls: {\n    default: defaultRpcUrls,\n    bundler: defaultRpcUrls,\n  },\n  contracts: {\n    ...chainConfig.contracts,\n    l1StandardBridge: {\n      [sourceId]: {\n        address: \"0xC24932c31D9621aE9e792576152B7ef010cFC2F8\",\n      },\n    },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Blockscout\",\n      url: \"https://explorer.pyropechain.com\",\n    },\n    worldsExplorer: {\n      name: \"MUD Worlds Explorer\",\n      url: \"https://explorer.mud.dev/pyrope/worlds\",\n    },\n  },\n  iconUrls: [\"https://lattice.xyz/brand/color/pyrope.svg\"],\n  indexerUrl: \"https://indexer.mud.pyropechain.com\",\n} as const satisfies MUDChain;\n"],"mappings":";AAAA,SAAS,eAAe;AAGjB,IAAM,aAAa;AAAA,EACxB,GAAG;AAAA,EACH,MAAM;AAAA,IACJ,oBAAoB;AAAA,EACtB;AACF;;;ACRA,SAAS,YAAY,sBAAsB;AAGpC,IAAM,WAAW;AAAA,EACtB,GAAG;AAAA,EACH,UAAU,CAAC,+CAA+C;AAAA,EAC1D,YAAY;AACd;;;ACPA,SAAS,UAAU,oBAAoB;AAGhC,IAAM,SAAS;AAAA,EACpB,GAAG;AAAA,EACH,SAAS;AAAA,IACP,GAAG,aAAa;AAAA,IAChB,SAAS,aAAa,QAAQ;AAAA,EAChC;AAAA,EACA,UAAU,CAAC,6CAA6C;AAAA,EACxD,YAAY;AACd;;;ACXA,SAAS,mBAAmB;AAI5B,IAAM,WAAW;AAEjB,IAAM,iBAAiB;AAAA,EACrB,MAAM,CAAC,gCAAgC;AAAA,EACvC,WAAW,CAAC,8BAA8B;AAC5C;AAEO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,MAAM;AAAA,EACN,SAAS;AAAA,EACT,IAAI;AAAA,EACJ;AAAA,EACA,gBAAgB,EAAE,MAAM,SAAS,QAAQ,OAAO,UAAU,GAAG;AAAA,EAC7D,SAAS;AAAA,IACP,SAAS;AAAA,IACT,SAAS;AAAA,IACT,kBAAkB;AAAA,IAClB,SAAS;AAAA,EACX;AAAA,EACA,WAAW;AAAA,IACT,GAAG,YAAY;AAAA,IACf,kBAAkB;AAAA,MAChB,CAAC,QAAQ,GAAG;AAAA,QACV,SAAS;AAAA,MACX;AAAA,IACF;AAAA,IACA,iBAAiB;AAAA,MACf,SAAS;AAAA,IACX;AAAA,EACF;AAAA,EACA,gBAAgB;AAAA,IACd,SAAS;AAAA,MACP,MAAM;AAAA,MACN,KAAK;AAAA,IACP;AAAA,IACA,gBAAgB;AAAA,MACd,MAAM;AAAA,MACN,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EACA,UAAU,CAAC,gDAAgD;AAAA,EAC3D,YAAY;AACd;;;AC/CA,SAAS,eAAAA,oBAAmB;AAI5B,IAAMC,YAAW;AAEjB,IAAMC,kBAAiB;AAAA,EACrB,MAAM,CAAC,6BAA6B;AAAA,EACpC,WAAW,CAAC,2BAA2B;AACzC;AAEO,IAAM,SAAS;AAAA,EACpB,GAAGF;AAAA,EACH,MAAM;AAAA,EACN,SAAS;AAAA,EACT,IAAI;AAAA,EACJ,UAAAC;AAAA,EACA,gBAAgB,EAAE,MAAM,SAAS,QAAQ,OAAO,UAAU,GAAG;AAAA,EAC7D,SAAS;AAAA,IACP,SAASC;AAAA,IACT,SAASA;AAAA,EACX;AAAA,EACA,WAAW;AAAA,IACT,GAAGF,aAAY;AAAA,IACf,kBAAkB;AAAA,MAChB,CAACC,SAAQ,GAAG;AAAA,QACV,SAAS;AAAA,MACX;AAAA,IACF;AAAA,EACF;AAAA,EACA,gBAAgB;AAAA,IACd,SAAS;AAAA,MACP,MAAM;AAAA,MACN,KAAK;AAAA,IACP;AAAA,IACA,gBAAgB;AAAA,MACd,MAAM;AAAA,MACN,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EACA,UAAU,CAAC,4CAA4C;AAAA,EACvD,YAAY;AACd;","names":["chainConfig","sourceId","defaultRpcUrls"]}

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,