@rhinestone/shared-configs 1.4.63 → 1.4.65

package/dist/configs/providers.json

@@ -0,0 +1,69 @@
+{
+    "Alchemy": {
+        "chain_mapping": {
+            "1": "eth-mainnet",
+            "10": "opt-mainnet",
+            "100": "gnosis-mainnet",
+            "137": "polygon-mainnet",
+            "146": "sonic-mainnet",
+            "1868": "soneium-mainnet",
+            "8453": "base-mainnet",
+            "9745": "plasma-mainnet",
+            "9746": "plasma-testnet",
+            "42161": "arb-mainnet",
+            "84532": "base-sepolia",
+            "421614": "arb-sepolia",
+            "11155111": "eth-sepolia",
+            "11155420": "opt-sepolia"
+        },
+        "url_template": "https://{{chain_param}}.g.alchemy.com/v2/${ALCHEMY_API_KEY}"
+    },
+    "DRPC": {
+        "chain_mapping": {
+            "1": "ethereum",
+            "10": "optimism",
+            "100": "gnosis",
+            "137": "polygon",
+            "146": "sonic",
+            "1868": "soneium",
+            "8453": "base",
+            "9745": "plasma",
+            "9746": "plasma-testnet",
+            "42161": "arbitrum",
+            "84532": "base-sepolia",
+            "421614": "arbitrum-sepolia",
+            "11155111": "sepolia",
+            "11155420": "optimism-sepolia"
+        },
+        "url_template": "https://lb.drpc.org/ogrpc?network={{chain_param}}&dkey=${DRPC_API_KEY}"
+    },
+    "eRPC": {
+        "chain_mapping": {
+            "1": "1",
+            "10": "10",
+            "100": "100",
+            "137": "137",
+            "146": "146",
+            "1868": "1868",
+            "8453": "8453",
+            "9745": "9745",
+            "9746": "9746",
+            "42161": "42161",
+            "84532": "84532",
+            "421614": "421614",
+            "11155111": "11155111",
+            "11155420": "11155420"
+        },
+        "url_template": "https://v1.orchestrator.rhinestone.dev/rpc-proxy/main/evm/{{chain_param}}"
+    },
+    "local-rpc": {
+        "chain_mapping": {
+            "1": "30001",
+            "137": "30004",
+            "146": "30005",
+            "8453": "30003",
+            "42161": "30002"
+        },
+        "url_template": "http://localhost:{{chain_param}}"
+    }
+}

package/dist/configs/testnets.json

@@ -0,0 +1,27 @@
+{
+    "9746": {
+        "providers": [
+            "Alchemy"
+        ]
+    },
+    "84532": {
+        "providers": [
+            "DRPC"
+        ]
+    },
+    "421614": {
+        "providers": [
+            "DRPC"
+        ]
+    },
+    "11155111": {
+        "providers": [
+            "DRPC"
+        ]
+    },
+    "11155420": {
+        "providers": [
+            "DRPC"
+        ]
+    }
+}

package/dist/scripts/generate-abis.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-abis.d.ts.map

package/dist/scripts/generate-abis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-abis.d.ts","sourceRoot":"","sources":["../../scripts/generate-abis.ts"],"names":[],"mappings":""}

package/dist/scripts/generate-abis.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const ABIS_SOURCE_DIR = node_path_1.default.join(process.cwd(), "abis-source");
+const ABIS_OUTPUT_DIR = node_path_1.default.join(process.cwd(), "src", "abis");
+const ABI_CONFIGS = [
+    {
+        outputFile: "orchestrator.ts",
+        comment: "Auto-generated from orchestrator ABIs. Do not edit manually.",
+        abis: [
+            { name: "routerAbi", sourceFile: "router.json" },
+            { name: "routerHelperAbi", sourceFile: "routerHelper.json" },
+            { name: "emissaryAbi", sourceFile: "emissary.json" },
+            { name: "intentExecutorAbi", sourceFile: "intentExecutor.json" },
+            { name: "acrossAdapterAbi", sourceFile: "acrossAdapter.json" },
+            { name: "ecoAdapterAbi", sourceFile: "ecoAdapter.json" },
+            { name: "relayAdapterAbi", sourceFile: "relayAdapter.json" },
+            { name: "sameChainAdapterAbi", sourceFile: "sameChainAdapter.json" },
+            { name: "intentExecutorAdapterAbi", sourceFile: "intentExecutorAdapter.json" },
+            { name: "multicallAbi", sourceFile: "multicall.json" },
+            { name: "multicallHandlerAbi", sourceFile: "multicallHandler.json" },
+            { name: "acrossAdapterOptimizedAbi", sourceFile: "acrossAdapterOptimized.json", satisfiesAbi: false },
+            { name: "routeTupleAbi", sourceFile: "routeTuple.json", satisfiesAbi: false },
+            { name: "rewardTupleAbi", sourceFile: "rewardTuple.json", satisfiesAbi: false },
+            { name: "ecoAdapterOptimizedAbi", sourceFile: "ecoAdapterOptimized.json", satisfiesAbi: false },
+            { name: "relayAdapterOptimizedAbi", sourceFile: "relayAdapterOptimized.json", satisfiesAbi: false },
+        ],
+    },
+    {
+        outputFile: "relayer.ts",
+        comment: "Auto-generated from relayer ABIs. Do not edit manually.",
+        abis: [
+            { name: "relayerPotV1Abi", sourceFile: "relayerPotV1.json" },
+            { name: "wethAbi", sourceFile: "weth.json" },
+            { name: "singleCallAbi", sourceFile: "singleCall.json" },
+            { name: "multiCallAbi", sourceFile: "relayerMultiCall.json" },
+            { name: "directRouteAbi", sourceFile: "directRoute.json" },
+        ],
+    },
+];
+function formatAbiAsTypeScript(abi) {
+    const json = JSON.stringify(abi, null, 2);
+    return json.replace(/"([^"]+)":/g, "$1:").replace(/"/g, "'");
+}
+function generateAbiFile(config) {
+    const lines = [
+        `// ${config.comment}`,
+        'import type { Abi } from "viem";',
+        "",
+    ];
+    for (const abiDef of config.abis) {
+        const sourceFile = node_path_1.default.join(ABIS_SOURCE_DIR, abiDef.sourceFile);
+        if (!(0, node_fs_1.existsSync)(sourceFile)) {
+            console.warn(`Warning: Source file not found: ${sourceFile}`);
+            continue;
+        }
+        const abiJson = JSON.parse((0, node_fs_1.readFileSync)(sourceFile, "utf8"));
+        const abi = Array.isArray(abiJson) ? abiJson : abiJson.abi;
+        if (!abi) {
+            console.warn(`Warning: No ABI found in ${sourceFile}`);
+            continue;
+        }
+        const formattedAbi = formatAbiAsTypeScript(abi);
+        const typeAnnotation = abiDef.satisfiesAbi === false ? "as const" : "as const satisfies Abi";
+        lines.push(`export const ${abiDef.name} = ${formattedAbi} ${typeAnnotation};`);
+        lines.push("");
+    }
+    const outputFile = node_path_1.default.join(ABIS_OUTPUT_DIR, config.outputFile);
+    (0, node_fs_1.writeFileSync)(outputFile, lines.join("\n"));
+    console.log(`Generated: ${outputFile}`);
+}
+function extractExistingAbis() {
+    console.log("Extracting existing ABIs to JSON source files...");
+    if (!(0, node_fs_1.existsSync)(ABIS_SOURCE_DIR)) {
+        (0, node_fs_1.mkdirSync)(ABIS_SOURCE_DIR, { recursive: true });
+    }
+    for (const config of ABI_CONFIGS) {
+        const sourceFile = node_path_1.default.join(ABIS_OUTPUT_DIR, config.outputFile);
+        if (!(0, node_fs_1.existsSync)(sourceFile)) {
+            console.warn(`Source TypeScript file not found: ${sourceFile}`);
+            continue;
+        }
+        const content = (0, node_fs_1.readFileSync)(sourceFile, "utf8");
+        for (const abiDef of config.abis) {
+            let startPattern = `export const ${abiDef.name}= [`;
+            let startIndex = content.indexOf(startPattern);
+            let prefixLen = `export const ${abiDef.name}= `.length;
+            if (startIndex === -1) {
+                startPattern = `export const ${abiDef.name} = [`;
+                startIndex = content.indexOf(startPattern);
+                prefixLen = `export const ${abiDef.name} = `.length;
+            }
+            if (startIndex === -1) {
+                console.warn(`Could not find ${abiDef.name} in ${config.outputFile}`);
+                continue;
+            }
+            const arrayStart = startIndex + prefixLen;
+            let depth = 0;
+            let endIndex = arrayStart;
+            for (let i = arrayStart; i < content.length; i++) {
+                const char = content[i];
+                if (char === "[" || char === "{")
+                    depth++;
+                else if (char === "]" || char === "}") {
+                    depth--;
+                    if (depth === 0) {
+                        endIndex = i + 1;
+                        break;
+                    }
+                }
+            }
+            const abiStr = content.slice(arrayStart, endIndex);
+            try {
+                const jsonStr = abiStr
+                    .replace(/'/g, '"')
+                    .replace(/(\w+):/g, '"$1":')
+                    .replace(/,(\s*[}\]])/g, "$1");
+                const abi = JSON.parse(jsonStr);
+                const outputPath = node_path_1.default.join(ABIS_SOURCE_DIR, abiDef.sourceFile);
+                (0, node_fs_1.writeFileSync)(outputPath, JSON.stringify(abi, null, 2));
+                console.log(`Extracted: ${abiDef.name} -> ${abiDef.sourceFile}`);
+            }
+            catch (e) {
+                console.error(`Failed to extract ${abiDef.name}:`, e);
+            }
+        }
+    }
+}
+function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--extract")) {
+        extractExistingAbis();
+        return;
+    }
+    if (!(0, node_fs_1.existsSync)(ABIS_SOURCE_DIR)) {
+        console.error(`Error: ABI source directory not found: ${ABIS_SOURCE_DIR}`);
+        console.log("Run with --extract first to create source files from existing ABIs.");
+        process.exit(1);
+    }
+    console.log("Generating ABI TypeScript files...");
+    for (const config of ABI_CONFIGS) {
+        generateAbiFile(config);
+    }
+    console.log("Done!");
+}
+main();

package/dist/scripts/generate.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate.d.ts.map

package/dist/scripts/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../scripts/generate.ts"],"names":[],"mappings":""}

package/dist/scripts/generate.js

@@ -0,0 +1,371 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+function renderNetworkEnum(name, entries) {
+    const lines = entries.map((entry) => `  ${entry.enumKey} = ${entry.viemChain}.id,`);
+    return `enum ${name} {\n${lines.join("\n")}\n}\n`;
+}
+function renderNetworks(networks) {
+    const imports = [];
+    const seen = new Set();
+    const addImport = (name) => {
+        if (!seen.has(name)) {
+            seen.add(name);
+            imports.push(name);
+        }
+    };
+    for (const entry of [...networks.mainnets, ...networks.testnets]) {
+        addImport(entry.viemChain);
+    }
+    const mainnetChains = networks.mainnets.map((entry) => entry.viemChain);
+    const testnetChains = networks.testnets.map((entry) => entry.viemChain);
+    const opStackLines = [];
+    for (const entry of networks.mainnets) {
+        if (entry.opStackKey) {
+            opStackLines.push(`  MAINNET_${entry.opStackKey} = ${entry.viemChain}.id,`);
+        }
+    }
+    for (const entry of networks.testnets) {
+        if (entry.opStackKey) {
+            opStackLines.push(`  TESTNET_${entry.opStackKey} = ${entry.viemChain}.id,`);
+        }
+    }
+    return [
+        "// Auto-generated by scripts/generate.ts. Do not edit manually.",
+        "import {",
+        ...imports.map((name) => `  ${name},`),
+        '} from "viem/chains";',
+        "",
+        `const mainnetChains = [${mainnetChains.join(", ")}];`,
+        `const testnetChains = [${testnetChains.join(", ")}];`,
+        "const chains = [...mainnetChains, ...testnetChains];",
+        "",
+        renderNetworkEnum("MainnetNetwork", networks.mainnets).trimEnd(),
+        "",
+        renderNetworkEnum("TestnetNetwork", networks.testnets).trimEnd(),
+        "",
+        `enum OPStackChains {\n${opStackLines.join("\n")}\n}\n`.trimEnd(),
+        "",
+        "export {",
+        "  mainnetChains,",
+        "  testnetChains,",
+        "  chains,",
+        "  MainnetNetwork,",
+        "  TestnetNetwork,",
+        "  OPStackChains,",
+        "};",
+    ].join("\n");
+}
+function renderChains(chainRegistry, mainnets, testnets) {
+    const providersByChain = {
+        ...mainnets,
+        ...testnets,
+    };
+    const chains = {};
+    for (const [chainId, chainCfg] of Object.entries(chainRegistry)) {
+        const providers = providersByChain[chainId]?.providers ?? [];
+        chains[chainId] = {
+            ...chainCfg,
+            providers,
+        };
+    }
+    return [
+        "// Auto-generated by scripts/generate.ts. Do not edit manually.",
+        'import type { Address } from "viem";',
+        'import type { ProviderName, SettlementLayer, SupportedChain, SwapQuoter } from "./types";',
+        "",
+        "interface Token {",
+        "  address: Address;",
+        "  symbol?: string;",
+        "  decimals?: number;",
+        "  priceSymbol?: string;",
+        "  balanceSlot: number | null;",
+        "  approvalSlot: number | null;",
+        "}",
+        "",
+        "interface NativeToken {",
+        "  address: Address;",
+        "  symbol: string;",
+        "  decimals: number;",
+        "}",
+        "",
+        "interface Chain {",
+        "  name: string;",
+        "  nativeToken: NativeToken;",
+        "  wrappedNativeToken: NativeToken;",
+        "  tokens: Token[];",
+        "  settlementLayers: SettlementLayer[];",
+        "  providers: ProviderName[];",
+        "  swapQuoters: SwapQuoter[];",
+        "}",
+        "",
+        `const chains: Record<SupportedChain, Chain> = ${JSON.stringify(chains, null, 2)};`,
+        "",
+        "export { chains };",
+        "export type { Chain, Token, NativeToken };",
+    ].join("\n");
+}
+function runJsonnet(yeetRoot) {
+    const jsonnetFile = node_path_1.default.join("config", "shared-configs.jsonnet");
+    const jsonnetEth = node_path_1.default.join(yeetRoot, "bin", "jsonnet-eth");
+    let output = "";
+    if ((0, node_fs_1.existsSync)(jsonnetEth)) {
+        output = (0, node_child_process_1.execFileSync)(jsonnetEth, [jsonnetFile], {
+            cwd: yeetRoot,
+            encoding: "utf8",
+        });
+    }
+    else {
+        output = (0, node_child_process_1.execFileSync)("go", ["run", "./cmd/jsonnet-eth", jsonnetFile], {
+            cwd: yeetRoot,
+            encoding: "utf8",
+        });
+    }
+    return JSON.parse(output);
+}
+const compactObject = (values) => {
+    return Object.fromEntries(Object.entries(values).filter((entry) => entry[1] !== undefined));
+};
+const collectNullKeys = (values) => Object.keys(values).filter((key) => values[key] === null);
+const stripNulls = (values) => Object.fromEntries(Object.entries(values).filter(([, value]) => value !== null));
+const applyOverrides = (base, overrideWildcard, override) => {
+    const merged = {
+        ...base,
+        ...stripNulls(overrideWildcard),
+        ...stripNulls(override),
+    };
+    for (const key of [
+        ...collectNullKeys(overrideWildcard),
+        ...collectNullKeys(override),
+    ]) {
+        delete merged[key];
+    }
+    return merged;
+};
+const mergeContracts = (base, overrides) => {
+    const merged = {};
+    const overrideWildcard = overrides["*"] ?? {};
+    for (const [chainId, entries] of Object.entries(base)) {
+        if (chainId === "*") {
+            continue;
+        }
+        merged[chainId] = applyOverrides(entries, overrideWildcard, overrides[chainId] ?? {});
+    }
+    for (const [chainId, entries] of Object.entries(overrides)) {
+        if (chainId === "*") {
+            continue;
+        }
+        if (!merged[chainId]) {
+            merged[chainId] = applyOverrides({}, overrideWildcard, entries);
+        }
+    }
+    const baseWildcard = base["*"] ?? {};
+    if (Object.keys(baseWildcard).length > 0 ||
+        Object.keys(overrideWildcard).length > 0) {
+        merged["*"] = applyOverrides(baseWildcard, overrideWildcard, {});
+    }
+    return merged;
+};
+const loadContractOverrides = (sharedConfigsRoot) => {
+    const overridesPath = node_path_1.default.join(sharedConfigsRoot, "src", "contracts.overrides.json");
+    if (!(0, node_fs_1.existsSync)(overridesPath)) {
+        return {};
+    }
+    const raw = (0, node_fs_1.readFileSync)(overridesPath, "utf8");
+    return JSON.parse(raw);
+};
+const mapWildcardDeployments = (deployments) => {
+    return compactObject({
+        addressBook: deployments.addressBook,
+        allocator: deployments.allocator,
+        caller: deployments.caller,
+        multiCaller: deployments.caller,
+        emissary: deployments.emissary,
+        emissaryImpl: deployments.emissaryImpl,
+        intentExecutor: deployments.intentExecutor,
+        intentExecutorImpl: deployments.intentExecutorImpl,
+        intentExecutorAdapter: deployments.intentExecutorAdapter,
+        intentExecutorAdapterGasRefund: deployments.intentExecutorAdapterGasRefund,
+        multicallAdapter: deployments.multicallAdapter,
+        multicallHandler: deployments.multicallHandler,
+        ecoHandler: deployments.multicallHandler,
+        paymaster: deployments.paymaster,
+        relayerPot: deployments.relayerPotV0AndV1 ?? deployments.relayerPot,
+        router: deployments.router,
+        routerImpl: deployments.routerImpl,
+        samechainArbiter: deployments.samechain,
+        samechainAdapter: deployments.samechainAdapterArbiterImpl,
+        smartSessionEmissary: deployments.smartSessionEmissary,
+        smartSessionLens: deployments.smartSessionLens,
+    });
+};
+const mapChainDeployments = (deployments, external) => {
+    return compactObject({
+        acrossHandler: deployments.acrossHandler,
+        across7579Arbiter: deployments.acrossWith7579,
+        acrossMulticallArbiter: deployments.acrossWithMulticall,
+        relayerPot: deployments.relayerPotV0AndV1 ?? deployments.relayerPot,
+        ecoArbiter: deployments.ecoAdapter,
+        emissary: deployments.emissary,
+        intentExecutor: deployments.intentExecutor,
+        intentExecutorAdapter: deployments.intentExecutorAdapter,
+        paymaster: deployments.paymaster,
+        relayArbiter: deployments.relayAdapter,
+        samechainArbiter: deployments.samechain,
+        samechainAdapter: deployments.samechainAdapterArbiterImpl,
+        acrossBridge: external?.across?.spokepool,
+        spokepool: external?.across?.spokepool,
+        ecoPortal: external?.eco?.portal,
+        ecoHyperProver: external?.eco?.hyperProver,
+        ecoVaultAddress: external?.eco?.vault,
+        relayReceiver: external?.relay?.receiver,
+        relaySolver: external?.relay?.solver,
+        compact: external?.contracts?.compact,
+        permit2: external?.contracts?.permit2,
+        feeCollector: external?.contracts?.feeCollector,
+    });
+};
+function collectContracts(addrConfig) {
+    const merged = {};
+    const wildcardDeployments = addrConfig["*"]?.deployments ?? {};
+    const wildcardMapped = mapWildcardDeployments(wildcardDeployments);
+    if (Object.keys(wildcardMapped).length > 0) {
+        merged["*"] = wildcardMapped;
+    }
+    for (const [chainId, entry] of Object.entries(addrConfig)) {
+        if (chainId === "*")
+            continue;
+        const deployments = entry.deployments ?? {};
+        const mapped = mapChainDeployments(deployments, entry.external);
+        if (Object.keys(mapped).length > 0) {
+            merged[chainId] = mapped;
+        }
+    }
+    return merged;
+}
+function renderContracts(contracts) {
+    return [
+        "// Auto-generated by scripts/generate.ts. Do not edit manually.",
+        'import type { Address } from "viem";',
+        "",
+        "type ContractAddresses = Record<string, Record<string, Address>>;",
+        `const contractAddresses: ContractAddresses = ${JSON.stringify(contracts, null, 2)};`,
+        "",
+        "export { contractAddresses };",
+        "export type { ContractAddresses };",
+    ].join("\n");
+}
+const SHARED_CHAIN_NAMES = [
+    "mainnet",
+    "optimism",
+    "base",
+    "arbitrum",
+    "polygon",
+    "soneium",
+    "sonic",
+    "plasma",
+    "gnosis",
+    "sepolia",
+    "optimism_sepolia",
+    "base_sepolia",
+    "arbitrum_sepolia",
+    "plasma_testnet",
+];
+function runOrchestratorFile(yeetRoot, env) {
+    const recipe = node_path_1.default.join("core", "shared-configs.jsonnet");
+    const binary = node_path_1.default.join(yeetRoot, "bin", "yeet-orchestrator-file");
+    const useBinary = process.env.YEET_USE_BINARY === "1";
+    const tempDir = (0, node_fs_1.mkdtempSync)(node_path_1.default.join(node_os_1.default.tmpdir(), "yeet-shared-configs-"));
+    const chainsFile = node_path_1.default.join(tempDir, "chains.txt");
+    (0, node_fs_1.writeFileSync)(chainsFile, `${SHARED_CHAIN_NAMES.join("\n")}\n`);
+    const args = [
+        "--recipe",
+        recipe,
+        "--chains-from-file",
+        chainsFile,
+        "--dedup",
+        "--env",
+        env,
+        "--codegen",
+    ];
+    try {
+        const output = useBinary && (0, node_fs_1.existsSync)(binary)
+            ? (0, node_child_process_1.execFileSync)(binary, args, { cwd: yeetRoot, encoding: "utf8" })
+            : (0, node_child_process_1.execFileSync)("go", ["run", "./cmd/yeet-orchestrator-file", ...args], {
+                cwd: yeetRoot,
+                encoding: "utf8",
+            });
+        return JSON.parse(output);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(tempDir, { force: true, recursive: true });
+    }
+}
+function collectAbiSignatures(addrConfig) {
+    const merged = {};
+    const wildcardAbis = addrConfig["*"]?.abis ?? {};
+    Object.assign(merged, wildcardAbis);
+    for (const [chainId, entry] of Object.entries(addrConfig)) {
+        if (chainId === "*")
+            continue;
+        if (!entry.abis)
+            continue;
+        for (const [name, abi] of Object.entries(entry.abis)) {
+            if (!merged[name]) {
+                merged[name] = abi;
+            }
+        }
+    }
+    return merged;
+}
+function renderAbiSignatures(abis) {
+    const ordered = Object.fromEntries(Object.keys(abis)
+        .sort()
+        .map((key) => [key, abis[key]]));
+    return [
+        "// Auto-generated by scripts/generate.ts. Do not edit manually.",
+        `const abiSignatures = ${JSON.stringify(ordered, null, 2)} as const;`,
+        "",
+        "export { abiSignatures };",
+        "export type AbiSignatureMap = typeof abiSignatures;",
+    ].join("\n");
+}
+async function generate() {
+    const sharedConfigsRoot = node_path_1.default.resolve(process.cwd());
+    const yeetRoot = node_path_1.default.resolve(sharedConfigsRoot, "..");
+    const configsDir = node_path_1.default.join(sharedConfigsRoot, "configs");
+    const generatedDir = node_path_1.default.join(sharedConfigsRoot, "src", "generated");
+    const output = runJsonnet(yeetRoot);
+    await (0, promises_1.mkdir)(configsDir, { recursive: true });
+    await (0, promises_1.mkdir)(generatedDir, { recursive: true });
+    await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "chains.json"), `${JSON.stringify(output.chains, null, 2)}\n`);
+    await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "mainnets.json"), `${JSON.stringify(output.mainnets, null, 2)}\n`);
+    await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "testnets.json"), `${JSON.stringify(output.testnets, null, 2)}\n`);
+    await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "providers.json"), `${JSON.stringify(output.providers, null, 2)}\n`);
+    await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "oft.json"), `${JSON.stringify(output.oft, null, 2)}\n`);
+    await (0, promises_1.writeFile)(node_path_1.default.join(sharedConfigsRoot, "src", "chains.ts"), `${renderChains(output.chains, output.mainnets, output.testnets)}\n`);
+    await (0, promises_1.writeFile)(node_path_1.default.join(generatedDir, "networks.ts"), `${renderNetworks(output.networks)}\n`);
+    const prodAddrConfig = runOrchestratorFile(yeetRoot, "prod");
+    const stagingAddrConfig = runOrchestratorFile(yeetRoot, "staging");
+    const abiSignatures = collectAbiSignatures(prodAddrConfig);
+    const prodContracts = collectContracts(prodAddrConfig);
+    const stagingContracts = collectContracts(stagingAddrConfig);
+    const overrides = loadContractOverrides(sharedConfigsRoot);
+    const prodContractsMerged = mergeContracts(prodContracts, overrides.prod ?? {});
+    const devOverrides = overrides.dev ?? overrides.staging ?? {};
+    const stagingContractsMerged = mergeContracts(stagingContracts, devOverrides);
+    await (0, promises_1.writeFile)(node_path_1.default.join(generatedDir, "contracts.ts"), `${renderContracts(prodContractsMerged)}\n`);
+    await (0, promises_1.writeFile)(node_path_1.default.join(generatedDir, "contracts.dev.ts"), `${renderContracts(stagingContractsMerged)}\n`);
+    await (0, promises_1.writeFile)(node_path_1.default.join(generatedDir, "abis.ts"), `${renderAbiSignatures(abiSignatures)}\n`);
+}
+generate().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/src/abis/index.d.ts

@@ -0,0 +1,3 @@
+export { routerAbi, routerHelperAbi, emissaryAbi, intentExecutorAbi, intentExecutorAdapterAbi, acrossAdapterAbi, ecoAdapterAbi, relayAdapterAbi, sameChainAdapterAbi, multicallAbi, multicallHandlerAbi, acrossAdapterOptimizedAbi, ecoAdapterOptimizedAbi, relayAdapterOptimizedAbi, routeTupleAbi, rewardTupleAbi, multicallAbi as multiCallAbi } from "./orchestrator";
+export { directRouteAbi, wethAbi, relayerPotV1Abi, singleCallAbi, } from "./relayer";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/abis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/abis/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,wBAAwB,EACxB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,YAAY,EACZ,mBAAmB,EACnB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACxB,aAAa,EACb,cAAc,EACd,YAAY,IAAI,YAAY,EAC7B,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EACL,cAAc,EACd,OAAO,EACP,eAAe,EACf,aAAa,GACd,MAAM,WAAW,CAAC"}

package/dist/src/abis/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.singleCallAbi = exports.relayerPotV1Abi = exports.wethAbi = exports.directRouteAbi = exports.multiCallAbi = exports.rewardTupleAbi = exports.routeTupleAbi = exports.relayAdapterOptimizedAbi = exports.ecoAdapterOptimizedAbi = exports.acrossAdapterOptimizedAbi = exports.multicallHandlerAbi = exports.multicallAbi = exports.sameChainAdapterAbi = exports.relayAdapterAbi = exports.ecoAdapterAbi = exports.acrossAdapterAbi = exports.intentExecutorAdapterAbi = exports.intentExecutorAbi = exports.emissaryAbi = exports.routerHelperAbi = exports.routerAbi = void 0;
+// Re-export ABIs from orchestrator.ts
+var orchestrator_1 = require("./orchestrator");
+Object.defineProperty(exports, "routerAbi", { enumerable: true, get: function () { return orchestrator_1.routerAbi; } });
+Object.defineProperty(exports, "routerHelperAbi", { enumerable: true, get: function () { return orchestrator_1.routerHelperAbi; } });
+Object.defineProperty(exports, "emissaryAbi", { enumerable: true, get: function () { return orchestrator_1.emissaryAbi; } });
+Object.defineProperty(exports, "intentExecutorAbi", { enumerable: true, get: function () { return orchestrator_1.intentExecutorAbi; } });
+Object.defineProperty(exports, "intentExecutorAdapterAbi", { enumerable: true, get: function () { return orchestrator_1.intentExecutorAdapterAbi; } });
+Object.defineProperty(exports, "acrossAdapterAbi", { enumerable: true, get: function () { return orchestrator_1.acrossAdapterAbi; } });
+Object.defineProperty(exports, "ecoAdapterAbi", { enumerable: true, get: function () { return orchestrator_1.ecoAdapterAbi; } });
+Object.defineProperty(exports, "relayAdapterAbi", { enumerable: true, get: function () { return orchestrator_1.relayAdapterAbi; } });
+Object.defineProperty(exports, "sameChainAdapterAbi", { enumerable: true, get: function () { return orchestrator_1.sameChainAdapterAbi; } });
+Object.defineProperty(exports, "multicallAbi", { enumerable: true, get: function () { return orchestrator_1.multicallAbi; } });
+Object.defineProperty(exports, "multicallHandlerAbi", { enumerable: true, get: function () { return orchestrator_1.multicallHandlerAbi; } });
+Object.defineProperty(exports, "acrossAdapterOptimizedAbi", { enumerable: true, get: function () { return orchestrator_1.acrossAdapterOptimizedAbi; } });
+Object.defineProperty(exports, "ecoAdapterOptimizedAbi", { enumerable: true, get: function () { return orchestrator_1.ecoAdapterOptimizedAbi; } });
+Object.defineProperty(exports, "relayAdapterOptimizedAbi", { enumerable: true, get: function () { return orchestrator_1.relayAdapterOptimizedAbi; } });
+Object.defineProperty(exports, "routeTupleAbi", { enumerable: true, get: function () { return orchestrator_1.routeTupleAbi; } });
+Object.defineProperty(exports, "rewardTupleAbi", { enumerable: true, get: function () { return orchestrator_1.rewardTupleAbi; } });
+Object.defineProperty(exports, "multiCallAbi", { enumerable: true, get: function () { return orchestrator_1.multicallAbi; } });
+// Relayer ABIs
+var relayer_1 = require("./relayer");
+Object.defineProperty(exports, "directRouteAbi", { enumerable: true, get: function () { return relayer_1.directRouteAbi; } });
+Object.defineProperty(exports, "wethAbi", { enumerable: true, get: function () { return relayer_1.wethAbi; } });
+Object.defineProperty(exports, "relayerPotV1Abi", { enumerable: true, get: function () { return relayer_1.relayerPotV1Abi; } });
+Object.defineProperty(exports, "singleCallAbi", { enumerable: true, get: function () { return relayer_1.singleCallAbi; } });