@gnosis-guild/zodiac 4.2.1 → 5.0.0

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"}

package/dist/cjs/rpc.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCode = getCode;
+/**
+ * Perform a raw JSON-RPC eth_getCode call using fetch.
+ * This is used for fast, low-overhead status checks across many networks
+ * without initializing a full Ethers provider.
+ */
+async function getCode(rpcUrl, address) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5_000);
+    try {
+        const response = await fetch(rpcUrl, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "eth_getCode",
+                params: [address, "latest"],
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`RPC returned HTTP ${response.status}`);
+        }
+        const payload = (await response.json());
+        if (payload.error || typeof payload.result !== "string") {
+            throw new Error("RPC returned an invalid eth_getCode response");
+        }
+        return payload.result;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/cjs/singleton.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NICK_FACTORY = exports.ERC2470_FACTORY = void 0;
+exports.recoverDeployment = recoverDeployment;
+const ethers_1 = require("ethers");
+/**
+ * Known CREATE2 singleton factories used across the Zodiac ecosystem. Both
+ * yield identical addresses on every chain, which is what makes mastercopy
+ * replication address-stable.
+ */
+exports.ERC2470_FACTORY = "0xce0042B868300000d44A59004Da54A005ffdcf9f";
+exports.NICK_FACTORY = "0x4e59b44847b379578588920cA78FbF26c0B4956C";
+const erc2470Interface = new ethers_1.Interface([
+    "function deploy(bytes _initCode, bytes32 _salt) returns (address)",
+]);
+/**
+ * Recover the init code and salt from a singleton-factory deployment
+ * transaction. Supports the ERC-2470 factory (an abi-encoded `deploy` call)
+ * and Nick's factory (raw `salt ++ initCode` calldata).
+ *
+ * Returns undefined when the transaction does not target a known factory, in
+ * which case the deployment cannot be replicated address-stably.
+ */
+function recoverDeployment({ to, input, }) {
+    const factory = to ? (0, ethers_1.getAddress)(to) : null;
+    if (factory === (0, ethers_1.getAddress)(exports.ERC2470_FACTORY)) {
+        try {
+            const [initCode, salt] = erc2470Interface.decodeFunctionData("deploy", input);
+            return { factory: exports.ERC2470_FACTORY, initCode: (0, ethers_1.hexlify)(initCode), salt };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (factory === (0, ethers_1.getAddress)(exports.NICK_FACTORY)) {
+        // Nick's factory: calldata is salt (32 bytes) followed by the init code.
+        const salt = (0, ethers_1.dataSlice)(input, 0, 32);
+        const initCode = (0, ethers_1.dataSlice)(input, 32);
+        return { factory: exports.NICK_FACTORY, initCode, salt };
+    }
+    return undefined;
+}

package/dist/cjs/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Artifacts written for a single asset (the main contract or a linked library)
+ * under `mastercopies/<module>/<version>/<asset>/`. Each field maps to one file:
+ * `abi.json`, `sourcecode.json`, `bytecode.json`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/ui.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUESTION = exports.CROSS = exports.CHECK = void 0;
+exports.color = color;
+exports.visibleLength = visibleLength;
+exports.formatRow = formatRow;
+exports.printTable = printTable;
+exports.renderProgress = renderProgress;
+exports.clearProgress = clearProgress;
+exports.showTransient = showTransient;
+exports.printStatusLine = printStatusLine;
+const readline_1 = require("readline");
+exports.CHECK = "✓";
+exports.CROSS = "✗";
+exports.QUESTION = "?";
+function color(value, colorName) {
+    const code = colorName === "green" ? 32 : colorName === "red" ? 31 : 33;
+    return `\u001b[${code}m${value}\u001b[0m`;
+}
+function visibleLength(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function formatRow(row, widths) {
+    return row
+        .map((value, index) => value + " ".repeat(widths[index] - visibleLength(value)))
+        .join("  ");
+}
+function printTable(headers, rows, caption) {
+    const body = rows.map((row) => [
+        row.network,
+        ...row.cells.map((c) => c.label),
+    ]);
+    const widths = headers.map((header, index) => Math.max(header.length, ...body.map((row) => visibleLength(row[index]))));
+    console.log(formatRow(headers, widths));
+    console.log(widths.map((width) => "-".repeat(width)).join("  "));
+    for (const row of body) {
+        console.log(formatRow(row, widths));
+    }
+    console.log();
+    console.log(caption.join("  "));
+}
+function renderProgress(completed, total, label = "Checking deployments") {
+    if (!process.stderr.isTTY)
+        return;
+    (0, readline_1.cursorTo)(process.stderr, 0);
+    process.stderr.write(`${label}: ${completed}/${total} requests`);
+}
+function clearProgress() {
+    if (!process.stderr.isTTY)
+        return;
+    (0, readline_1.cursorTo)(process.stderr, 0);
+    (0, readline_1.clearLine)(process.stderr, 0);
+}
+function showTransient(message) {
+    if (!process.stderr.isTTY)
+        return;
+    clearProgress();
+    (0, readline_1.cursorTo)(process.stderr, 0);
+    process.stderr.write(message);
+}
+function printStatusLine(message) {
+    clearProgress();
+    console.log(message);
+}

package/dist/cjs/zodiacModule.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZodiacModuleAbi = getZodiacModuleAbi;
+exports.getZodiacModuleAddress = getZodiacModuleAddress;
+exports.sanityCheckZodiacModuleAddress = sanityCheckZodiacModuleAddress;
+const semver_1 = require("semver");
+const index_js_1 = require("./abis/index.js");
+const contracts_js_1 = require("./contracts.js");
+function getZodiacModuleAbi(name, versionRange = "*") {
+    const versions = index_js_1.ABIs[name];
+    if (!versions) {
+        throw new Error(`No ABI registry for ${name}`);
+    }
+    const version = matchingVersion(versions, versionRange);
+    if (!version) {
+        throw new Error(`No ABI for ${name}@${versionRange}`);
+    }
+    const address = contracts_js_1.CanonicalAddresses[name]?.[version];
+    if (!address) {
+        throw new Error(`No address for ${name}@${version}`);
+    }
+    sanityCheckZodiacModuleAddress(address);
+    return versions[version];
+}
+function getZodiacModuleAddress(name, versionRange = "*") {
+    const versions = contracts_js_1.CanonicalAddresses[name];
+    if (!versions) {
+        throw new Error(`No address registry for ${name}`);
+    }
+    const version = matchingVersion(versions, versionRange, Boolean);
+    if (!version) {
+        throw new Error(`No address for ${name}@${versionRange}`);
+    }
+    sanityCheckZodiacModuleAddress(versions[version]);
+    return versions[version];
+}
+function sanityCheckZodiacModuleAddress(address) {
+    const normalizedAddress = address.toLowerCase();
+    const canonicalAddresses = flattenAddresses(contracts_js_1.CanonicalAddresses);
+    const faultyAddresses = flattenAddresses(contracts_js_1.FAULTY);
+    if (!canonicalAddresses.has(normalizedAddress)) {
+        throw new Error(`Unknown Zodiac module address: ${address}`);
+    }
+    if (faultyAddresses.has(normalizedAddress)) {
+        throw new Error(`Faulty Zodiac module address: ${address}`);
+    }
+}
+function matchingVersion(versions, versionRange, predicate = () => true) {
+    return Object.entries(versions)
+        .filter(([, value]) => predicate(value))
+        .map(([entry]) => entry)
+        .sort(semver_1.compare)
+        .reverse()
+        .find((entry) => (0, semver_1.satisfies)(entry, (0, semver_1.valid)(versionRange) ? `=${versionRange}` : versionRange));
+}
+function flattenAddresses(addresses) {
+    return new Set(Object.values(addresses)
+        .flatMap((versions) => Object.values(versions ?? {}))
+        .filter(Boolean)
+        .map((address) => address.toLowerCase()));
+}