@gnosis-guild/zodiac 4.2.0 → 5.0.0

package/dist/cjs/explorer.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceCode = getSourceCode;
+exports.getContractCreation = getContractCreation;
+exports.getTransaction = getTransaction;
+exports.getCode = getCode;
+exports.verifySourceCode = verifySourceCode;
+exports.checkVerificationStatus = checkVerificationStatus;
+const networks_js_1 = require("./networks.js");
+function isOk(status) {
+    return String(status) === "1";
+}
+/**
+ * Etherscan double-wraps the standard-JSON source in extra braces. Parse
+ * tolerantly so both `{{...}}` and `{...}` payloads succeed.
+ */
+function safeJsonParse(input) {
+    const trimmed = input.trim();
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return JSON.parse(trimmed.replace(/^\{|\}$/g, "").trim());
+    }
+}
+function parseLibraries(input) {
+    const libraries = {};
+    for (const entry of (input || "").split(/[;,]/)) {
+        const match = entry.trim().match(/^(.+?)(?::|\s)+(0x[0-9a-fA-F]{40})$/);
+        if (match)
+            libraries[match[1].trim()] = match[2];
+    }
+    return libraries;
+}
+function compilerInputFromExplorerEntry(entry) {
+    const sourceCode = entry.SourceCode.trim();
+    const contractName = entry.ContractName;
+    if (sourceCode.startsWith("{")) {
+        const compilerInput = safeJsonParse(sourceCode);
+        return {
+            compilerInput,
+            sourceName: sourceNameFor(compilerInput, contractName),
+        };
+    }
+    const sourceName = entry.ContractFileName || `${contractName}.sol`;
+    const settings = {};
+    if (entry.OptimizationUsed !== "") {
+        settings.optimizer = {
+            enabled: String(entry.OptimizationUsed) === "1",
+            runs: Number(entry.Runs) || 200,
+        };
+    }
+    if (entry.EVMVersion && entry.EVMVersion !== "Default") {
+        settings.evmVersion = entry.EVMVersion;
+    }
+    const libraries = parseLibraries(entry.Library);
+    if (Object.keys(libraries).length > 0) {
+        settings.libraries = { [sourceName]: libraries };
+    }
+    return {
+        sourceName,
+        compilerInput: {
+            language: "Solidity",
+            sources: {
+                [sourceName]: { content: sourceCode },
+            },
+            settings,
+        },
+    };
+}
+function resolveApiKey(network, explicit) {
+    return (explicit ||
+        process.env[`ETHERSCAN_API_KEY_${network.toUpperCase()}`] ||
+        process.env.ETHERSCAN_API_KEY ||
+        "");
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function isRateLimited(body) {
+    const text = `${body?.message ?? ""} ${body?.result ?? ""}`.toLowerCase();
+    return text.includes("rate limit");
+}
+/**
+ * Internal helper to perform a GET against the explorer API.
+ * Resolves network, API key, and handles rate-limiting retries.
+ */
+async function explorerGet(networkOrChainId, params, apiKey, attempt = 0) {
+    const network = (0, networks_js_1.resolveNetwork)(networkOrChainId);
+    if (!network.etherscanApiUrl) {
+        throw new Error(`${network.name} (chain ${network.chainId}) is not supported by Etherscan V2.`);
+    }
+    const url = new URL(network.etherscanApiUrl);
+    url.searchParams.set("apikey", resolveApiKey(network.name, apiKey));
+    for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Explorer request failed: ${response.status}`);
+    }
+    const body = (await response.json());
+    if (isRateLimited(body) && attempt < 5) {
+        await sleep(1000 * (attempt + 1));
+        return explorerGet(networkOrChainId, params, apiKey, attempt + 1);
+    }
+    return body;
+}
+async function explorerPost(networkOrChainId, params, apiKey, attempt = 0) {
+    const network = (0, networks_js_1.resolveNetwork)(networkOrChainId);
+    if (!network.etherscanApiUrl) {
+        throw new Error(`${network.name} (chain ${network.chainId}) is not supported by Etherscan V2.`);
+    }
+    const body = new URLSearchParams();
+    body.set("apikey", resolveApiKey(network.name, apiKey));
+    for (const [key, value] of new URL(network.etherscanApiUrl).searchParams) {
+        body.set(key, value);
+    }
+    for (const [key, value] of Object.entries(params)) {
+        body.set(key, value);
+    }
+    const response = await fetch(network.etherscanApiUrl, {
+        method: "POST",
+        headers: {
+            "content-type": "application/x-www-form-urlencoded",
+        },
+        body,
+    });
+    if (!response.ok) {
+        throw new Error(`Explorer request failed: ${response.status}`);
+    }
+    const responseBody = (await response.json());
+    if (isRateLimited(responseBody) && attempt < 5) {
+        await sleep(1000 * (attempt + 1));
+        return explorerPost(networkOrChainId, params, apiKey, attempt + 1);
+    }
+    return responseBody;
+}
+/**
+ * Fetch verified source, ABI and compiler input for a deployed contract.
+ */
+async function getSourceCode({ address, network, apiKey, }) {
+    const { status, message, result } = await explorerGet(network, {
+        module: "contract",
+        action: "getsourcecode",
+        address,
+    }, apiKey);
+    if (!isOk(status)) {
+        throw new Error(`getsourcecode failed for ${address}: ${message}${result ? ` (${result})` : ""}`);
+    }
+    const entry = result[0];
+    if (!entry?.SourceCode) {
+        throw new Error(`Contract ${address} is not verified on ${network}`);
+    }
+    const { compilerInput, sourceName } = compilerInputFromExplorerEntry(entry);
+    return {
+        contractName: entry.ContractName,
+        sourceName,
+        compilerVersion: entry.CompilerVersion,
+        compilerInput,
+        abi: entry.ABI ? safeJsonParse(entry.ABI) : undefined,
+        constructorArguments: entry.ConstructorArguments || "",
+    };
+}
+/**
+ * Resolve the full source path for a contract name within a standard-JSON input.
+ */
+function sourceNameFor(compilerInput, contractName) {
+    const sources = compilerInput?.sources || {};
+    // Prefer a source file whose path basename matches the contract name.
+    const match = Object.keys(sources).find((path) => path
+        .split("/")
+        .pop()
+        ?.replace(/\.sol$/, "") === contractName);
+    if (match)
+        return match;
+    const [only] = Object.keys(sources);
+    if (only)
+        return only;
+    throw new Error(`Could not resolve sourceName for ${contractName}`);
+}
+/**
+ * Get creation metadata (tx hash and bytecode) for a contract.
+ */
+async function getContractCreation({ address, network, apiKey, }) {
+    const { status, result } = await explorerGet(network, {
+        module: "contract",
+        action: "getcontractcreation",
+        contractaddresses: address,
+    }, apiKey);
+    if (!isOk(status) || !Array.isArray(result) || result.length === 0) {
+        return undefined;
+    }
+    return {
+        txHash: result[0].txHash,
+        creationBytecode: result[0].creationBytecode,
+    };
+}
+/**
+ * Fetch a transaction (input + to) via the explorer's proxy module.
+ */
+async function getTransaction({ txHash, network, apiKey, }) {
+    const { result } = await explorerGet(network, {
+        module: "proxy",
+        action: "eth_getTransactionByHash",
+        txhash: txHash,
+    }, apiKey);
+    if (!result?.input)
+        return undefined;
+    return { to: result.to ?? null, input: result.input };
+}
+/**
+ * Fetch the deployed (runtime) bytecode at an address via the proxy module.
+ */
+async function getCode({ address, network, apiKey, }) {
+    const { result } = await explorerGet(network, {
+        module: "proxy",
+        action: "eth_getCode",
+        address,
+        tag: "latest",
+    }, apiKey);
+    return result ?? "0x";
+}
+/**
+ * Submit standard-JSON Solidity source for verification.
+ */
+async function verifySourceCode({ address, network, sourceCode, contractName, compilerVersion, constructorArguments = "", evmVersion = "default", licenseType = "1", apiKey, }) {
+    const { status, message, result } = await explorerPost(network, {
+        module: "contract",
+        action: "verifysourcecode",
+        contractaddress: address,
+        sourceCode,
+        codeformat: "solidity-standard-json-input",
+        contractname: contractName,
+        compilerversion: compilerVersion,
+        optimizationUsed: "0",
+        runs: "200",
+        constructorArguments,
+        evmVersion,
+        licenseType,
+    }, apiKey);
+    if (!isOk(status)) {
+        if (typeof result === "string" &&
+            result.toLowerCase().includes("already")) {
+            return result;
+        }
+        throw new Error(`${message}${result ? ` (${result})` : ""}`);
+    }
+    return result;
+}
+/**
+ * Check the async source verification status for a submitted GUID.
+ */
+async function checkVerificationStatus({ guid, network, apiKey, }) {
+    const { status, message, result } = await explorerPost(network, {
+        module: "contract",
+        action: "checkverifystatus",
+        guid,
+    }, apiKey);
+    if (!isOk(status)) {
+        if (typeof result === "string" && result)
+            return result;
+        throw new Error(`${message}${result ? ` (${result})` : ""}`);
+    }
+    return result;
+}

package/dist/cjs/extract.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extract = extract;
+const ethers_1 = require("ethers");
+const zodiac_core_1 = require("@gnosis-guild/zodiac-core");
+const networks_js_1 = require("./networks.js");
+const explorer_js_1 = require("./explorer.js");
+const singleton_js_1 = require("./singleton.js");
+/**
+ * Enumerate the libraries a contract links, from its standard-JSON compiler
+ * input. Shape: `settings.libraries = { [sourceName]: { [libName]: address } }`.
+ */
+function enumerateLibraries(input) {
+    const libraries = input?.settings?.libraries || {};
+    const out = [];
+    for (const sourceName of Object.keys(libraries)) {
+        for (const libraryName of Object.keys(libraries[sourceName] || {})) {
+            const address = libraries[sourceName][libraryName];
+            if (address)
+                out.push({ sourceName, libraryName, address });
+        }
+    }
+    return out;
+}
+/**
+ * Extract an asset (and, recursively, every library it links) from a block
+ * explorer.
+ *
+ * Recursion is depth-first and deduplicated by address, so a library shared by
+ * several contracts is fetched once.
+ *
+ * @returns every asset produced, keyed by lower-cased address.
+ */
+async function extract({ network, address, apiKey, }) {
+    const net = (0, networks_js_1.resolveNetwork)(network);
+    const visited = new Map();
+    await extractOne({
+        address,
+        networkName: net.name,
+        apiKey,
+        visited,
+    });
+    return visited;
+}
+async function extractOne({ address, nameHint, networkName, apiKey, visited, }) {
+    const key = (0, ethers_1.getAddress)(address).toLowerCase();
+    const existing = visited.get(key);
+    if (existing)
+        return existing;
+    const source = await (0, explorer_js_1.getSourceCode)({ address, network: networkName, apiKey });
+    const name = nameHint || source.contractName;
+    const creation = await (0, explorer_js_1.getContractCreation)({
+        address,
+        network: networkName,
+        apiKey,
+    });
+    const tx = creation?.txHash
+        ? await (0, explorer_js_1.getTransaction)({
+            txHash: creation.txHash,
+            network: networkName,
+            apiKey,
+        })
+        : undefined;
+    const recovered = tx && (0, singleton_js_1.recoverDeployment)(tx);
+    if (!recovered) {
+        throw new Error(`${name} @ ${address} was not deployed via a known singleton factory.`);
+    }
+    const { factory, initCode: creationBytecode, salt } = recovered;
+    // Sanity: the recovered creation bytecode must reproduce the on-chain address
+    // via CREATE2. By construction it always does — a failure means a parsing bug.
+    // zodiac-core's helper concatenates bytecode + encoded constructor args; we
+    // already hold the full creation bytecode, so pass it as `bytecode` with empty
+    // args (the concat is then a no-op).
+    const predicted = (0, zodiac_core_1.predictSingletonAddress)({
+        factory,
+        bytecode: creationBytecode,
+        constructorArgs: { types: [], values: [] },
+        salt,
+    });
+    if (predicted.toLowerCase() !== key) {
+        throw new Error(`${name} @ ${address}: recovered creation bytecode reproduces ` +
+            `${predicted}, not the on-chain address. Refusing to write.`);
+    }
+    // Deployed (runtime) bytecode actually stored at the address.
+    const bytecode = await (0, explorer_js_1.getCode)({ address, network: networkName, apiKey });
+    // Record this asset before recursing so shared libraries dedupe correctly.
+    const asset = {
+        name,
+        abi: source.abi,
+        sourceCode: {
+            contractName: source.contractName,
+            sourceName: source.sourceName,
+            compilerVersion: source.compilerVersion,
+            constructorArguments: source.constructorArguments,
+            input: source.compilerInput,
+        },
+        bytecode: {
+            address: predicted,
+            factory,
+            salt,
+            creationBytecode,
+            bytecode,
+        },
+    };
+    visited.set(key, asset);
+    // Recurse into linked libraries.
+    for (const lib of enumerateLibraries(source.compilerInput)) {
+        await extractOne({
+            address: lib.address,
+            nameHint: lib.libraryName,
+            networkName,
+            apiKey,
+            visited,
+        });
+    }
+    return asset;
+}

package/dist/cjs/index.js

@@ -1,17 +1,16 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./factory"), exports);
+exports.sanityCheckZodiacModuleAddress = exports.getZodiacModuleAddress = exports.getZodiacModuleAbi = exports.SupportedNetworks = exports.KnownContracts = exports.CanonicalAddresses = exports.predictSingletonAddress = exports.predictProxyAddress = exports.encodeDeploySingleton = exports.encodeDeployProxy = void 0;
+var zodiac_core_1 = require("@gnosis-guild/zodiac-core");
+Object.defineProperty(exports, "encodeDeployProxy", { enumerable: true, get: function () { return zodiac_core_1.encodeDeployProxy; } });
+Object.defineProperty(exports, "encodeDeploySingleton", { enumerable: true, get: function () { return zodiac_core_1.encodeDeploySingleton; } });
+Object.defineProperty(exports, "predictProxyAddress", { enumerable: true, get: function () { return zodiac_core_1.predictProxyAddress; } });
+Object.defineProperty(exports, "predictSingletonAddress", { enumerable: true, get: function () { return zodiac_core_1.predictSingletonAddress; } });
+var contracts_js_1 = require("./contracts.js");
+Object.defineProperty(exports, "CanonicalAddresses", { enumerable: true, get: function () { return contracts_js_1.CanonicalAddresses; } });
+Object.defineProperty(exports, "KnownContracts", { enumerable: true, get: function () { return contracts_js_1.KnownContracts; } });
+Object.defineProperty(exports, "SupportedNetworks", { enumerable: true, get: function () { return contracts_js_1.SupportedNetworks; } });
+var zodiacModule_js_1 = require("./zodiacModule.js");
+Object.defineProperty(exports, "getZodiacModuleAbi", { enumerable: true, get: function () { return zodiacModule_js_1.getZodiacModuleAbi; } });
+Object.defineProperty(exports, "getZodiacModuleAddress", { enumerable: true, get: function () { return zodiacModule_js_1.getZodiacModuleAddress; } });
+Object.defineProperty(exports, "sanityCheckZodiacModuleAddress", { enumerable: true, get: function () { return zodiacModule_js_1.sanityCheckZodiacModuleAddress; } });

package/dist/cjs/mastercopies.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMastercopiesDir = defaultMastercopiesDir;
+exports.writeAsset = writeAsset;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const process_1 = require("process");
+/**
+ * The on-disk layout:
+ *
+ *   mastercopies/<module>/<version>/<asset>/abi.json
+ *   mastercopies/<module>/<version>/<asset>/sourcecode.json
+ *   mastercopies/<module>/<version>/<asset>/bytecode.json
+ *
+ * where <asset> is the main contract name or a linked-library name.
+ */
+function defaultMastercopiesDir() {
+    return path_1.default.join((0, process_1.cwd)(), "mastercopies");
+}
+/**
+ * Write one asset's three files, creating directories as needed.
+ * Returns the asset directory.
+ */
+function writeAsset({ module, version, asset, mastercopiesDir = defaultMastercopiesDir(), }) {
+    const dir = path_1.default.join(mastercopiesDir, module, version, asset.name);
+    (0, fs_1.mkdirSync)(dir, { recursive: true });
+    (0, fs_1.writeFileSync)(path_1.default.join(dir, "abi.json"), JSON.stringify(asset.abi, null, 2), "utf8");
+    (0, fs_1.writeFileSync)(path_1.default.join(dir, "sourcecode.json"), JSON.stringify(asset.sourceCode, null, 2), "utf8");
+    (0, fs_1.writeFileSync)(path_1.default.join(dir, "bytecode.json"), JSON.stringify(asset.bytecode, null, 2), "utf8");
+    return dir;
+}

package/dist/cjs/networks.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Source-of-truth network registry.
+ *
+ * One entry per chain referenced across the Zodiac repos (the in-repo chain
+ * list plus the chains served by `ser` and `rolesSubgraph`). Each entry carries:
+ *
+ *  - `chainId`          the canonical chain id
+ *  - `alchemyRpcUrl`    Alchemy JSON-RPC endpoint, or null when Alchemy does
+ *                       not serve the chain. The key is read from `ALCHEMY_KEY`.
+ *  - `publicRpc`        public JSON-RPC endpoint, or null when no public
+ *                       fallback is configured.
+ *  - `etherscanApiUrl`  Etherscan V2 multichain explorer API endpoint (with
+ *                       `?chainid=`), or null when the chain is not supported
+ *                       by Etherscan V2. V2 support was checked against
+ *                       api.etherscan.io/v2/chainlist.
+ *
+ * Entries are sorted by `chainId`.
+ *
+ * Not wired into anything yet — this is a config drop, intentionally standalone.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networks = void 0;
+exports.resolveNetwork = resolveNetwork;
+const ETHERSCAN_V2_API = "https://api.etherscan.io/v2/api";
+const alchemyKey = typeof process !== "undefined" ? process.env.ALCHEMY_KEY ?? "" : "";
+const ETHERSCAN_V2_CHAIN_IDS = new Set([
+    1, 10, 50, 51, 56, 100, 130, 143, 146, 199, 204, 252, 480, 988, 999, 1029,
+    1284, 1285, 1287, 1328, 1329, 2201, 2523, 2741, 4326, 4352, 5000, 5611, 6343,
+    8453, 9745, 9746, 10143, 11124, 33111, 33139, 42161, 42220, 43114, 43522,
+    59144, 80069, 80094, 81457, 167000, 167013, 560048, 737373, 747474, 11155111,
+    168587773,
+]);
+/** Build an Alchemy RPC URL from its endpoint subdomain. */
+const alchemy = (subdomain) => `https://${subdomain}.g.alchemy.com/v2/${alchemyKey}`;
+/** Build the Etherscan V2 multichain API URL for a chain. */
+const etherscanV2 = (chainId) => ETHERSCAN_V2_CHAIN_IDS.has(chainId)
+    ? `${ETHERSCAN_V2_API}?chainid=${chainId}`
+    : null;
+exports.networks = [
+    {
+        name: "mainnet",
+        chainId: 1,
+        alchemyRpcUrl: alchemy("eth-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(1),
+    },
+    {
+        name: "optimism",
+        chainId: 10,
+        alchemyRpcUrl: alchemy("opt-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(10),
+    },
+    {
+        name: "flare",
+        chainId: 14,
+        alchemyRpcUrl: null,
+        publicRpc: "https://flare-api.flare.network/ext/C/rpc",
+        etherscanApiUrl: null,
+    },
+    {
+        name: "bnb",
+        chainId: 56,
+        alchemyRpcUrl: alchemy("bnb-mainnet"),
+        publicRpc: "https://bsc-dataseed.bnbchain.org",
+        etherscanApiUrl: etherscanV2(56),
+    },
+    {
+        name: "gnosis",
+        chainId: 100,
+        alchemyRpcUrl: null,
+        publicRpc: "https://rpc.gnosischain.com",
+        etherscanApiUrl: etherscanV2(100),
+    },
+    {
+        name: "unichain",
+        chainId: 130,
+        alchemyRpcUrl: alchemy("unichain-mainnet"),
+        publicRpc: "https://mainnet.unichain.org",
+        etherscanApiUrl: etherscanV2(130),
+    },
+    {
+        name: "polygon",
+        chainId: 137,
+        alchemyRpcUrl: alchemy("polygon-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(137),
+    },
+    {
+        name: "sonic",
+        chainId: 146,
+        alchemyRpcUrl: null,
+        publicRpc: "https://rpc.soniclabs.com",
+        etherscanApiUrl: etherscanV2(146),
+    },
+    {
+        name: "worldchain",
+        chainId: 480,
+        alchemyRpcUrl: null,
+        publicRpc: "https://worldchain-mainnet.g.alchemy.com/public",
+        etherscanApiUrl: etherscanV2(480),
+    },
+    {
+        name: "hyperevm",
+        chainId: 999,
+        alchemyRpcUrl: null, //alchemy("hyperliquid-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(999),
+    },
+    {
+        name: "megaeth",
+        chainId: 4326,
+        alchemyRpcUrl: alchemy("megaeth-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(4326),
+    },
+    {
+        name: "mantle",
+        chainId: 5000,
+        alchemyRpcUrl: alchemy("mantle-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(5000),
+    },
+    {
+        name: "base",
+        chainId: 8453,
+        alchemyRpcUrl: alchemy("base-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(8453),
+    },
+    {
+        name: "plasma",
+        chainId: 9745,
+        alchemyRpcUrl: null,
+        publicRpc: "https://rpc.plasma.to",
+        etherscanApiUrl: etherscanV2(9745),
+    },
+    {
+        name: "arbitrum",
+        chainId: 42161,
+        alchemyRpcUrl: alchemy("arb-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(42161),
+    },
+    {
+        name: "celo",
+        chainId: 42220,
+        alchemyRpcUrl: alchemy("celo-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(42220),
+    },
+    {
+        name: "avalanche",
+        chainId: 43114,
+        alchemyRpcUrl: alchemy("avax-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(43114),
+    },
+    {
+        name: "ink",
+        chainId: 57073,
+        alchemyRpcUrl: alchemy("ink-mainnet"),
+        publicRpc: "https://rpc-gel.inkonchain.com",
+        etherscanApiUrl: null,
+    },
+    {
+        name: "linea",
+        chainId: 59144,
+        alchemyRpcUrl: alchemy("linea-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(59144),
+    },
+    {
+        name: "bob",
+        chainId: 60808,
+        alchemyRpcUrl: null,
+        publicRpc: "https://rpc.gobob.xyz",
+        etherscanApiUrl: null,
+    },
+    {
+        name: "berachain",
+        chainId: 80094,
+        alchemyRpcUrl: null,
+        publicRpc: "https://rpc.berachain.com",
+        etherscanApiUrl: etherscanV2(80094),
+    },
+    {
+        name: "scroll",
+        chainId: 534352,
+        alchemyRpcUrl: alchemy("scroll-mainnet"),
+        publicRpc: null,
+        etherscanApiUrl: null,
+    },
+    {
+        name: "katana",
+        chainId: 747474,
+        alchemyRpcUrl: null,
+        publicRpc: "https://rpc.katana.network",
+        etherscanApiUrl: etherscanV2(747474),
+    },
+    {
+        name: "sepolia",
+        chainId: 11155111,
+        alchemyRpcUrl: alchemy("eth-sepolia"),
+        publicRpc: null,
+        etherscanApiUrl: etherscanV2(11155111),
+    },
+];
+/**
+ * Resolve a network name or chain id (string or number) to its config. An
+ * unknown name throws; an unknown numeric chain id resolves to an Etherscan V2
+ * entry only when that chain is listed by Etherscan V2.
+ */
+function resolveNetwork(networkOrChainId) {
+    const key = String(networkOrChainId).toLowerCase();
+    const found = exports.networks.find((n) => n.name.toLowerCase() === key || String(n.chainId) === key);
+    if (found)
+        return found;
+    if (/^\d+$/.test(key)) {
+        const chainId = Number(key);
+        return {
+            name: key,
+            chainId,
+            alchemyRpcUrl: null,
+            publicRpc: null,
+            etherscanApiUrl: etherscanV2(chainId),
+        };
+    }
+    throw new Error(`Unknown network "${networkOrChainId}". Known networks: ${exports.networks
+        .map((n) => n.name)
+        .join(", ")} (or pass a numeric chain id).`);
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}