@gnosis-guild/zodiac 4.2.1 → 5.0.0

package/dist/esm/contracts.js

@@ -0,0 +1,142 @@
+/**
+ * Known Zodiac contracts and their canonical mastercopy addresses.
+ *
+ * Canonical mastercopy addresses by `name@version`. Most are deployed through
+ * CREATE2 singleton factories, but the registry itself is pure address/name
+ * data — no ABIs, bytecode or typechain types (use `extract` to capture
+ * per-version artifacts into `mastercopies/`).
+ */
+export var KnownContracts;
+(function (KnownContracts) {
+    KnownContracts["META_GUARD"] = "metaGuard";
+    KnownContracts["OPTIMISTIC_GOVERNOR"] = "optimisticGovernor";
+    KnownContracts["TELLOR"] = "tellor";
+    KnownContracts["REALITY_ETH"] = "realityETH";
+    KnownContracts["REALITY_ERC20"] = "realityERC20";
+    KnownContracts["BRIDGE"] = "bridge";
+    KnownContracts["DELAY"] = "delay";
+    KnownContracts["EXIT_ERC20"] = "exit";
+    KnownContracts["EXIT_ERC721"] = "exitERC721";
+    KnownContracts["CIRCULATING_SUPPLY_ERC20"] = "circulatingSupplyERC20";
+    KnownContracts["CIRCULATING_SUPPLY_ERC721"] = "circulatingSupplyERC721";
+    KnownContracts["SCOPE_GUARD"] = "scopeGuard";
+    KnownContracts["FACTORY"] = "factory";
+    KnownContracts["ROLES"] = "roles";
+    KnownContracts["ROLES_V1"] = "roles";
+    KnownContracts["ROLES_V2"] = "roles";
+    KnownContracts["OZ_GOVERNOR"] = "ozGovernor";
+    KnownContracts["ERC20_VOTES"] = "erc20Votes";
+    KnownContracts["ERC721_VOTES"] = "erc721Votes";
+    KnownContracts["MULTISEND_ENCODER"] = "multisendEncoder";
+    KnownContracts["CONNEXT"] = "connext";
+})(KnownContracts || (KnownContracts = {}));
+export const SupportedNetworks = Object.freeze({
+    MAINNET: 1,
+    OPTIMISM: 10,
+    FLARE: 14,
+    BSC: 56,
+    BNB: 56,
+    GNOSIS: 100,
+    UNICHAIN: 130,
+    POLYGON: 137,
+    SONIC: 146,
+    WORLDCHAIN: 480,
+    HYPEREVM: 999,
+    MEGAETH: 4326,
+    MANTLE: 5000,
+    BASE: 8453,
+    PLASMA: 9745,
+    ARBITRUM: 42161,
+    CELO: 42220,
+    AVALANCHE: 43114,
+    INK: 57073,
+    LINEA: 59144,
+    BOB: 60808,
+    BERACHAIN: 80094,
+    SCROLL: 534352,
+    KATANA: 747474,
+    SEPOLIA: 11155111,
+});
+/** Canonical mastercopy address for each known contract, by version. */
+export const CanonicalAddresses = {
+    [KnownContracts.META_GUARD]: {
+        "1.0.0": "0xe2847462a574bfd43014d1c7BB6De5769C294691",
+    },
+    [KnownContracts.REALITY_ETH]: {
+        "2.0.0": "0x4e35DA39Fa5893a70A40Ce964F993d891E607cC0",
+    },
+    [KnownContracts.REALITY_ERC20]: {
+        "2.0.0": "0x7276813b21623d89BA8984B225d5792943DD7dbF",
+    },
+    [KnownContracts.BRIDGE]: {
+        "1.0.0": "0x03B5eBD2CB2e3339E93774A1Eb7c8634B8C393A9",
+    },
+    [KnownContracts.DELAY]: {
+        "1.0.0": "0xD62129BF40CD1694b3d9D9847367783a1A4d5cB4",
+        "1.0.1": "0xd54895B1121A2eE3f37b502F507631FA1331BED6",
+        "1.1.0": "0x01F8cabB808D7dE0dF4202D4B60C8310d2f1339b",
+        "1.1.1": "0x824175b945838d127c1ca83cbce11d8e44f6df01",
+    },
+    [KnownContracts.FACTORY]: {
+        "1.0.0": "0x00000000062c52e29e8029dc2413172f6d619d85",
+        "1.1.0": "0x00000000000DC7F163742Eb4aBEf650037b1f588",
+        "1.2.0": "0x000000000000aDdB49795b0f9bA5BC298cDda236",
+    },
+    [KnownContracts.EXIT_ERC20]: {
+        "1.0.0": "0x35E35dcDc7Cd112B93C7c55987C86e5D6D419C69",
+        "1.1.0": "0x33bCa41bda8A3983afbAd8fc8936Ce2Fb29121da",
+        "1.2.0": "0x3ed380a282aDfA3460da28560ebEB2F6D967C9f5",
+    },
+    [KnownContracts.EXIT_ERC721]: {
+        "1.1.0": "0xD3579C14a4181EfC3DF35C3103D20823A8C8d718",
+        "1.2.0": "0xE0eCE32Eb4BE4E9224dcec6a4FcB335c1fe05CDe",
+    },
+    [KnownContracts.CIRCULATING_SUPPLY_ERC20]: {
+        "1.0.0": "0xd7a85e7D0813F8440602E243Acb67df3CCeb5a60",
+        "1.1.0": "0xb50fab2e2892E3323A5300870C042B428B564FE3",
+        "1.2.0": "0x5Ed57C291a184cc244F5c9B5E9F11a8DD08BBd12",
+    },
+    [KnownContracts.CIRCULATING_SUPPLY_ERC721]: {
+        "1.1.0": "0x71530ec830CBE363bab28F4EC52964a550C0AB1E",
+        "1.2.0": "0xBD34D00dC0ae37C687F784A11FA6a0F2c5726Ba3",
+    },
+    [KnownContracts.SCOPE_GUARD]: {
+        "1.0.0": "0xeF27fcd3965a866b22Fb2d7C689De9AB7e611f1F",
+    },
+    [KnownContracts.ROLES]: {
+        "1.0.0": "0x85388a8cd772b19a468F982Dc264C238856939C9",
+        "1.1.0": "0xD8DfC1d938D7D163C5231688341e9635E9011889",
+        "2.1.0": "0x9646fDAD06d3e24444381f44362a3B0eB343D337",
+        "2.1.1": "0xf2964ce6161ce0e75964fe7927ce114cb0b283d5",
+    },
+    [KnownContracts.TELLOR]: {
+        "2.1.0": "0xa89EC2C1e218CfBb0F82829E95352CeAbDEe9A69",
+    },
+    [KnownContracts.OPTIMISTIC_GOVERNOR]: {
+        "1.0.0": "",
+        "1.2.0": "0x28CeBFE94a03DbCA9d17143e9d2Bd1155DC26D5d",
+    },
+    [KnownContracts.OZ_GOVERNOR]: {
+        "1.0.0": "0xe28c39FAC73cce2B33C4C003049e2F3AE43f77d5",
+    },
+    [KnownContracts.ERC20_VOTES]: {
+        "1.0.0": "0x752c61de75ADA0F8a33e048d2F773f51172f033e",
+    },
+    [KnownContracts.ERC721_VOTES]: {
+        "1.0.0": "0xeFf38b2eBB95ACBA09761246045743f40e762568",
+    },
+    [KnownContracts.MULTISEND_ENCODER]: {
+        "1.0.0": "0xb67EDe523171325345780fA3016b7F5221293df0",
+    },
+    [KnownContracts.CONNEXT]: {
+        "1.0.0": "0x7dE07b9De0bf0FABf31A188DE1527034b2aF36dB",
+    },
+};
+export const FAULTY = {
+    [KnownContracts.DELAY]: {
+        "1.1.0": "0x01F8cabB808D7dE0dF4202D4B60C8310d2f1339b",
+    },
+    [KnownContracts.ROLES]: {
+        "2.1.0": "0x9646fDAD06d3e24444381f44362a3B0eB343D337",
+    },
+};

package/dist/esm/explorer.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Minimal Etherscan-compatible explorer client.
+ *
+ * Everything `extract` needs is reachable through the explorer:
+ *  - `getsourcecode`     -> verified source, ABI, compiler input, constructor args
+ *  - `getcontractcreation` -> the deployment transaction hash
+ *  - `eth_getTransactionByHash` (proxy module) -> the raw deployment calldata
+ *
+ * so no separate JSON-RPC endpoint is required for extraction.
+ */
+export interface SourceCode {
+    contractName: string;
+    sourceName: string;
+    compilerVersion: string;
+    compilerInput: any;
+    abi: any;
+    /** abi-encoded constructor arguments (hex, no leading 0x). */
+    constructorArguments: string;
+}
+export interface ContractCreation {
+    txHash?: string;
+    creationBytecode?: string;
+}
+export interface VerificationRequest {
+    address: string;
+    network: string | number;
+    sourceCode: string;
+    contractName: string;
+    compilerVersion: string;
+    constructorArguments?: string;
+    evmVersion?: string;
+    licenseType?: string;
+    apiKey?: string;
+}
+/**
+ * Fetch verified source, ABI and compiler input for a deployed contract.
+ */
+export declare function getSourceCode({ address, network, apiKey, }: {
+    address: string;
+    network: string | number;
+    apiKey?: string;
+}): Promise<SourceCode>;
+/**
+ * Get creation metadata (tx hash and bytecode) for a contract.
+ */
+export declare function getContractCreation({ address, network, apiKey, }: {
+    address: string;
+    network: string | number;
+    apiKey?: string;
+}): Promise<ContractCreation | undefined>;
+/**
+ * Fetch a transaction (input + to) via the explorer's proxy module.
+ */
+export declare function getTransaction({ txHash, network, apiKey, }: {
+    txHash: string;
+    network: string | number;
+    apiKey?: string;
+}): Promise<{
+    to: string | null;
+    input: string;
+} | undefined>;
+/**
+ * Fetch the deployed (runtime) bytecode at an address via the proxy module.
+ */
+export declare function getCode({ address, network, apiKey, }: {
+    address: string;
+    network: string | number;
+    apiKey?: string;
+}): Promise<string>;
+/**
+ * Submit standard-JSON Solidity source for verification.
+ */
+export declare function verifySourceCode({ address, network, sourceCode, contractName, compilerVersion, constructorArguments, evmVersion, licenseType, apiKey, }: VerificationRequest): Promise<string>;
+/**
+ * Check the async source verification status for a submitted GUID.
+ */
+export declare function checkVerificationStatus({ guid, network, apiKey, }: {
+    guid: string;
+    network: string | number;
+    apiKey?: string;
+}): Promise<string>;

package/dist/esm/explorer.js

@@ -0,0 +1,256 @@
+import { resolveNetwork } from "./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 = 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 = 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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/esm/extract.d.ts

@@ -0,0 +1,15 @@
+import { Asset } from "./types.js";
+/**
+ * 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.
+ */
+export declare function extract({ network, address, apiKey, }: {
+    network: string | number;
+    address: string;
+    apiKey?: string;
+}): Promise<Map<string, Asset>>;

package/dist/esm/extract.js

@@ -0,0 +1,114 @@
+import { getAddress } from "ethers";
+import { predictSingletonAddress } from "@gnosis-guild/zodiac-core";
+import { resolveNetwork } from "./networks.js";
+import { getCode, getContractCreation, getSourceCode, getTransaction, } from "./explorer.js";
+import { recoverDeployment } from "./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.
+ */
+export async function extract({ network, address, apiKey, }) {
+    const net = 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 = getAddress(address).toLowerCase();
+    const existing = visited.get(key);
+    if (existing)
+        return existing;
+    const source = await getSourceCode({ address, network: networkName, apiKey });
+    const name = nameHint || source.contractName;
+    const creation = await getContractCreation({
+        address,
+        network: networkName,
+        apiKey,
+    });
+    const tx = creation?.txHash
+        ? await getTransaction({
+            txHash: creation.txHash,
+            network: networkName,
+            apiKey,
+        })
+        : undefined;
+    const recovered = tx && 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 = 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 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/esm/index.d.ts

@@ -0,0 +1,3 @@
+export { encodeDeployProxy, encodeDeploySingleton, predictProxyAddress, predictSingletonAddress, } from "@gnosis-guild/zodiac-core";
+export { CanonicalAddresses, KnownContracts, SupportedNetworks, } from "./contracts.js";
+export { getZodiacModuleAbi, getZodiacModuleAddress, sanityCheckZodiacModuleAddress, } from "./zodiacModule.js";

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export { encodeDeployProxy, encodeDeploySingleton, predictProxyAddress, predictSingletonAddress, } from "@gnosis-guild/zodiac-core";
+export { CanonicalAddresses, KnownContracts, SupportedNetworks, } from "./contracts.js";
+export { getZodiacModuleAbi, getZodiacModuleAddress, sanityCheckZodiacModuleAddress, } from "./zodiacModule.js";

package/dist/esm/mastercopies.d.ts

@@ -0,0 +1,21 @@
+import { Asset } from "./types.js";
+/**
+ * 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.
+ */
+export declare function defaultMastercopiesDir(): string;
+/**
+ * Write one asset's three files, creating directories as needed.
+ * Returns the asset directory.
+ */
+export declare function writeAsset({ module, version, asset, mastercopiesDir, }: {
+    module: string;
+    version: string;
+    asset: Asset;
+    mastercopiesDir?: string;
+}): string;

package/dist/esm/mastercopies.js

@@ -0,0 +1,27 @@
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
+import { cwd } from "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.
+ */
+export function defaultMastercopiesDir() {
+    return path.join(cwd(), "mastercopies");
+}
+/**
+ * Write one asset's three files, creating directories as needed.
+ * Returns the asset directory.
+ */
+export function writeAsset({ module, version, asset, mastercopiesDir = defaultMastercopiesDir(), }) {
+    const dir = path.join(mastercopiesDir, module, version, asset.name);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path.join(dir, "abi.json"), JSON.stringify(asset.abi, null, 2), "utf8");
+    writeFileSync(path.join(dir, "sourcecode.json"), JSON.stringify(asset.sourceCode, null, 2), "utf8");
+    writeFileSync(path.join(dir, "bytecode.json"), JSON.stringify(asset.bytecode, null, 2), "utf8");
+    return dir;
+}