@eco-incorp/sauce 0.99.5 → 0.99.7

package/sdk/dist/descriptors/contracts.generated.d.ts

@@ -0,0 +1,3393 @@
+import type { AddressOnlyContract, Contract, InterfaceContract } from "./accessors.js";
+import * as aaveV2Abis from "../protocols/aave-v2/abis.js";
+import * as aaveV3Abis from "../protocols/aave-v3/abis.js";
+import * as aaveV4Abis from "../protocols/aave-v4/abis.js";
+import * as abracadabraAbis from "../protocols/abracadabra/abis.js";
+import * as acrossAbis from "../protocols/across/abis.js";
+import * as aerodromeAbis from "../protocols/aerodrome/abis.js";
+import * as aerodromeSlipstreamAbis from "../protocols/aerodrome-slipstream/abis.js";
+import * as aevoAbis from "../protocols/aevo/abis.js";
+import * as alchemixAbis from "../protocols/alchemix/abis.js";
+import * as ambientAbis from "../protocols/ambient/abis.js";
+import * as arbitrumBridgeAbis from "../protocols/arbitrum-bridge/abis.js";
+import * as arrakisAbis from "../protocols/arrakis/abis.js";
+import * as axelarAbis from "../protocols/axelar/abis.js";
+import * as balancerV2Abis from "../protocols/balancer-v2/abis.js";
+import * as baseBridgeAbis from "../protocols/base-bridge/abis.js";
+import * as baseswapAbis from "../protocols/baseswap/abis.js";
+import * as beefyAbis from "../protocols/beefy/abis.js";
+import * as benqiAbis from "../protocols/benqi/abis.js";
+import * as camelotAbis from "../protocols/camelot/abis.js";
+import * as cbethAbis from "../protocols/cbeth/abis.js";
+import * as cctpAbis from "../protocols/cctp/abis.js";
+import * as celerAbis from "../protocols/celer/abis.js";
+import * as chainlinkAbis from "../protocols/chainlink/abis.js";
+import * as chainlinkCcipAbis from "../protocols/chainlink-ccip/abis.js";
+import * as circleGatewayAbis from "../protocols/circle-gateway/abis.js";
+import * as compoundV2Abis from "../protocols/compound-v2/abis.js";
+import * as compoundV3Abis from "../protocols/compound-v3/abis.js";
+import * as connextAbis from "../protocols/connext/abis.js";
+import * as convexAbis from "../protocols/convex/abis.js";
+import * as cowswapAbis from "../protocols/cowswap/abis.js";
+import * as crvusdAbis from "../protocols/crvusd/abis.js";
+import * as curveAbis from "../protocols/curve/abis.js";
+import * as debridgeAbis from "../protocols/debridge/abis.js";
+import * as dodoAbis from "../protocols/dodo/abis.js";
+import * as ecoRoutesAbis from "../protocols/eco-routes/abis.js";
+import * as eigenlayerAbis from "../protocols/eigenlayer/abis.js";
+import * as ensAbis from "../protocols/ens/abis.js";
+import * as erc20Abis from "../protocols/erc20/abis.js";
+import * as erc3156Abis from "../protocols/erc3156/abis.js";
+import * as erc4626Abis from "../protocols/erc4626/abis.js";
+import * as ethenaAbis from "../protocols/ethena/abis.js";
+import * as etherfiAbis from "../protocols/etherfi/abis.js";
+import * as eulerV2Abis from "../protocols/euler-v2/abis.js";
+import * as fenixAbis from "../protocols/fenix/abis.js";
+import * as fluidAbis from "../protocols/fluid/abis.js";
+import * as fraxAbis from "../protocols/frax/abis.js";
+import * as fraxEtherAbis from "../protocols/frax-ether/abis.js";
+import * as gainsNetworkAbis from "../protocols/gains-network/abis.js";
+import * as gammaAbis from "../protocols/gamma/abis.js";
+import * as gelatoAbis from "../protocols/gelato/abis.js";
+import * as ghoAbis from "../protocols/gho/abis.js";
+import * as gmxV1Abis from "../protocols/gmx-v1/abis.js";
+import * as gmxV2Abis from "../protocols/gmx-v2/abis.js";
+import * as harvestAbis from "../protocols/harvest/abis.js";
+import * as hegicAbis from "../protocols/hegic/abis.js";
+import * as hopAbis from "../protocols/hop/abis.js";
+import * as hyperlaneAbis from "../protocols/hyperlane/abis.js";
+import * as instadappAbis from "../protocols/instadapp/abis.js";
+import * as kelpAbis from "../protocols/kelp/abis.js";
+import * as kimAbis from "../protocols/kim/abis.js";
+import * as kyberswapAbis from "../protocols/kyberswap/abis.js";
+import * as kyberswapAggregatorAbis from "../protocols/kyberswap-aggregator/abis.js";
+import * as layerbankAbis from "../protocols/layerbank/abis.js";
+import * as layerzeroAbis from "../protocols/layerzero/abis.js";
+import * as levelFinanceAbis from "../protocols/level-finance/abis.js";
+import * as lidoAbis from "../protocols/lido/abis.js";
+import * as lifiAbis from "../protocols/lifi/abis.js";
+import * as lineaBridgeAbis from "../protocols/linea-bridge/abis.js";
+import * as liquityV1Abis from "../protocols/liquity-v1/abis.js";
+import * as liquityV2Abis from "../protocols/liquity-v2/abis.js";
+import * as lynexAbis from "../protocols/lynex/abis.js";
+import * as makerAbis from "../protocols/maker/abis.js";
+import * as mantleMethAbis from "../protocols/mantle-meth/abis.js";
+import * as maverickAbis from "../protocols/maverick/abis.js";
+import * as moonwellAbis from "../protocols/moonwell/abis.js";
+import * as morphoBlueAbis from "../protocols/morpho-blue/abis.js";
+import * as muxProtocolAbis from "../protocols/mux-protocol/abis.js";
+import * as olympusAbis from "../protocols/olympus/abis.js";
+import * as oneinchAbis from "../protocols/oneinch/abis.js";
+import * as openoceanAbis from "../protocols/openocean/abis.js";
+import * as optimismBridgeAbis from "../protocols/optimism-bridge/abis.js";
+import * as opynAbis from "../protocols/opyn/abis.js";
+import * as pancakeswapV2Abis from "../protocols/pancakeswap-v2/abis.js";
+import * as pancakeswapV3Abis from "../protocols/pancakeswap-v3/abis.js";
+import * as paraswapAbis from "../protocols/paraswap/abis.js";
+import * as pendleAbis from "../protocols/pendle/abis.js";
+import * as permit2Abis from "../protocols/permit2/abis.js";
+import * as perpetualProtocolAbis from "../protocols/perpetual-protocol/abis.js";
+import * as polygonBridgeAbis from "../protocols/polygon-bridge/abis.js";
+import * as premiaAbis from "../protocols/premia/abis.js";
+import * as pufferAbis from "../protocols/puffer/abis.js";
+import * as pythAbis from "../protocols/pyth/abis.js";
+import * as quickswapAbis from "../protocols/quickswap/abis.js";
+import * as radiantAbis from "../protocols/radiant/abis.js";
+import * as ramsesAbis from "../protocols/ramses/abis.js";
+import * as reflexerAbis from "../protocols/reflexer/abis.js";
+import * as renzoAbis from "../protocols/renzo/abis.js";
+import * as rocketPoolAbis from "../protocols/rocket-pool/abis.js";
+import * as sablierAbis from "../protocols/sablier/abis.js";
+import * as safeAbis from "../protocols/safe/abis.js";
+import * as scrollBridgeAbis from "../protocols/scroll-bridge/abis.js";
+import * as seamlessAbis from "../protocols/seamless/abis.js";
+import * as seaportAbis from "../protocols/seaport/abis.js";
+import * as siloAbis from "../protocols/silo/abis.js";
+import * as socketAbis from "../protocols/socket/abis.js";
+import * as sommelierAbis from "../protocols/sommelier/abis.js";
+import * as sparkAbis from "../protocols/spark/abis.js";
+import * as spookyswapAbis from "../protocols/spookyswap/abis.js";
+import * as squidAbis from "../protocols/squid/abis.js";
+import * as staderAbis from "../protocols/stader/abis.js";
+import * as stargateAbis from "../protocols/stargate/abis.js";
+import * as superfluidAbis from "../protocols/superfluid/abis.js";
+import * as sushiswapV2Abis from "../protocols/sushiswap-v2/abis.js";
+import * as swellAbis from "../protocols/swell/abis.js";
+import * as synapseAbis from "../protocols/synapse/abis.js";
+import * as syncswapAbis from "../protocols/syncswap/abis.js";
+import * as synthetixV3Abis from "../protocols/synthetix-v3/abis.js";
+import * as synthraV3Abis from "../protocols/synthra-v3/abis.js";
+import * as thalesAbis from "../protocols/thales/abis.js";
+import * as thenaAbis from "../protocols/thena/abis.js";
+import * as thrusterAbis from "../protocols/thruster/abis.js";
+import * as tokemakAbis from "../protocols/tokemak/abis.js";
+import * as traderJoeAbis from "../protocols/trader-joe/abis.js";
+import * as uniswapV2Abis from "../protocols/uniswap-v2/abis.js";
+import * as uniswapV3Abis from "../protocols/uniswap-v3/abis.js";
+import * as uniswapV4Abis from "../protocols/uniswap-v4/abis.js";
+import * as unitflowV3Abis from "../protocols/unitflow-v3/abis.js";
+import * as velodromeAbis from "../protocols/velodrome/abis.js";
+import * as venusAbis from "../protocols/venus/abis.js";
+import * as vertexAbis from "../protocols/vertex/abis.js";
+import * as wormholeAbis from "../protocols/wormhole/abis.js";
+import * as yearnV3Abis from "../protocols/yearn-v3/abis.js";
+import * as zerolendAbis from "../protocols/zerolend/abis.js";
+import * as zeroxAbis from "../protocols/zerox/abis.js";
+import * as zksyncBridgeAbis from "../protocols/zksync-bridge/abis.js";
+/** Every registry protocol's ABI exports and deployments, by slug. */
+export declare const PROTOCOL_SOURCES: {
+    readonly "aave-v2": {
+        readonly abis: typeof aaveV2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "aave-v3": {
+        readonly abis: typeof aaveV3Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "aave-v4": {
+        readonly abis: typeof aaveV4Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly abracadabra: {
+        readonly abis: typeof abracadabraAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly across: {
+        readonly abis: typeof acrossAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly aerodrome: {
+        readonly abis: typeof aerodromeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "aerodrome-slipstream": {
+        readonly abis: typeof aerodromeSlipstreamAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly aevo: {
+        readonly abis: typeof aevoAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly alchemix: {
+        readonly abis: typeof alchemixAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly ambient: {
+        readonly abis: typeof ambientAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "arbitrum-bridge": {
+        readonly abis: typeof arbitrumBridgeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly arrakis: {
+        readonly abis: typeof arrakisAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly axelar: {
+        readonly abis: typeof axelarAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "balancer-v2": {
+        readonly abis: typeof balancerV2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "base-bridge": {
+        readonly abis: typeof baseBridgeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly baseswap: {
+        readonly abis: typeof baseswapAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly beefy: {
+        readonly abis: typeof beefyAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly benqi: {
+        readonly abis: typeof benqiAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly camelot: {
+        readonly abis: typeof camelotAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly cbeth: {
+        readonly abis: typeof cbethAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly cctp: {
+        readonly abis: typeof cctpAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly celer: {
+        readonly abis: typeof celerAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly chainlink: {
+        readonly abis: typeof chainlinkAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "chainlink-ccip": {
+        readonly abis: typeof chainlinkCcipAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "circle-gateway": {
+        readonly abis: typeof circleGatewayAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "compound-v2": {
+        readonly abis: typeof compoundV2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "compound-v3": {
+        readonly abis: typeof compoundV3Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly connext: {
+        readonly abis: typeof connextAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly convex: {
+        readonly abis: typeof convexAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly cowswap: {
+        readonly abis: typeof cowswapAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly crvusd: {
+        readonly abis: typeof crvusdAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly curve: {
+        readonly abis: typeof curveAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly debridge: {
+        readonly abis: typeof debridgeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly dodo: {
+        readonly abis: typeof dodoAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "eco-routes": {
+        readonly abis: typeof ecoRoutesAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly eigenlayer: {
+        readonly abis: typeof eigenlayerAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly ens: {
+        readonly abis: typeof ensAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly erc20: {
+        readonly abis: typeof erc20Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly erc3156: {
+        readonly abis: typeof erc3156Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly erc4626: {
+        readonly abis: typeof erc4626Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly ethena: {
+        readonly abis: typeof ethenaAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly etherfi: {
+        readonly abis: typeof etherfiAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "euler-v2": {
+        readonly abis: typeof eulerV2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly fenix: {
+        readonly abis: typeof fenixAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly fluid: {
+        readonly abis: typeof fluidAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly frax: {
+        readonly abis: typeof fraxAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "frax-ether": {
+        readonly abis: typeof fraxEtherAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "gains-network": {
+        readonly abis: typeof gainsNetworkAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly gamma: {
+        readonly abis: typeof gammaAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly gelato: {
+        readonly abis: typeof gelatoAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly gho: {
+        readonly abis: typeof ghoAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "gmx-v1": {
+        readonly abis: typeof gmxV1Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "gmx-v2": {
+        readonly abis: typeof gmxV2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly harvest: {
+        readonly abis: typeof harvestAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly hegic: {
+        readonly abis: typeof hegicAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly hop: {
+        readonly abis: typeof hopAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly hyperlane: {
+        readonly abis: typeof hyperlaneAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly instadapp: {
+        readonly abis: typeof instadappAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly kelp: {
+        readonly abis: typeof kelpAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly kim: {
+        readonly abis: typeof kimAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly kyberswap: {
+        readonly abis: typeof kyberswapAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "kyberswap-aggregator": {
+        readonly abis: typeof kyberswapAggregatorAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly layerbank: {
+        readonly abis: typeof layerbankAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly layerzero: {
+        readonly abis: typeof layerzeroAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "level-finance": {
+        readonly abis: typeof levelFinanceAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly lido: {
+        readonly abis: typeof lidoAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly lifi: {
+        readonly abis: typeof lifiAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "linea-bridge": {
+        readonly abis: typeof lineaBridgeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "liquity-v1": {
+        readonly abis: typeof liquityV1Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "liquity-v2": {
+        readonly abis: typeof liquityV2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly lynex: {
+        readonly abis: typeof lynexAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly maker: {
+        readonly abis: typeof makerAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "mantle-meth": {
+        readonly abis: typeof mantleMethAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly maverick: {
+        readonly abis: typeof maverickAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly moonwell: {
+        readonly abis: typeof moonwellAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "morpho-blue": {
+        readonly abis: typeof morphoBlueAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "mux-protocol": {
+        readonly abis: typeof muxProtocolAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly olympus: {
+        readonly abis: typeof olympusAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly oneinch: {
+        readonly abis: typeof oneinchAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly openocean: {
+        readonly abis: typeof openoceanAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "optimism-bridge": {
+        readonly abis: typeof optimismBridgeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly opyn: {
+        readonly abis: typeof opynAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "pancakeswap-v2": {
+        readonly abis: typeof pancakeswapV2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "pancakeswap-v3": {
+        readonly abis: typeof pancakeswapV3Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly paraswap: {
+        readonly abis: typeof paraswapAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly pendle: {
+        readonly abis: typeof pendleAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly permit2: {
+        readonly abis: typeof permit2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "perpetual-protocol": {
+        readonly abis: typeof perpetualProtocolAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "polygon-bridge": {
+        readonly abis: typeof polygonBridgeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly premia: {
+        readonly abis: typeof premiaAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly puffer: {
+        readonly abis: typeof pufferAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly pyth: {
+        readonly abis: typeof pythAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly quickswap: {
+        readonly abis: typeof quickswapAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly radiant: {
+        readonly abis: typeof radiantAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly ramses: {
+        readonly abis: typeof ramsesAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly reflexer: {
+        readonly abis: typeof reflexerAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly renzo: {
+        readonly abis: typeof renzoAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "rocket-pool": {
+        readonly abis: typeof rocketPoolAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly sablier: {
+        readonly abis: typeof sablierAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly safe: {
+        readonly abis: typeof safeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "scroll-bridge": {
+        readonly abis: typeof scrollBridgeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly seamless: {
+        readonly abis: typeof seamlessAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly seaport: {
+        readonly abis: typeof seaportAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly silo: {
+        readonly abis: typeof siloAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly socket: {
+        readonly abis: typeof socketAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly sommelier: {
+        readonly abis: typeof sommelierAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly spark: {
+        readonly abis: typeof sparkAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly spookyswap: {
+        readonly abis: typeof spookyswapAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly squid: {
+        readonly abis: typeof squidAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly stader: {
+        readonly abis: typeof staderAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly stargate: {
+        readonly abis: typeof stargateAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly superfluid: {
+        readonly abis: typeof superfluidAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "sushiswap-v2": {
+        readonly abis: typeof sushiswapV2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly swell: {
+        readonly abis: typeof swellAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly synapse: {
+        readonly abis: typeof synapseAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly syncswap: {
+        readonly abis: typeof syncswapAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "synthetix-v3": {
+        readonly abis: typeof synthetixV3Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "synthra-v3": {
+        readonly abis: typeof synthraV3Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly thales: {
+        readonly abis: typeof thalesAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly thena: {
+        readonly abis: typeof thenaAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly thruster: {
+        readonly abis: typeof thrusterAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly tokemak: {
+        readonly abis: typeof tokemakAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "trader-joe": {
+        readonly abis: typeof traderJoeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "uniswap-v2": {
+        readonly abis: typeof uniswapV2Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "uniswap-v3": {
+        readonly abis: typeof uniswapV3Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "uniswap-v4": {
+        readonly abis: typeof uniswapV4Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "unitflow-v3": {
+        readonly abis: typeof unitflowV3Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly velodrome: {
+        readonly abis: typeof velodromeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly venus: {
+        readonly abis: typeof venusAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly vertex: {
+        readonly abis: typeof vertexAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly wormhole: {
+        readonly abis: typeof wormholeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "yearn-v3": {
+        readonly abis: typeof yearnV3Abis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly zerolend: {
+        readonly abis: typeof zerolendAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly zerox: {
+        readonly abis: typeof zeroxAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+    readonly "zksync-bridge": {
+        readonly abis: typeof zksyncBridgeAbis;
+        readonly deployments: import("../index.js").ChainDeployment[];
+    };
+};
+/** One entry per contract: 316 contracts across 135 protocols. */
+export declare const CONTRACT_LINKS: readonly [{
+    readonly protocol: "aave-v2";
+    readonly contract: "LendingPool";
+    readonly kind: "singleton";
+    readonly roleKey: "lendingPool";
+    readonly abiExport: "LendingPoolABI";
+}, {
+    readonly protocol: "aave-v3";
+    readonly contract: "Pool";
+    readonly kind: "singleton";
+    readonly roleKey: "pool";
+    readonly abiExport: "PoolABI";
+}, {
+    readonly protocol: "aave-v3";
+    readonly contract: "PoolAddressesProvider";
+    readonly kind: "address-only";
+    readonly roleKey: "poolAddressesProvider";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "MainSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "mainSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "ForexSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "forexSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "BluechipSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "bluechipSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "EthenaCorrelatedSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "ethenaCorrelatedSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "EthenaEcosystemSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "ethenaEcosystemSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "GoldSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "goldSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "PaxgGoldSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "paxgGoldSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "LombardBtcSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "lombardBtcSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "UsdgPendleSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "usdgPendleSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "EtherfiESpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "etherfiESpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "KelpESpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "kelpESpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "LidoESpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "lidoESpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "UsdgMapleESpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "usdgMapleESpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "Mag7Spoke";
+    readonly kind: "singleton";
+    readonly roleKey: "mag7Spoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "AvaxCorrelatedSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "avaxCorrelatedSpoke";
+    readonly abiExport: "AaveV4SpokeABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "CoreHub";
+    readonly kind: "singleton";
+    readonly roleKey: "coreHub";
+    readonly abiExport: "AaveV4HubABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "PlusHub";
+    readonly kind: "singleton";
+    readonly roleKey: "plusHub";
+    readonly abiExport: "AaveV4HubABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "PrimeHub";
+    readonly kind: "singleton";
+    readonly roleKey: "primeHub";
+    readonly abiExport: "AaveV4HubABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "GlobalDollarHub";
+    readonly kind: "singleton";
+    readonly roleKey: "globalDollarHub";
+    readonly abiExport: "AaveV4HubABI";
+}, {
+    readonly protocol: "aave-v4";
+    readonly contract: "EquitiesHub";
+    readonly kind: "singleton";
+    readonly roleKey: "equitiesHub";
+    readonly abiExport: "AaveV4HubABI";
+}, {
+    readonly protocol: "abracadabra";
+    readonly contract: "Cauldron";
+    readonly kind: "interface";
+    readonly abiExport: "CauldronABI";
+}, {
+    readonly protocol: "abracadabra";
+    readonly contract: "DegenBox";
+    readonly kind: "singleton";
+    readonly roleKey: "degenBox";
+    readonly abiExport: "DegenBoxABI";
+}, {
+    readonly protocol: "abracadabra";
+    readonly contract: "Mim";
+    readonly kind: "address-only";
+    readonly roleKey: "mim";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "across";
+    readonly contract: "HubPool";
+    readonly kind: "singleton";
+    readonly roleKey: "hubPool";
+    readonly abiExport: "AcrossHubPoolABI";
+}, {
+    readonly protocol: "across";
+    readonly contract: "SpokePool";
+    readonly kind: "singleton";
+    readonly roleKey: "spokePool";
+    readonly abiExport: "AcrossSpokePoolABI";
+}, {
+    readonly protocol: "aerodrome";
+    readonly contract: "PoolFactory";
+    readonly kind: "singleton";
+    readonly roleKey: "poolFactory";
+    readonly abiExport: "AerodromePoolFactoryABI";
+}, {
+    readonly protocol: "aerodrome";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "AerodromeRouterABI";
+}, {
+    readonly protocol: "aerodrome";
+    readonly contract: "Pool";
+    readonly kind: "interface";
+    readonly abiExport: "AerodromePoolABI";
+}, {
+    readonly protocol: "aerodrome-slipstream";
+    readonly contract: "CLFactory";
+    readonly kind: "singleton";
+    readonly roleKey: "clFactory";
+    readonly abiExport: "SlipstreamCLFactoryABI";
+}, {
+    readonly protocol: "aerodrome-slipstream";
+    readonly contract: "CLFactoryGaugeCaps";
+    readonly kind: "singleton";
+    readonly roleKey: "clFactoryGaugeCaps";
+    readonly abiExport: "SlipstreamCLFactoryABI";
+}, {
+    readonly protocol: "aerodrome-slipstream";
+    readonly contract: "CLFactoryGaugesV3";
+    readonly kind: "singleton";
+    readonly roleKey: "clFactoryGaugesV3";
+    readonly abiExport: "SlipstreamCLFactoryABI";
+}, {
+    readonly protocol: "aerodrome-slipstream";
+    readonly contract: "NonfungiblePositionManager";
+    readonly kind: "singleton";
+    readonly roleKey: "nonfungiblePositionManager";
+    readonly abiExport: "SlipstreamPositionManagerABI";
+}, {
+    readonly protocol: "aerodrome-slipstream";
+    readonly contract: "NonfungiblePositionManagerGaugeCaps";
+    readonly kind: "singleton";
+    readonly roleKey: "nonfungiblePositionManagerGaugeCaps";
+    readonly abiExport: "SlipstreamPositionManagerABI";
+}, {
+    readonly protocol: "aerodrome-slipstream";
+    readonly contract: "NonfungiblePositionManagerGaugesV3";
+    readonly kind: "singleton";
+    readonly roleKey: "nonfungiblePositionManagerGaugesV3";
+    readonly abiExport: "SlipstreamPositionManagerABI";
+}, {
+    readonly protocol: "aerodrome-slipstream";
+    readonly contract: "Metarouter";
+    readonly kind: "singleton";
+    readonly roleKey: "metarouter";
+    readonly abiExport: "AeroMetarouterABI";
+}, {
+    readonly protocol: "aerodrome-slipstream";
+    readonly contract: "Pool";
+    readonly kind: "interface";
+    readonly abiExport: "AerodromeSlipstreamPoolABI";
+}, {
+    readonly protocol: "aevo";
+    readonly contract: "DepositContract";
+    readonly kind: "singleton";
+    readonly roleKey: "depositContract";
+    readonly abiExport: "DepositContractABI";
+}, {
+    readonly protocol: "alchemix";
+    readonly contract: "AlchemistAlUSD";
+    readonly kind: "singleton";
+    readonly roleKey: "alchemistAlUSD";
+    readonly abiExport: "AlchemistABI";
+}, {
+    readonly protocol: "alchemix";
+    readonly contract: "AlchemistAlETH";
+    readonly kind: "singleton";
+    readonly roleKey: "alchemistAlETH";
+    readonly abiExport: "AlchemistABI";
+}, {
+    readonly protocol: "alchemix";
+    readonly contract: "AlUSD";
+    readonly kind: "address-only";
+    readonly roleKey: "alUSD";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "alchemix";
+    readonly contract: "AlETH";
+    readonly kind: "address-only";
+    readonly roleKey: "alETH";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "ambient";
+    readonly contract: "CrocSwapDex";
+    readonly kind: "singleton";
+    readonly roleKey: "crocSwapDex";
+    readonly abiExport: "CrocSwapDexABI";
+}, {
+    readonly protocol: "arbitrum-bridge";
+    readonly contract: "L1GatewayRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "l1GatewayRouter";
+    readonly abiExport: "ArbitrumL1GatewayRouterABI";
+}, {
+    readonly protocol: "arbitrum-bridge";
+    readonly contract: "L2GatewayRouter";
+    readonly kind: "address-only";
+    readonly roleKey: "l2GatewayRouter";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "arrakis";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "ArrakisRouterABI";
+}, {
+    readonly protocol: "arrakis";
+    readonly contract: "Vault";
+    readonly kind: "interface";
+    readonly abiExport: "ArrakisVaultABI";
+}, {
+    readonly protocol: "arrakis";
+    readonly contract: "Factory";
+    readonly kind: "address-only";
+    readonly roleKey: "factory";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "axelar";
+    readonly contract: "GasService";
+    readonly kind: "singleton";
+    readonly roleKey: "gasService";
+    readonly abiExport: "AxelarGasServiceABI";
+}, {
+    readonly protocol: "axelar";
+    readonly contract: "Gateway";
+    readonly kind: "singleton";
+    readonly roleKey: "gateway";
+    readonly abiExport: "AxelarGatewayABI";
+}, {
+    readonly protocol: "axelar";
+    readonly contract: "ITS";
+    readonly kind: "singleton";
+    readonly roleKey: "its";
+    readonly abiExport: "AxelarITSABI";
+}, {
+    readonly protocol: "balancer-v2";
+    readonly contract: "Vault";
+    readonly kind: "singleton";
+    readonly roleKey: "vault";
+    readonly abiExport: "BalancerV2VaultABI";
+}, {
+    readonly protocol: "base-bridge";
+    readonly contract: "L1StandardBridge";
+    readonly kind: "singleton";
+    readonly roleKey: "l1StandardBridge";
+    readonly abiExport: "BaseL1StandardBridgeABI";
+}, {
+    readonly protocol: "base-bridge";
+    readonly contract: "L2StandardBridge";
+    readonly kind: "address-only";
+    readonly roleKey: "l2StandardBridge";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "baseswap";
+    readonly contract: "V2Router";
+    readonly kind: "singleton";
+    readonly roleKey: "v2Router";
+    readonly abiExport: "BaseSwapRouterABI";
+}, {
+    readonly protocol: "beefy";
+    readonly contract: "Vault";
+    readonly kind: "interface";
+    readonly abiExport: "BeefyVaultABI";
+}, {
+    readonly protocol: "beefy";
+    readonly contract: "BIFI";
+    readonly kind: "address-only";
+    readonly roleKey: "BIFI";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "benqi";
+    readonly contract: "Comptroller";
+    readonly kind: "singleton";
+    readonly roleKey: "comptroller";
+    readonly abiExport: "BenqiComptrollerABI";
+}, {
+    readonly protocol: "benqi";
+    readonly contract: "QiToken";
+    readonly kind: "interface";
+    readonly abiExport: "QiTokenABI";
+}, {
+    readonly protocol: "camelot";
+    readonly contract: "V2Router";
+    readonly kind: "singleton";
+    readonly roleKey: "v2Router";
+    readonly abiExport: "CamelotV2RouterABI";
+}, {
+    readonly protocol: "camelot";
+    readonly contract: "V3SwapRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "v3SwapRouter";
+    readonly abiExport: "CamelotV3SwapRouterABI";
+}, {
+    readonly protocol: "camelot";
+    readonly contract: "V2Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "v2Factory";
+    readonly abiExport: "CamelotV2FactoryABI";
+}, {
+    readonly protocol: "camelot";
+    readonly contract: "V2Pair";
+    readonly kind: "interface";
+    readonly abiExport: "CamelotV2PairABI";
+}, {
+    readonly protocol: "camelot";
+    readonly contract: "V3Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "v3Factory";
+    readonly abiExport: "CamelotV3FactoryABI";
+}, {
+    readonly protocol: "camelot";
+    readonly contract: "V3Pool";
+    readonly kind: "interface";
+    readonly abiExport: "CamelotV3PoolABI";
+}, {
+    readonly protocol: "cbeth";
+    readonly contract: "CbETH";
+    readonly kind: "singleton";
+    readonly roleKey: "cbETH";
+    readonly abiExport: "CbETHABI";
+    readonly caveats: readonly ["exchangeRate() is not available on base: Base cbETH is the bridged OptimismMintableERC20; the exchange rate lives only on the Ethereum StakedTokenV1", "mint(address,uint256) is not available on base: Base cbETH's mint is the bridge's (returns nothing); the ABI describes the Ethereum token, whose mint returns bool"];
+}, {
+    readonly protocol: "cctp";
+    readonly contract: "TokenMessenger";
+    readonly kind: "singleton";
+    readonly roleKey: "tokenMessenger";
+    readonly abiExport: "TokenMessengerABI";
+}, {
+    readonly protocol: "celer";
+    readonly contract: "Bridge";
+    readonly kind: "singleton";
+    readonly roleKey: "bridge";
+    readonly abiExport: "CelerBridgeABI";
+}, {
+    readonly protocol: "chainlink";
+    readonly contract: "EthUsdFeed";
+    readonly kind: "singleton";
+    readonly roleKey: "ethUsdFeed";
+    readonly abiExport: "AggregatorV3ABI";
+}, {
+    readonly protocol: "chainlink";
+    readonly contract: "FeedRegistry";
+    readonly kind: "singleton";
+    readonly roleKey: "feedRegistry";
+    readonly abiExport: "FeedRegistryABI";
+}, {
+    readonly protocol: "chainlink";
+    readonly contract: "VrfV2Coordinator";
+    readonly kind: "address-only";
+    readonly roleKey: "vrfV2Coordinator";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "chainlink-ccip";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "CCIPRouterABI";
+}, {
+    readonly protocol: "circle-gateway";
+    readonly contract: "GatewayWallet";
+    readonly kind: "singleton";
+    readonly roleKey: "gatewayWallet";
+    readonly abiExport: "GatewayWalletABI";
+}, {
+    readonly protocol: "circle-gateway";
+    readonly contract: "GatewayMinter";
+    readonly kind: "singleton";
+    readonly roleKey: "gatewayMinter";
+    readonly abiExport: "GatewayMinterABI";
+}, {
+    readonly protocol: "compound-v2";
+    readonly contract: "CUSDC";
+    readonly kind: "singleton";
+    readonly roleKey: "cUSDC";
+    readonly abiExport: "CErc20ABI";
+}, {
+    readonly protocol: "compound-v2";
+    readonly contract: "Comptroller";
+    readonly kind: "singleton";
+    readonly roleKey: "comptroller";
+    readonly abiExport: "ComptrollerABI";
+}, {
+    readonly protocol: "compound-v2";
+    readonly contract: "CETH";
+    readonly kind: "address-only";
+    readonly roleKey: "cETH";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "compound-v3";
+    readonly contract: "CUSDCv3";
+    readonly kind: "singleton";
+    readonly roleKey: "cUSDCv3";
+    readonly abiExport: "CometABI";
+}, {
+    readonly protocol: "compound-v3";
+    readonly contract: "CWETHv3";
+    readonly kind: "singleton";
+    readonly roleKey: "cWETHv3";
+    readonly abiExport: "CometABI";
+}, {
+    readonly protocol: "compound-v3";
+    readonly contract: "CUSDTv3";
+    readonly kind: "singleton";
+    readonly roleKey: "cUSDTv3";
+    readonly abiExport: "CometABI";
+}, {
+    readonly protocol: "connext";
+    readonly contract: "EverclearSpoke";
+    readonly kind: "singleton";
+    readonly roleKey: "everclearSpoke";
+    readonly abiExport: "EverclearSpokeABI";
+}, {
+    readonly protocol: "convex";
+    readonly contract: "BaseRewardPool";
+    readonly kind: "interface";
+    readonly abiExport: "BaseRewardPoolABI";
+}, {
+    readonly protocol: "convex";
+    readonly contract: "Booster";
+    readonly kind: "singleton";
+    readonly roleKey: "booster";
+    readonly abiExport: "BoosterABI";
+}, {
+    readonly protocol: "convex";
+    readonly contract: "CvxRewardPool";
+    readonly kind: "address-only";
+    readonly roleKey: "cvxRewardPool";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "cowswap";
+    readonly contract: "GPv2Settlement";
+    readonly kind: "singleton";
+    readonly roleKey: "gpv2Settlement";
+    readonly abiExport: "GPv2SettlementABI";
+}, {
+    readonly protocol: "crvusd";
+    readonly contract: "CrvUSD";
+    readonly kind: "singleton";
+    readonly roleKey: "crvusd";
+    readonly abiExport: "CrvUSDERC20ABI";
+}, {
+    readonly protocol: "curve";
+    readonly contract: "AddressProvider";
+    readonly kind: "singleton";
+    readonly roleKey: "addressProvider";
+    readonly abiExport: "CurveAddressProviderABI";
+}, {
+    readonly protocol: "curve";
+    readonly contract: "RouterNG";
+    readonly kind: "singleton";
+    readonly roleKey: "routerNG";
+    readonly abiExport: "CurveRouterNGABI";
+}, {
+    readonly protocol: "curve";
+    readonly contract: "StableSwap";
+    readonly kind: "interface";
+    readonly abiExport: "CurveStableSwapABI";
+}, {
+    readonly protocol: "curve";
+    readonly contract: "ThreePool";
+    readonly kind: "singleton";
+    readonly roleKey: "threePool";
+    readonly abiExport: "CurveThreePoolABI";
+}, {
+    readonly protocol: "curve";
+    readonly contract: "CrvToken";
+    readonly kind: "address-only";
+    readonly roleKey: "crvToken";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "debridge";
+    readonly contract: "DlnDestination";
+    readonly kind: "singleton";
+    readonly roleKey: "dlnDestination";
+    readonly abiExport: "DlnDestinationABI";
+}, {
+    readonly protocol: "debridge";
+    readonly contract: "DlnSource";
+    readonly kind: "singleton";
+    readonly roleKey: "dlnSource";
+    readonly abiExport: "DlnSourceABI";
+}, {
+    readonly protocol: "dodo";
+    readonly contract: "DODOV2Proxy";
+    readonly kind: "singleton";
+    readonly roleKey: "dodoV2Proxy";
+    readonly abiExport: "DODOV2ProxyABI";
+}, {
+    readonly protocol: "eco-routes";
+    readonly contract: "Portal";
+    readonly kind: "singleton";
+    readonly roleKey: "Portal";
+    readonly abiExport: "PortalABI";
+}, {
+    readonly protocol: "eco-routes";
+    readonly contract: "HyperProver";
+    readonly kind: "singleton";
+    readonly roleKey: "HyperProver";
+    readonly abiExport: "ProverABI";
+}, {
+    readonly protocol: "eco-routes";
+    readonly contract: "PolymerProver";
+    readonly kind: "singleton";
+    readonly roleKey: "PolymerProver";
+    readonly abiExport: "ProverABI";
+    readonly caveats: readonly ["fetchFee(uint64,bytes,bytes) is not available on ethereum: a PolymerProver: its proof is relayed through Polymer's prover API rather than paid for in prove, so it has no fetchFee", "fetchFee(uint64,bytes,bytes) is not available on optimism: a PolymerProver: its proof is relayed through Polymer's prover API rather than paid for in prove, so it has no fetchFee", "fetchFee(uint64,bytes,bytes) is not available on unichain: a PolymerProver: its proof is relayed through Polymer's prover API rather than paid for in prove, so it has no fetchFee", "fetchFee(uint64,bytes,bytes) is not available on polygon: a PolymerProver: its proof is relayed through Polymer's prover API rather than paid for in prove, so it has no fetchFee", "fetchFee(uint64,bytes,bytes) is not available on monad: a PolymerProver: its proof is relayed through Polymer's prover API rather than paid for in prove, so it has no fetchFee", "fetchFee(uint64,bytes,bytes) is not available on arc: a PolymerProver: its proof is relayed through Polymer's prover API rather than paid for in prove, so it has no fetchFee", "fetchFee(uint64,bytes,bytes) is not available on base: a PolymerProver: its proof is relayed through Polymer's prover API rather than paid for in prove, so it has no fetchFee", "fetchFee(uint64,bytes,bytes) is not available on plasma: a PolymerProver: its proof is relayed through Polymer's prover API rather than paid for in prove, so it has no fetchFee", "fetchFee(uint64,bytes,bytes) is not available on arbitrum: a PolymerProver: its proof is relayed through Polymer's prover API rather than paid for in prove, so it has no fetchFee", "error InsufficientFee(uint256) is not available on ethereum: a PolymerProver: it charges no fee, so it never reverts InsufficientFee", "error InsufficientFee(uint256) is not available on optimism: a PolymerProver: it charges no fee, so it never reverts InsufficientFee", "error InsufficientFee(uint256) is not available on unichain: a PolymerProver: it charges no fee, so it never reverts InsufficientFee", "error InsufficientFee(uint256) is not available on polygon: a PolymerProver: it charges no fee, so it never reverts InsufficientFee", "error InsufficientFee(uint256) is not available on monad: a PolymerProver: it charges no fee, so it never reverts InsufficientFee", "error InsufficientFee(uint256) is not available on arc: a PolymerProver: it charges no fee, so it never reverts InsufficientFee", "error InsufficientFee(uint256) is not available on base: a PolymerProver: it charges no fee, so it never reverts InsufficientFee", "error InsufficientFee(uint256) is not available on plasma: a PolymerProver: it charges no fee, so it never reverts InsufficientFee", "error InsufficientFee(uint256) is not available on arbitrum: a PolymerProver: it charges no fee, so it never reverts InsufficientFee"];
+}, {
+    readonly protocol: "eigenlayer";
+    readonly contract: "DelegationManager";
+    readonly kind: "singleton";
+    readonly roleKey: "delegationManager";
+    readonly abiExport: "DelegationManagerABI";
+}, {
+    readonly protocol: "eigenlayer";
+    readonly contract: "StETHStrategy";
+    readonly kind: "singleton";
+    readonly roleKey: "stETHStrategy";
+    readonly abiExport: "StrategyABI";
+}, {
+    readonly protocol: "eigenlayer";
+    readonly contract: "RETHStrategy";
+    readonly kind: "singleton";
+    readonly roleKey: "rETHStrategy";
+    readonly abiExport: "StrategyABI";
+}, {
+    readonly protocol: "eigenlayer";
+    readonly contract: "CbETHStrategy";
+    readonly kind: "singleton";
+    readonly roleKey: "cbETHStrategy";
+    readonly abiExport: "StrategyABI";
+}, {
+    readonly protocol: "eigenlayer";
+    readonly contract: "StrategyManager";
+    readonly kind: "singleton";
+    readonly roleKey: "strategyManager";
+    readonly abiExport: "StrategyManagerABI";
+}, {
+    readonly protocol: "ens";
+    readonly contract: "BaseRegistrar";
+    readonly kind: "singleton";
+    readonly roleKey: "baseRegistrar";
+    readonly abiExport: "BaseRegistrarABI";
+}, {
+    readonly protocol: "ens";
+    readonly contract: "Registry";
+    readonly kind: "singleton";
+    readonly roleKey: "registry";
+    readonly abiExport: "ENSRegistryABI";
+}, {
+    readonly protocol: "erc20";
+    readonly contract: "ERC20";
+    readonly kind: "interface";
+    readonly abiExport: "ERC20ABI";
+}, {
+    readonly protocol: "erc3156";
+    readonly contract: "FlashLender";
+    readonly kind: "interface";
+    readonly abiExport: "FlashLenderABI";
+}, {
+    readonly protocol: "erc4626";
+    readonly contract: "Vault";
+    readonly kind: "interface";
+    readonly abiExport: "VaultABI";
+}, {
+    readonly protocol: "ethena";
+    readonly contract: "Susde";
+    readonly kind: "singleton";
+    readonly roleKey: "susde";
+    readonly abiExport: "StakedUSDeABI";
+}, {
+    readonly protocol: "ethena";
+    readonly contract: "USDe";
+    readonly kind: "singleton";
+    readonly roleKey: "usde";
+    readonly abiExport: "USDeABI";
+}, {
+    readonly protocol: "etherfi";
+    readonly contract: "EETH";
+    readonly kind: "singleton";
+    readonly roleKey: "eETH";
+    readonly abiExport: "EETHABI";
+}, {
+    readonly protocol: "etherfi";
+    readonly contract: "LiquidityPool";
+    readonly kind: "singleton";
+    readonly roleKey: "liquidityPool";
+    readonly abiExport: "LiquidityPoolABI";
+}, {
+    readonly protocol: "etherfi";
+    readonly contract: "WeETH";
+    readonly kind: "singleton";
+    readonly roleKey: "weETH";
+    readonly abiExport: "WeETHABI";
+}, {
+    readonly protocol: "euler-v2";
+    readonly contract: "EthereumVaultConnector";
+    readonly kind: "singleton";
+    readonly roleKey: "ethereumVaultConnector";
+    readonly abiExport: "EVCABI";
+}, {
+    readonly protocol: "euler-v2";
+    readonly contract: "EVault";
+    readonly kind: "interface";
+    readonly abiExport: "EVaultABI";
+}, {
+    readonly protocol: "fenix";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "FenixRouterABI";
+}, {
+    readonly protocol: "fluid";
+    readonly contract: "Lending";
+    readonly kind: "interface";
+    readonly abiExport: "FluidLendingABI";
+}, {
+    readonly protocol: "fluid";
+    readonly contract: "Vault";
+    readonly kind: "interface";
+    readonly abiExport: "FluidVaultABI";
+}, {
+    readonly protocol: "fluid";
+    readonly contract: "Liquidity";
+    readonly kind: "address-only";
+    readonly roleKey: "liquidity";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "frax";
+    readonly contract: "Frax";
+    readonly kind: "singleton";
+    readonly roleKey: "frax";
+    readonly abiExport: "FraxERC20ABI";
+}, {
+    readonly protocol: "frax-ether";
+    readonly contract: "FrxETHMinter";
+    readonly kind: "singleton";
+    readonly roleKey: "frxETHMinter";
+    readonly abiExport: "FrxETHMinterABI";
+}, {
+    readonly protocol: "frax-ether";
+    readonly contract: "SfrxETH";
+    readonly kind: "singleton";
+    readonly roleKey: "sfrxETH";
+    readonly abiExport: "SfrxETHABI";
+}, {
+    readonly protocol: "gains-network";
+    readonly contract: "Diamond";
+    readonly kind: "singleton";
+    readonly roleKey: "diamond";
+    readonly abiExport: "DiamondABI";
+}, {
+    readonly protocol: "gains-network";
+    readonly contract: "Gns";
+    readonly kind: "address-only";
+    readonly roleKey: "gns";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "gamma";
+    readonly contract: "Hypervisor";
+    readonly kind: "interface";
+    readonly abiExport: "HypervisorABI";
+}, {
+    readonly protocol: "gamma";
+    readonly contract: "UniProxy";
+    readonly kind: "singleton";
+    readonly roleKey: "uniProxy";
+    readonly abiExport: "UniProxyABI";
+    readonly chains: readonly [137];
+}, {
+    readonly protocol: "gamma";
+    readonly contract: "UniProxyLegacy";
+    readonly kind: "singleton";
+    readonly roleKey: "uniProxy";
+    readonly abiExport: "UniProxyLegacyABI";
+    readonly chains: readonly [1];
+}, {
+    readonly protocol: "gelato";
+    readonly contract: "Automate";
+    readonly kind: "singleton";
+    readonly roleKey: "automate";
+    readonly abiExport: "GelatoAutomateABI";
+}, {
+    readonly protocol: "gho";
+    readonly contract: "Gho";
+    readonly kind: "singleton";
+    readonly roleKey: "gho";
+    readonly abiExport: "GhoTokenABI";
+}, {
+    readonly protocol: "gmx-v1";
+    readonly contract: "PositionRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "positionRouter";
+    readonly abiExport: "PositionRouterABI";
+}, {
+    readonly protocol: "gmx-v1";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "RouterABI";
+}, {
+    readonly protocol: "gmx-v1";
+    readonly contract: "Vault";
+    readonly kind: "singleton";
+    readonly roleKey: "vault";
+    readonly abiExport: "VaultABI";
+}, {
+    readonly protocol: "gmx-v1";
+    readonly contract: "Glp";
+    readonly kind: "address-only";
+    readonly roleKey: "glp";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "gmx-v2";
+    readonly contract: "ExchangeRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "exchangeRouter";
+    readonly abiExport: "ExchangeRouterABI";
+}, {
+    readonly protocol: "gmx-v2";
+    readonly contract: "DataStore";
+    readonly kind: "address-only";
+    readonly roleKey: "dataStore";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "harvest";
+    readonly contract: "Vault";
+    readonly kind: "interface";
+    readonly abiExport: "VaultABI";
+}, {
+    readonly protocol: "harvest";
+    readonly contract: "Controller";
+    readonly kind: "address-only";
+    readonly roleKey: "controller";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "harvest";
+    readonly contract: "Farm";
+    readonly kind: "address-only";
+    readonly roleKey: "farm";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "harvest";
+    readonly contract: "DepositHelper";
+    readonly kind: "address-only";
+    readonly roleKey: "depositHelper";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "hegic";
+    readonly contract: "OperationalTreasury";
+    readonly kind: "singleton";
+    readonly roleKey: "operationalTreasury";
+    readonly abiExport: "HegicABI";
+}, {
+    readonly protocol: "hegic";
+    readonly contract: "Hegic";
+    readonly kind: "address-only";
+    readonly roleKey: "hegic";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "hop";
+    readonly contract: "L1EthBridge";
+    readonly kind: "singleton";
+    readonly roleKey: "l1EthBridge";
+    readonly abiExport: "HopL1BridgeABI";
+}, {
+    readonly protocol: "hop";
+    readonly contract: "L1UsdcBridge";
+    readonly kind: "singleton";
+    readonly roleKey: "l1UsdcBridge";
+    readonly abiExport: "HopL1BridgeABI";
+}, {
+    readonly protocol: "hop";
+    readonly contract: "L2AmmWrapper";
+    readonly kind: "singleton";
+    readonly roleKey: "l2AmmWrapper";
+    readonly abiExport: "HopL2AmmWrapperABI";
+}, {
+    readonly protocol: "hyperlane";
+    readonly contract: "Mailbox";
+    readonly kind: "singleton";
+    readonly roleKey: "mailbox";
+    readonly abiExport: "HyperlaneMailboxABI";
+}, {
+    readonly protocol: "instadapp";
+    readonly contract: "FlashloanAggregator";
+    readonly kind: "singleton";
+    readonly roleKey: "flashloanAggregator";
+    readonly abiExport: "FlashAggregatorABI";
+}, {
+    readonly protocol: "kelp";
+    readonly contract: "LRTDepositPool";
+    readonly kind: "singleton";
+    readonly roleKey: "lrtDepositPool";
+    readonly abiExport: "LRTDepositPoolABI";
+}, {
+    readonly protocol: "kelp";
+    readonly contract: "RsETH";
+    readonly kind: "singleton";
+    readonly roleKey: "rsETH";
+    readonly abiExport: "RsETHABI";
+}, {
+    readonly protocol: "kim";
+    readonly contract: "V2Router";
+    readonly kind: "singleton";
+    readonly roleKey: "v2Router";
+    readonly abiExport: "KimRouterABI";
+}, {
+    readonly protocol: "kyberswap";
+    readonly contract: "ElasticRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "elasticRouter";
+    readonly abiExport: "KyberSwapElasticRouterABI";
+}, {
+    readonly protocol: "kyberswap";
+    readonly contract: "MetaAggregationRouterV2";
+    readonly kind: "singleton";
+    readonly roleKey: "metaAggregationRouterV2";
+    readonly abiExport: "KyberSwapMetaAggregationRouterABI";
+}, {
+    readonly protocol: "kyberswap";
+    readonly contract: "ElasticFactory";
+    readonly kind: "address-only";
+    readonly roleKey: "elasticFactory";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "kyberswap-aggregator";
+    readonly contract: "MetaAggregationRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "metaAggregationRouter";
+    readonly abiExport: "KyberSwapMetaAggregationRouterABI";
+}, {
+    readonly protocol: "layerbank";
+    readonly contract: "LToken";
+    readonly kind: "interface";
+    readonly abiExport: "LTokenABI";
+}, {
+    readonly protocol: "layerbank";
+    readonly contract: "Core";
+    readonly kind: "singleton";
+    readonly roleKey: "core";
+    readonly abiExport: "LayerBankCoreABI";
+}, {
+    readonly protocol: "layerzero";
+    readonly contract: "EndpointV2";
+    readonly kind: "singleton";
+    readonly roleKey: "endpointV2";
+    readonly abiExport: "LayerZeroEndpointV2ABI";
+}, {
+    readonly protocol: "level-finance";
+    readonly contract: "LiquidityPool";
+    readonly kind: "singleton";
+    readonly roleKey: "liquidityPool";
+    readonly abiExport: "LiquidityPoolABI";
+}, {
+    readonly protocol: "lido";
+    readonly contract: "StETH";
+    readonly kind: "singleton";
+    readonly roleKey: "stETH";
+    readonly abiExport: "LidoABI";
+}, {
+    readonly protocol: "lido";
+    readonly contract: "WstETH";
+    readonly kind: "singleton";
+    readonly roleKey: "wstETH";
+    readonly abiExport: "WstETHABI";
+    readonly caveats: readonly ["wrap(uint256) is not available on arbitrum: Arbitrum wstETH is the bridged ERC20Bridged token: wrapping and the stETH rate exist only on the Ethereum WstETH", "unwrap(uint256) is not available on arbitrum: Arbitrum wstETH is the bridged ERC20Bridged token: wrapping and the stETH rate exist only on the Ethereum WstETH", "getStETHByWstETH(uint256) is not available on arbitrum: Arbitrum wstETH is the bridged ERC20Bridged token: wrapping and the stETH rate exist only on the Ethereum WstETH", "getWstETHByStETH(uint256) is not available on arbitrum: Arbitrum wstETH is the bridged ERC20Bridged token: wrapping and the stETH rate exist only on the Ethereum WstETH"];
+}, {
+    readonly protocol: "lifi";
+    readonly contract: "LiFiDiamond";
+    readonly kind: "singleton";
+    readonly roleKey: "lifiDiamond";
+    readonly abiExport: "LiFiDiamondABI";
+    readonly caveats: readonly ["startBridgeTokensViaAcrossV4((bytes32,string,string,address,address,address,uint256,uint256,bool,bool),(bytes32,bytes32,bytes32,bytes32,uint256,uint128,bytes32,uint32,uint32,uint32,bytes)) is not available on gnosis: this chain's diamond has no Across V4 facet: facetAddress returns zero for the selector", "startBridgeTokensViaAcrossV4((bytes32,string,string,address,address,address,uint256,uint256,bool,bool),(bytes32,bytes32,bytes32,bytes32,uint256,uint128,bytes32,uint32,uint32,uint32,bytes)) is not available on fantom: this chain's diamond has no Across V4 facet: facetAddress returns zero for the selector", "startBridgeTokensViaAcrossV4((bytes32,string,string,address,address,address,uint256,uint256,bool,bool),(bytes32,bytes32,bytes32,bytes32,uint256,uint128,bytes32,uint32,uint32,uint32,bytes)) is not available on avalanche: this chain's diamond has no Across V4 facet: facetAddress returns zero for the selector"];
+}, {
+    readonly protocol: "linea-bridge";
+    readonly contract: "L1MessageService";
+    readonly kind: "singleton";
+    readonly roleKey: "l1MessageService";
+    readonly abiExport: "LineaL1MessageServiceABI";
+}, {
+    readonly protocol: "linea-bridge";
+    readonly contract: "L2MessageService";
+    readonly kind: "address-only";
+    readonly roleKey: "l2MessageService";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "liquity-v1";
+    readonly contract: "BorrowerOperations";
+    readonly kind: "singleton";
+    readonly roleKey: "borrowerOperations";
+    readonly abiExport: "BorrowerOperationsABI";
+}, {
+    readonly protocol: "liquity-v1";
+    readonly contract: "Lusd";
+    readonly kind: "address-only";
+    readonly roleKey: "lusd";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "liquity-v2";
+    readonly contract: "Bold";
+    readonly kind: "singleton";
+    readonly roleKey: "bold";
+    readonly abiExport: "BoldTokenABI";
+}, {
+    readonly protocol: "lynex";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "LynexRouterABI";
+}, {
+    readonly protocol: "maker";
+    readonly contract: "Pot";
+    readonly kind: "singleton";
+    readonly roleKey: "pot";
+    readonly abiExport: "PotABI";
+}, {
+    readonly protocol: "maker";
+    readonly contract: "SDAI";
+    readonly kind: "singleton";
+    readonly roleKey: "sDAI";
+    readonly abiExport: "SavingsDaiABI";
+}, {
+    readonly protocol: "maker";
+    readonly contract: "Dai";
+    readonly kind: "address-only";
+    readonly roleKey: "dai";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "maker";
+    readonly contract: "Usds";
+    readonly kind: "address-only";
+    readonly roleKey: "usds";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "maker";
+    readonly contract: "Vat";
+    readonly kind: "address-only";
+    readonly roleKey: "vat";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "mantle-meth";
+    readonly contract: "METH";
+    readonly kind: "singleton";
+    readonly roleKey: "mETH";
+    readonly abiExport: "METHABI";
+}, {
+    readonly protocol: "mantle-meth";
+    readonly contract: "Staking";
+    readonly kind: "singleton";
+    readonly roleKey: "staking";
+    readonly abiExport: "METHStakingABI";
+}, {
+    readonly protocol: "maverick";
+    readonly contract: "V2Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "v2Factory";
+    readonly abiExport: "MaverickV2FactoryABI";
+    readonly caveats: readonly ["lookup(address,address,uint256,uint256) is checked against the deployed bytecode only: the MaverickV2Factory has no verified source on Sourcify, Blockscout or Routescan; the selector is proven by the factory bytecode, and the address[] output is not verifiable"];
+}, {
+    readonly protocol: "maverick";
+    readonly contract: "V2Router";
+    readonly kind: "singleton";
+    readonly roleKey: "v2Router";
+    readonly abiExport: "MaverickV2RouterABI";
+}, {
+    readonly protocol: "maverick";
+    readonly contract: "V2Pool";
+    readonly kind: "interface";
+    readonly abiExport: "MaverickV2PoolABI";
+}, {
+    readonly protocol: "moonwell";
+    readonly contract: "MToken";
+    readonly kind: "interface";
+    readonly abiExport: "MTokenABI";
+}, {
+    readonly protocol: "moonwell";
+    readonly contract: "Comptroller";
+    readonly kind: "singleton";
+    readonly roleKey: "comptroller";
+    readonly abiExport: "MoonwellComptrollerABI";
+}, {
+    readonly protocol: "morpho-blue";
+    readonly contract: "Morpho";
+    readonly kind: "singleton";
+    readonly roleKey: "morpho";
+    readonly abiExport: "MorphoABI";
+}, {
+    readonly protocol: "morpho-blue";
+    readonly contract: "Bundler3";
+    readonly kind: "address-only";
+    readonly roleKey: "bundler3";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "mux-protocol";
+    readonly contract: "LiquidityPool";
+    readonly kind: "singleton";
+    readonly roleKey: "liquidityPool";
+    readonly abiExport: "LiquidityPoolABI";
+}, {
+    readonly protocol: "mux-protocol";
+    readonly contract: "OrderBook";
+    readonly kind: "singleton";
+    readonly roleKey: "orderBook";
+    readonly abiExport: "OrderBookABI";
+}, {
+    readonly protocol: "olympus";
+    readonly contract: "Staking";
+    readonly kind: "singleton";
+    readonly roleKey: "staking";
+    readonly abiExport: "StakingABI";
+}, {
+    readonly protocol: "olympus";
+    readonly contract: "Ohm";
+    readonly kind: "address-only";
+    readonly roleKey: "ohm";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "olympus";
+    readonly contract: "StakingHelper";
+    readonly kind: "address-only";
+    readonly roleKey: "stakingHelper";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "oneinch";
+    readonly contract: "AggregationRouterV6";
+    readonly kind: "singleton";
+    readonly roleKey: "aggregationRouterV6";
+    readonly abiExport: "AggregationRouterV6ABI";
+}, {
+    readonly protocol: "openocean";
+    readonly contract: "ExchangeV2";
+    readonly kind: "singleton";
+    readonly roleKey: "exchangeV2";
+    readonly abiExport: "OpenOceanExchangeV2ABI";
+}, {
+    readonly protocol: "optimism-bridge";
+    readonly contract: "L1StandardBridge";
+    readonly kind: "singleton";
+    readonly roleKey: "l1StandardBridge";
+    readonly abiExport: "OptimismL1StandardBridgeABI";
+}, {
+    readonly protocol: "optimism-bridge";
+    readonly contract: "L2StandardBridge";
+    readonly kind: "address-only";
+    readonly roleKey: "l2StandardBridge";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "opyn";
+    readonly contract: "Controller";
+    readonly kind: "singleton";
+    readonly roleKey: "controller";
+    readonly abiExport: "ControllerABI";
+}, {
+    readonly protocol: "opyn";
+    readonly contract: "OSQTH";
+    readonly kind: "address-only";
+    readonly roleKey: "oSQTH";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "pancakeswap-v2";
+    readonly contract: "Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "factory";
+    readonly abiExport: "PancakeSwapV2FactoryABI";
+}, {
+    readonly protocol: "pancakeswap-v2";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "PancakeSwapV2RouterABI";
+}, {
+    readonly protocol: "pancakeswap-v2";
+    readonly contract: "Pair";
+    readonly kind: "interface";
+    readonly abiExport: "PancakeSwapV2PairABI";
+}, {
+    readonly protocol: "pancakeswap-v3";
+    readonly contract: "Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "factory";
+    readonly abiExport: "PancakeSwapV3FactoryABI";
+}, {
+    readonly protocol: "pancakeswap-v3";
+    readonly contract: "NonfungiblePositionManager";
+    readonly kind: "singleton";
+    readonly roleKey: "nonfungiblePositionManager";
+    readonly abiExport: "PancakeSwapV3NFPMABI";
+}, {
+    readonly protocol: "pancakeswap-v3";
+    readonly contract: "SmartRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "smartRouter";
+    readonly abiExport: "PancakeSwapV3SmartRouterABI";
+}, {
+    readonly protocol: "pancakeswap-v3";
+    readonly contract: "Pool";
+    readonly kind: "interface";
+    readonly abiExport: "PancakeSwapV3PoolABI";
+}, {
+    readonly protocol: "paraswap";
+    readonly contract: "AugustusV5";
+    readonly kind: "singleton";
+    readonly roleKey: "augustusV5";
+    readonly abiExport: "AugustusV5ABI";
+    readonly caveats: readonly ["simpleSwap((address,address,uint256,uint256,uint256,address[],bytes,uint256[],uint256[],address,address,uint256,bytes,uint256,bytes16)) is not available on base: Augustus V5 on Base has no SimpleSwap router registered: getImplementation returns zero for the selector"];
+}, {
+    readonly protocol: "paraswap";
+    readonly contract: "AugustusV6";
+    readonly kind: "address-only";
+    readonly roleKey: "augustusV6";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "pendle";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "PendleRouterABI";
+}, {
+    readonly protocol: "permit2";
+    readonly contract: "Permit2";
+    readonly kind: "singleton";
+    readonly roleKey: "permit2";
+    readonly abiExport: "Permit2ABI";
+}, {
+    readonly protocol: "perpetual-protocol";
+    readonly contract: "ClearingHouse";
+    readonly kind: "singleton";
+    readonly roleKey: "clearingHouse";
+    readonly abiExport: "ClearingHouseABI";
+}, {
+    readonly protocol: "perpetual-protocol";
+    readonly contract: "Vault";
+    readonly kind: "singleton";
+    readonly roleKey: "vault";
+    readonly abiExport: "VaultABI";
+}, {
+    readonly protocol: "polygon-bridge";
+    readonly contract: "RootChainManager";
+    readonly kind: "singleton";
+    readonly roleKey: "rootChainManager";
+    readonly abiExport: "PolygonRootChainManagerABI";
+}, {
+    readonly protocol: "polygon-bridge";
+    readonly contract: "Erc20Predicate";
+    readonly kind: "address-only";
+    readonly roleKey: "erc20Predicate";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "polygon-bridge";
+    readonly contract: "EtherPredicate";
+    readonly kind: "address-only";
+    readonly roleKey: "etherPredicate";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "polygon-bridge";
+    readonly contract: "ChildChainManager";
+    readonly kind: "address-only";
+    readonly roleKey: "childChainManager";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "premia";
+    readonly contract: "Diamond";
+    readonly kind: "interface";
+    readonly abiExport: "DiamondABI";
+}, {
+    readonly protocol: "premia";
+    readonly contract: "PoolFactory";
+    readonly kind: "address-only";
+    readonly roleKey: "poolFactory";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "puffer";
+    readonly contract: "PufferVault";
+    readonly kind: "singleton";
+    readonly roleKey: "pufferVault";
+    readonly abiExport: "PufferVaultABI";
+}, {
+    readonly protocol: "puffer";
+    readonly contract: "PufETH";
+    readonly kind: "address-only";
+    readonly roleKey: "pufETH";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "pyth";
+    readonly contract: "Oracle";
+    readonly kind: "singleton";
+    readonly roleKey: "oracle";
+    readonly abiExport: "PythOracleABI";
+    readonly caveats: readonly ["updatePriceFeeds(bytes[]) is checked against the deployed bytecode only: the Pyth implementation behind the proxy (0x3f38404a2e3cb949bcdfa19a5c3bdf3fe375feb0) has no verified source on Sourcify, Blockscout or Routescan; the selector is proven by its bytecode", "getUpdateFee(bytes[]) is checked against the deployed bytecode only: the Pyth implementation behind the proxy (0x3f38404a2e3cb949bcdfa19a5c3bdf3fe375feb0) has no verified source on Sourcify, Blockscout or Routescan; the selector is proven by its bytecode", "getPrice(bytes32) is checked against the deployed bytecode only: the Pyth implementation behind the proxy (0x3f38404a2e3cb949bcdfa19a5c3bdf3fe375feb0) has no verified source on Sourcify, Blockscout or Routescan; the selector is proven by its bytecode; the PythStructs.Price output types come from the Pyth SDK and are not verifiable"];
+}, {
+    readonly protocol: "quickswap";
+    readonly contract: "V2Router";
+    readonly kind: "singleton";
+    readonly roleKey: "v2Router";
+    readonly abiExport: "QuickSwapV2RouterABI";
+}, {
+    readonly protocol: "quickswap";
+    readonly contract: "V3SwapRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "v3SwapRouter";
+    readonly abiExport: "QuickSwapV3SwapRouterABI";
+}, {
+    readonly protocol: "quickswap";
+    readonly contract: "V2Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "v2Factory";
+    readonly abiExport: "QuickSwapV2FactoryABI";
+}, {
+    readonly protocol: "quickswap";
+    readonly contract: "V2Pair";
+    readonly kind: "interface";
+    readonly abiExport: "QuickSwapV2PairABI";
+}, {
+    readonly protocol: "quickswap";
+    readonly contract: "V3Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "v3Factory";
+    readonly abiExport: "QuickSwapV3FactoryABI";
+}, {
+    readonly protocol: "quickswap";
+    readonly contract: "V3Pool";
+    readonly kind: "interface";
+    readonly abiExport: "QuickSwapV3PoolABI";
+}, {
+    readonly protocol: "radiant";
+    readonly contract: "LendingPool";
+    readonly kind: "address-only";
+    readonly roleKey: "lendingPool";
+    readonly caveats: readonly ["RadiantLendingPoolABI does not describe this deployment: the only listed deployment (Arbitrum LendingPool proxy 0xF4B1486DD74D07706052A33d31d7c0AAFD0659E1) now delegates to a three-function stub (0x3d4c56cdb97355807157f5c7d4f54957f0e9af44): deposit/withdraw/borrow/repay no longer exist on-chain, and no verified source exists for the stub"];
+}, {
+    readonly protocol: "ramses";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "RamsesRouterABI";
+}, {
+    readonly protocol: "reflexer";
+    readonly contract: "CoinJoin";
+    readonly kind: "singleton";
+    readonly roleKey: "coinJoin";
+    readonly abiExport: "CoinJoinABI";
+}, {
+    readonly protocol: "reflexer";
+    readonly contract: "ETHJoin";
+    readonly kind: "singleton";
+    readonly roleKey: "ethJoin";
+    readonly abiExport: "ETHJoinABI";
+}, {
+    readonly protocol: "reflexer";
+    readonly contract: "SAFEEngine";
+    readonly kind: "singleton";
+    readonly roleKey: "safeEngine";
+    readonly abiExport: "SAFEEngineABI";
+}, {
+    readonly protocol: "reflexer";
+    readonly contract: "Rai";
+    readonly kind: "address-only";
+    readonly roleKey: "rai";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "renzo";
+    readonly contract: "EzETH";
+    readonly kind: "singleton";
+    readonly roleKey: "ezETH";
+    readonly abiExport: "EzETHABI";
+}, {
+    readonly protocol: "renzo";
+    readonly contract: "RestakeManager";
+    readonly kind: "singleton";
+    readonly roleKey: "restakeManager";
+    readonly abiExport: "RestakeManagerABI";
+}, {
+    readonly protocol: "rocket-pool";
+    readonly contract: "RETH";
+    readonly kind: "singleton";
+    readonly roleKey: "rETH";
+    readonly abiExport: "RETHABI";
+}, {
+    readonly protocol: "rocket-pool";
+    readonly contract: "RocketDepositPool";
+    readonly kind: "singleton";
+    readonly roleKey: "rocketDepositPool";
+    readonly abiExport: "RocketDepositPoolABI";
+}, {
+    readonly protocol: "sablier";
+    readonly contract: "LockupLinear";
+    readonly kind: "singleton";
+    readonly roleKey: "lockupLinear";
+    readonly abiExport: "LockupLinearABI";
+}, {
+    readonly protocol: "safe";
+    readonly contract: "SafeV141";
+    readonly kind: "singleton";
+    readonly roleKey: "safeV141";
+    readonly abiExport: "SafeABI";
+}, {
+    readonly protocol: "safe";
+    readonly contract: "SafeL2V130";
+    readonly kind: "singleton";
+    readonly roleKey: "safeL2V130";
+    readonly abiExport: "SafeABI";
+}, {
+    readonly protocol: "scroll-bridge";
+    readonly contract: "L1GatewayRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "l1GatewayRouter";
+    readonly abiExport: "ScrollL1GatewayRouterABI";
+}, {
+    readonly protocol: "scroll-bridge";
+    readonly contract: "L1ScrollMessenger";
+    readonly kind: "singleton";
+    readonly roleKey: "l1ScrollMessenger";
+    readonly abiExport: "ScrollL1MessengerABI";
+}, {
+    readonly protocol: "scroll-bridge";
+    readonly contract: "L2ScrollMessenger";
+    readonly kind: "address-only";
+    readonly roleKey: "l2ScrollMessenger";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "scroll-bridge";
+    readonly contract: "L2GatewayRouter";
+    readonly kind: "address-only";
+    readonly roleKey: "l2GatewayRouter";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "seamless";
+    readonly contract: "Pool";
+    readonly kind: "singleton";
+    readonly roleKey: "pool";
+    readonly abiExport: "SeamlessPoolABI";
+}, {
+    readonly protocol: "seamless";
+    readonly contract: "PoolAddressesProvider";
+    readonly kind: "address-only";
+    readonly roleKey: "poolAddressesProvider";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "seaport";
+    readonly contract: "SeaportV16";
+    readonly kind: "singleton";
+    readonly roleKey: "seaportV16";
+    readonly abiExport: "SeaportABI";
+}, {
+    readonly protocol: "silo";
+    readonly contract: "Silo";
+    readonly kind: "interface";
+    readonly abiExport: "SiloABI";
+}, {
+    readonly protocol: "silo";
+    readonly contract: "SiloRepository";
+    readonly kind: "singleton";
+    readonly roleKey: "siloRepository";
+    readonly abiExport: "SiloRepositoryABI";
+}, {
+    readonly protocol: "socket";
+    readonly contract: "SocketGateway";
+    readonly kind: "singleton";
+    readonly roleKey: "socketGateway";
+    readonly abiExport: "SocketGatewayABI";
+}, {
+    readonly protocol: "sommelier";
+    readonly contract: "Cellar";
+    readonly kind: "interface";
+    readonly abiExport: "CellarABI";
+}, {
+    readonly protocol: "sommelier";
+    readonly contract: "CellarRouter";
+    readonly kind: "address-only";
+    readonly roleKey: "cellarRouter";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "spark";
+    readonly contract: "Pool";
+    readonly kind: "singleton";
+    readonly roleKey: "pool";
+    readonly abiExport: "SparkPoolABI";
+}, {
+    readonly protocol: "spark";
+    readonly contract: "PoolAddressesProvider";
+    readonly kind: "address-only";
+    readonly roleKey: "poolAddressesProvider";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "spookyswap";
+    readonly contract: "V2Router";
+    readonly kind: "singleton";
+    readonly roleKey: "v2Router";
+    readonly abiExport: "SpookySwapRouterABI";
+    readonly caveats: readonly ["swapExactTokensForTokens(uint256,uint256,address[],address,uint256) is checked against the deployed bytecode only: the Fantom router has no verified source on Sourcify, and neither Blockscout nor Routescan serves Fantom keylessly; the selector is proven by the router bytecode (a UniswapV2Router02 fork: factory() and WETH() answer)", "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256) is checked against the deployed bytecode only: the Fantom router has no verified source on Sourcify, and neither Blockscout nor Routescan serves Fantom keylessly; the selector is proven by the router bytecode (a UniswapV2Router02 fork: factory() and WETH() answer)", "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256) is checked against the deployed bytecode only: the Fantom router has no verified source on Sourcify, and neither Blockscout nor Routescan serves Fantom keylessly; the selector is proven by the router bytecode (a UniswapV2Router02 fork: factory() and WETH() answer)"];
+}, {
+    readonly protocol: "squid";
+    readonly contract: "SquidRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "squidRouter";
+    readonly abiExport: "SquidRouterABI";
+}, {
+    readonly protocol: "stader";
+    readonly contract: "ETHx";
+    readonly kind: "singleton";
+    readonly roleKey: "ETHx";
+    readonly abiExport: "ETHxABI";
+}, {
+    readonly protocol: "stader";
+    readonly contract: "StakePoolManager";
+    readonly kind: "singleton";
+    readonly roleKey: "stakePoolManager";
+    readonly abiExport: "StakePoolManagerABI";
+}, {
+    readonly protocol: "stargate";
+    readonly contract: "PoolNative";
+    readonly kind: "singleton";
+    readonly roleKey: "poolNative";
+    readonly abiExport: "StargatePoolABI";
+}, {
+    readonly protocol: "stargate";
+    readonly contract: "PoolUSDC";
+    readonly kind: "singleton";
+    readonly roleKey: "poolUSDC";
+    readonly abiExport: "StargatePoolABI";
+}, {
+    readonly protocol: "stargate";
+    readonly contract: "PoolUSDT";
+    readonly kind: "singleton";
+    readonly roleKey: "poolUSDT";
+    readonly abiExport: "StargatePoolABI";
+}, {
+    readonly protocol: "superfluid";
+    readonly contract: "CFAForwarder";
+    readonly kind: "singleton";
+    readonly roleKey: "cfaForwarder";
+    readonly abiExport: "CFAForwarderABI";
+}, {
+    readonly protocol: "superfluid";
+    readonly contract: "Host";
+    readonly kind: "address-only";
+    readonly roleKey: "host";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "sushiswap-v2";
+    readonly contract: "Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "factory";
+    readonly abiExport: "SushiSwapV2FactoryABI";
+}, {
+    readonly protocol: "sushiswap-v2";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "SushiSwapV2RouterABI";
+}, {
+    readonly protocol: "sushiswap-v2";
+    readonly contract: "Pair";
+    readonly kind: "interface";
+    readonly abiExport: "SushiSwapV2PairABI";
+}, {
+    readonly protocol: "swell";
+    readonly contract: "RswETH";
+    readonly kind: "singleton";
+    readonly roleKey: "rswETH";
+    readonly abiExport: "RswETHABI";
+}, {
+    readonly protocol: "swell";
+    readonly contract: "SwETH";
+    readonly kind: "singleton";
+    readonly roleKey: "swETH";
+    readonly abiExport: "SwETHABI";
+}, {
+    readonly protocol: "synapse";
+    readonly contract: "SynapseBridge";
+    readonly kind: "singleton";
+    readonly roleKey: "synapseBridge";
+    readonly abiExport: "SynapseBridgeABI";
+}, {
+    readonly protocol: "synapse";
+    readonly contract: "CctpRouter";
+    readonly kind: "address-only";
+    readonly roleKey: "cctpRouter";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "syncswap";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "SyncSwapRouterABI";
+}, {
+    readonly protocol: "synthetix-v3";
+    readonly contract: "CoreProxy";
+    readonly kind: "singleton";
+    readonly roleKey: "coreProxy";
+    readonly abiExport: "CoreProxyABI";
+}, {
+    readonly protocol: "synthetix-v3";
+    readonly contract: "PerpsMarketProxy";
+    readonly kind: "singleton";
+    readonly roleKey: "perpsMarketProxy";
+    readonly abiExport: "PerpsMarketProxyABI";
+}, {
+    readonly protocol: "synthra-v3";
+    readonly contract: "Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "factory";
+    readonly abiExport: "SynthraV3FactoryABI";
+    readonly caveats: readonly ["getPool(address,address,uint24) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode", "createPool(address,address,uint24) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode"];
+}, {
+    readonly protocol: "synthra-v3";
+    readonly contract: "SwapRouter02";
+    readonly kind: "singleton";
+    readonly roleKey: "swapRouter02";
+    readonly abiExport: "SynthraV3SwapRouter02ABI";
+    readonly caveats: readonly ["exactInputSingle((address,address,uint24,address,uint256,uint256,uint160)) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode", "exactInput((bytes,address,uint256,uint256)) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode", "exactOutputSingle((address,address,uint24,address,uint256,uint256,uint160)) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode", "exactOutput((bytes,address,uint256,uint256)) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode"];
+}, {
+    readonly protocol: "synthra-v3";
+    readonly contract: "QuoterV2";
+    readonly kind: "singleton";
+    readonly roleKey: "quoterV2";
+    readonly abiExport: "SynthraV3QuoterV2ABI";
+    readonly caveats: readonly ["quoteExactInputSingle((address,address,uint256,uint24,uint160)) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode"];
+}, {
+    readonly protocol: "synthra-v3";
+    readonly contract: "NonfungiblePositionManager";
+    readonly kind: "singleton";
+    readonly roleKey: "nonfungiblePositionManager";
+    readonly abiExport: "SynthraV3NonfungiblePositionManagerABI";
+    readonly caveats: readonly ["mint((address,address,uint24,int24,int24,uint256,uint256,uint256,uint256,address,uint256)) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode", "increaseLiquidity((uint256,uint256,uint256,uint256,uint256,uint256)) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode", "decreaseLiquidity((uint256,uint128,uint256,uint256,uint256)) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode", "collect((uint256,address,uint128,uint128)) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge), nor on Robinhood Chain's; Synthra V3 is a Uniswap V3 fork (renamed pool callbacks only), so the fragment is Uniswap V3's, and the selector is proven by the bytecode"];
+}, {
+    readonly protocol: "synthra-v3";
+    readonly contract: "Pool";
+    readonly kind: "interface";
+    readonly abiExport: "SynthraV3PoolABI";
+}, {
+    readonly protocol: "thales";
+    readonly contract: "SpeedMarketsAMM";
+    readonly kind: "singleton";
+    readonly roleKey: "speedMarketsAMM";
+    readonly abiExport: "SpeedMarketsAMMABI";
+}, {
+    readonly protocol: "thales";
+    readonly contract: "ThalesAMM";
+    readonly kind: "singleton";
+    readonly roleKey: "thalesAMM";
+    readonly abiExport: "ThalesAMMABI";
+}, {
+    readonly protocol: "thales";
+    readonly contract: "PositionalMarket";
+    readonly kind: "interface";
+    readonly abiExport: "PositionalMarketABI";
+}, {
+    readonly protocol: "thena";
+    readonly contract: "RouterV2";
+    readonly kind: "singleton";
+    readonly roleKey: "routerV2";
+    readonly abiExport: "ThenaRouterABI";
+}, {
+    readonly protocol: "thruster";
+    readonly contract: "V3SwapRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "v3SwapRouter";
+    readonly abiExport: "ThrusterV3SwapRouterABI";
+}, {
+    readonly protocol: "tokemak";
+    readonly contract: "Autopool";
+    readonly kind: "interface";
+    readonly abiExport: "AutopoolABI";
+}, {
+    readonly protocol: "tokemak";
+    readonly contract: "Toke";
+    readonly kind: "address-only";
+    readonly roleKey: "toke";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "tokemak";
+    readonly contract: "SystemRegistry";
+    readonly kind: "address-only";
+    readonly roleKey: "systemRegistry";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "tokemak";
+    readonly contract: "AutopoolRegistry";
+    readonly kind: "address-only";
+    readonly roleKey: "autopoolRegistry";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "trader-joe";
+    readonly contract: "LBFactory";
+    readonly kind: "singleton";
+    readonly roleKey: "lbFactory";
+    readonly abiExport: "LBFactoryABI";
+}, {
+    readonly protocol: "trader-joe";
+    readonly contract: "LBRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "lbRouter";
+    readonly abiExport: "LBRouterABI";
+}, {
+    readonly protocol: "trader-joe";
+    readonly contract: "LBPair";
+    readonly kind: "interface";
+    readonly abiExport: "LBPairABI";
+}, {
+    readonly protocol: "uniswap-v2";
+    readonly contract: "Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "factory";
+    readonly abiExport: "UniswapV2FactoryABI";
+}, {
+    readonly protocol: "uniswap-v2";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "UniswapV2RouterABI";
+}, {
+    readonly protocol: "uniswap-v2";
+    readonly contract: "Pair";
+    readonly kind: "interface";
+    readonly abiExport: "UniswapV2PairABI";
+}, {
+    readonly protocol: "uniswap-v3";
+    readonly contract: "Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "factory";
+    readonly abiExport: "UniswapV3FactoryABI";
+}, {
+    readonly protocol: "uniswap-v3";
+    readonly contract: "NonfungiblePositionManager";
+    readonly kind: "singleton";
+    readonly roleKey: "nonfungiblePositionManager";
+    readonly abiExport: "UniswapV3NonfungiblePositionManagerABI";
+}, {
+    readonly protocol: "uniswap-v3";
+    readonly contract: "QuoterV2";
+    readonly kind: "singleton";
+    readonly roleKey: "quoterV2";
+    readonly abiExport: "UniswapV3QuoterV2ABI";
+}, {
+    readonly protocol: "uniswap-v3";
+    readonly contract: "SwapRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "swapRouter";
+    readonly abiExport: "UniswapV3SwapRouterABI";
+}, {
+    readonly protocol: "uniswap-v3";
+    readonly contract: "SwapRouter02";
+    readonly kind: "singleton";
+    readonly roleKey: "swapRouter02";
+    readonly abiExport: "UniswapV3SwapRouter02ABI";
+}, {
+    readonly protocol: "uniswap-v3";
+    readonly contract: "Pool";
+    readonly kind: "interface";
+    readonly abiExport: "UniswapV3PoolABI";
+}, {
+    readonly protocol: "uniswap-v4";
+    readonly contract: "PoolManager";
+    readonly kind: "singleton";
+    readonly roleKey: "poolManager";
+    readonly abiExport: "UniswapV4PoolManagerABI";
+}, {
+    readonly protocol: "uniswap-v4";
+    readonly contract: "PositionManager";
+    readonly kind: "singleton";
+    readonly roleKey: "positionManager";
+    readonly abiExport: "UniswapV4PositionManagerABI";
+}, {
+    readonly protocol: "uniswap-v4";
+    readonly contract: "UniversalRouter";
+    readonly kind: "singleton";
+    readonly roleKey: "universalRouter";
+    readonly abiExport: "UniswapV4UniversalRouterABI";
+}, {
+    readonly protocol: "uniswap-v4";
+    readonly contract: "StateView";
+    readonly kind: "singleton";
+    readonly roleKey: "stateView";
+    readonly abiExport: "UniswapV4StateViewABI";
+}, {
+    readonly protocol: "unitflow-v3";
+    readonly contract: "Factory";
+    readonly kind: "singleton";
+    readonly roleKey: "factory";
+    readonly abiExport: "UnitFlowV3FactoryABI";
+    readonly caveats: readonly ["getPool(address,address,uint24) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge); the fragment is IUnitFlowV3Factory's (UnitFlow-Finance/UnitFlowV3-contract) and the selector is proven by the factory bytecode", "feeAmountTickSpacing(uint24) is checked against the deployed bytecode only: the Arc deployment has no verified source on Sourcify, and Arc's explorer API is not served keylessly (Cloudflare challenge); the fragment is IUnitFlowV3Factory's (UnitFlow-Finance/UnitFlowV3-contract) and the selector is proven by the factory bytecode"];
+}, {
+    readonly protocol: "unitflow-v3";
+    readonly contract: "Router";
+    readonly kind: "singleton";
+    readonly roleKey: "router";
+    readonly abiExport: "UnitFlowV3RouterABI";
+}, {
+    readonly protocol: "unitflow-v3";
+    readonly contract: "Quoter";
+    readonly kind: "singleton";
+    readonly roleKey: "quoter";
+    readonly abiExport: "UnitFlowV3QuoterABI";
+}, {
+    readonly protocol: "unitflow-v3";
+    readonly contract: "Pool";
+    readonly kind: "interface";
+    readonly abiExport: "UnitFlowV3PoolABI";
+}, {
+    readonly protocol: "velodrome";
+    readonly contract: "PoolFactory";
+    readonly kind: "singleton";
+    readonly roleKey: "poolFactory";
+    readonly abiExport: "VelodromePoolFactoryABI";
+}, {
+    readonly protocol: "velodrome";
+    readonly contract: "RouterV2";
+    readonly kind: "singleton";
+    readonly roleKey: "routerV2";
+    readonly abiExport: "VelodromeRouterABI";
+}, {
+    readonly protocol: "velodrome";
+    readonly contract: "Pool";
+    readonly kind: "interface";
+    readonly abiExport: "VelodromePoolABI";
+}, {
+    readonly protocol: "venus";
+    readonly contract: "VBNB";
+    readonly kind: "singleton";
+    readonly roleKey: "vBNB";
+    readonly abiExport: "VBNBABI";
+}, {
+    readonly protocol: "venus";
+    readonly contract: "VToken";
+    readonly kind: "interface";
+    readonly abiExport: "VTokenABI";
+}, {
+    readonly protocol: "venus";
+    readonly contract: "Comptroller";
+    readonly kind: "singleton";
+    readonly roleKey: "comptroller";
+    readonly abiExport: "VenusComptrollerABI";
+    readonly caveats: readonly ["enterMarkets(address[]) is checked against the deployed bytecode only: the Diamond routes it (facetAddress) to MarketFacet 0x21f8e1471b153f49be1d645a008e4a57434eed23, which has no verified source on Sourcify or Routescan; the selector is proven by the routing only", "exitMarket(address) is checked against the deployed bytecode only: the Diamond routes it (facetAddress) to MarketFacet 0x21f8e1471b153f49be1d645a008e4a57434eed23, which has no verified source on Sourcify or Routescan; the selector is proven by the routing only"];
+}, {
+    readonly protocol: "vertex";
+    readonly contract: "Clearinghouse";
+    readonly kind: "singleton";
+    readonly roleKey: "clearinghouse";
+    readonly abiExport: "ClearinghouseABI";
+}, {
+    readonly protocol: "vertex";
+    readonly contract: "Endpoint";
+    readonly kind: "singleton";
+    readonly roleKey: "endpoint";
+    readonly abiExport: "EndpointABI";
+}, {
+    readonly protocol: "wormhole";
+    readonly contract: "CoreBridge";
+    readonly kind: "singleton";
+    readonly roleKey: "coreBridge";
+    readonly abiExport: "WormholeCoreBridgeABI";
+}, {
+    readonly protocol: "wormhole";
+    readonly contract: "TokenBridge";
+    readonly kind: "singleton";
+    readonly roleKey: "tokenBridge";
+    readonly abiExport: "WormholeTokenBridgeABI";
+}, {
+    readonly protocol: "yearn-v3";
+    readonly contract: "Vault";
+    readonly kind: "interface";
+    readonly abiExport: "YearnV3VaultABI";
+}, {
+    readonly protocol: "yearn-v3";
+    readonly contract: "VaultFactory";
+    readonly kind: "address-only";
+    readonly roleKey: "vaultFactory";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}, {
+    readonly protocol: "zerolend";
+    readonly contract: "Pool";
+    readonly kind: "singleton";
+    readonly roleKey: "pool";
+    readonly abiExport: "ZeroLendPoolABI";
+}, {
+    readonly protocol: "zerox";
+    readonly contract: "ExchangeProxy";
+    readonly kind: "singleton";
+    readonly roleKey: "exchangeProxy";
+    readonly abiExport: "ExchangeProxyABI";
+}, {
+    readonly protocol: "zksync-bridge";
+    readonly contract: "DiamondProxy";
+    readonly kind: "singleton";
+    readonly roleKey: "diamondProxy";
+    readonly abiExport: "ZkSyncDiamondProxyABI";
+}, {
+    readonly protocol: "zksync-bridge";
+    readonly contract: "L2Bridge";
+    readonly kind: "address-only";
+    readonly roleKey: "l2Bridge";
+    readonly caveats: readonly ["the registry has no ABI for this contract: its address only"];
+}];
+export interface AaveV2Contracts {
+    readonly LendingPool: Contract<typeof aaveV2Abis.LendingPoolABI>;
+}
+export interface AaveV3Contracts {
+    readonly Pool: Contract<typeof aaveV3Abis.PoolABI>;
+    readonly PoolAddressesProvider: AddressOnlyContract;
+}
+export interface AaveV4Contracts {
+    readonly MainSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly ForexSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly BluechipSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly EthenaCorrelatedSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly EthenaEcosystemSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly GoldSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly PaxgGoldSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly LombardBtcSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly UsdgPendleSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly EtherfiESpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly KelpESpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly LidoESpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly UsdgMapleESpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly Mag7Spoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly AvaxCorrelatedSpoke: Contract<typeof aaveV4Abis.AaveV4SpokeABI>;
+    readonly CoreHub: Contract<typeof aaveV4Abis.AaveV4HubABI>;
+    readonly PlusHub: Contract<typeof aaveV4Abis.AaveV4HubABI>;
+    readonly PrimeHub: Contract<typeof aaveV4Abis.AaveV4HubABI>;
+    readonly GlobalDollarHub: Contract<typeof aaveV4Abis.AaveV4HubABI>;
+    readonly EquitiesHub: Contract<typeof aaveV4Abis.AaveV4HubABI>;
+}
+export interface AbracadabraContracts {
+    readonly Cauldron: InterfaceContract<typeof abracadabraAbis.CauldronABI>;
+    readonly DegenBox: Contract<typeof abracadabraAbis.DegenBoxABI>;
+    readonly Mim: AddressOnlyContract;
+}
+export interface AcrossContracts {
+    readonly HubPool: Contract<typeof acrossAbis.AcrossHubPoolABI>;
+    readonly SpokePool: Contract<typeof acrossAbis.AcrossSpokePoolABI>;
+}
+export interface AerodromeContracts {
+    readonly PoolFactory: Contract<typeof aerodromeAbis.AerodromePoolFactoryABI>;
+    readonly Router: Contract<typeof aerodromeAbis.AerodromeRouterABI>;
+    readonly Pool: InterfaceContract<typeof aerodromeAbis.AerodromePoolABI>;
+}
+export interface AerodromeSlipstreamContracts {
+    readonly CLFactory: Contract<typeof aerodromeSlipstreamAbis.SlipstreamCLFactoryABI>;
+    readonly CLFactoryGaugeCaps: Contract<typeof aerodromeSlipstreamAbis.SlipstreamCLFactoryABI>;
+    readonly CLFactoryGaugesV3: Contract<typeof aerodromeSlipstreamAbis.SlipstreamCLFactoryABI>;
+    readonly NonfungiblePositionManager: Contract<typeof aerodromeSlipstreamAbis.SlipstreamPositionManagerABI>;
+    readonly NonfungiblePositionManagerGaugeCaps: Contract<typeof aerodromeSlipstreamAbis.SlipstreamPositionManagerABI>;
+    readonly NonfungiblePositionManagerGaugesV3: Contract<typeof aerodromeSlipstreamAbis.SlipstreamPositionManagerABI>;
+    readonly Metarouter: Contract<typeof aerodromeSlipstreamAbis.AeroMetarouterABI>;
+    readonly Pool: InterfaceContract<typeof aerodromeSlipstreamAbis.AerodromeSlipstreamPoolABI>;
+}
+export interface AevoContracts {
+    readonly DepositContract: Contract<typeof aevoAbis.DepositContractABI>;
+}
+export interface AlchemixContracts {
+    readonly AlchemistAlUSD: Contract<typeof alchemixAbis.AlchemistABI>;
+    readonly AlchemistAlETH: Contract<typeof alchemixAbis.AlchemistABI>;
+    readonly AlUSD: AddressOnlyContract;
+    readonly AlETH: AddressOnlyContract;
+}
+export interface AmbientContracts {
+    readonly CrocSwapDex: Contract<typeof ambientAbis.CrocSwapDexABI>;
+}
+export interface ArbitrumBridgeContracts {
+    readonly L1GatewayRouter: Contract<typeof arbitrumBridgeAbis.ArbitrumL1GatewayRouterABI>;
+    readonly L2GatewayRouter: AddressOnlyContract;
+}
+export interface ArrakisContracts {
+    readonly Router: Contract<typeof arrakisAbis.ArrakisRouterABI>;
+    readonly Vault: InterfaceContract<typeof arrakisAbis.ArrakisVaultABI>;
+    readonly Factory: AddressOnlyContract;
+}
+export interface AxelarContracts {
+    readonly GasService: Contract<typeof axelarAbis.AxelarGasServiceABI>;
+    readonly Gateway: Contract<typeof axelarAbis.AxelarGatewayABI>;
+    readonly ITS: Contract<typeof axelarAbis.AxelarITSABI>;
+}
+export interface BalancerV2Contracts {
+    readonly Vault: Contract<typeof balancerV2Abis.BalancerV2VaultABI>;
+}
+export interface BaseBridgeContracts {
+    readonly L1StandardBridge: Contract<typeof baseBridgeAbis.BaseL1StandardBridgeABI>;
+    readonly L2StandardBridge: AddressOnlyContract;
+}
+export interface BaseswapContracts {
+    readonly V2Router: Contract<typeof baseswapAbis.BaseSwapRouterABI>;
+}
+export interface BeefyContracts {
+    readonly Vault: InterfaceContract<typeof beefyAbis.BeefyVaultABI>;
+    readonly BIFI: AddressOnlyContract;
+}
+export interface BenqiContracts {
+    readonly Comptroller: Contract<typeof benqiAbis.BenqiComptrollerABI>;
+    readonly QiToken: InterfaceContract<typeof benqiAbis.QiTokenABI>;
+}
+export interface CamelotContracts {
+    readonly V2Router: Contract<typeof camelotAbis.CamelotV2RouterABI>;
+    readonly V3SwapRouter: Contract<typeof camelotAbis.CamelotV3SwapRouterABI>;
+    readonly V2Factory: Contract<typeof camelotAbis.CamelotV2FactoryABI>;
+    readonly V2Pair: InterfaceContract<typeof camelotAbis.CamelotV2PairABI>;
+    readonly V3Factory: Contract<typeof camelotAbis.CamelotV3FactoryABI>;
+    readonly V3Pool: InterfaceContract<typeof camelotAbis.CamelotV3PoolABI>;
+}
+export interface CbethContracts {
+    readonly CbETH: Contract<typeof cbethAbis.CbETHABI>;
+}
+export interface CctpContracts {
+    readonly TokenMessenger: Contract<typeof cctpAbis.TokenMessengerABI>;
+}
+export interface CelerContracts {
+    readonly Bridge: Contract<typeof celerAbis.CelerBridgeABI>;
+}
+export interface ChainlinkContracts {
+    readonly EthUsdFeed: Contract<typeof chainlinkAbis.AggregatorV3ABI>;
+    readonly FeedRegistry: Contract<typeof chainlinkAbis.FeedRegistryABI>;
+    readonly VrfV2Coordinator: AddressOnlyContract;
+}
+export interface ChainlinkCcipContracts {
+    readonly Router: Contract<typeof chainlinkCcipAbis.CCIPRouterABI>;
+}
+export interface CircleGatewayContracts {
+    readonly GatewayWallet: Contract<typeof circleGatewayAbis.GatewayWalletABI>;
+    readonly GatewayMinter: Contract<typeof circleGatewayAbis.GatewayMinterABI>;
+}
+export interface CompoundV2Contracts {
+    readonly CUSDC: Contract<typeof compoundV2Abis.CErc20ABI>;
+    readonly Comptroller: Contract<typeof compoundV2Abis.ComptrollerABI>;
+    readonly CETH: AddressOnlyContract;
+}
+export interface CompoundV3Contracts {
+    readonly CUSDCv3: Contract<typeof compoundV3Abis.CometABI>;
+    readonly CWETHv3: Contract<typeof compoundV3Abis.CometABI>;
+    readonly CUSDTv3: Contract<typeof compoundV3Abis.CometABI>;
+}
+export interface ConnextContracts {
+    readonly EverclearSpoke: Contract<typeof connextAbis.EverclearSpokeABI>;
+}
+export interface ConvexContracts {
+    readonly BaseRewardPool: InterfaceContract<typeof convexAbis.BaseRewardPoolABI>;
+    readonly Booster: Contract<typeof convexAbis.BoosterABI>;
+    readonly CvxRewardPool: AddressOnlyContract;
+}
+export interface CowswapContracts {
+    readonly GPv2Settlement: Contract<typeof cowswapAbis.GPv2SettlementABI>;
+}
+export interface CrvusdContracts {
+    readonly CrvUSD: Contract<typeof crvusdAbis.CrvUSDERC20ABI>;
+}
+export interface CurveContracts {
+    readonly AddressProvider: Contract<typeof curveAbis.CurveAddressProviderABI>;
+    readonly RouterNG: Contract<typeof curveAbis.CurveRouterNGABI>;
+    readonly StableSwap: InterfaceContract<typeof curveAbis.CurveStableSwapABI>;
+    readonly ThreePool: Contract<typeof curveAbis.CurveThreePoolABI>;
+    readonly CrvToken: AddressOnlyContract;
+}
+export interface DebridgeContracts {
+    readonly DlnDestination: Contract<typeof debridgeAbis.DlnDestinationABI>;
+    readonly DlnSource: Contract<typeof debridgeAbis.DlnSourceABI>;
+}
+export interface DodoContracts {
+    readonly DODOV2Proxy: Contract<typeof dodoAbis.DODOV2ProxyABI>;
+}
+export interface EcoRoutesContracts {
+    readonly Portal: Contract<typeof ecoRoutesAbis.PortalABI>;
+    readonly HyperProver: Contract<typeof ecoRoutesAbis.ProverABI>;
+    readonly PolymerProver: Contract<typeof ecoRoutesAbis.ProverABI>;
+}
+export interface EigenlayerContracts {
+    readonly DelegationManager: Contract<typeof eigenlayerAbis.DelegationManagerABI>;
+    readonly StETHStrategy: Contract<typeof eigenlayerAbis.StrategyABI>;
+    readonly RETHStrategy: Contract<typeof eigenlayerAbis.StrategyABI>;
+    readonly CbETHStrategy: Contract<typeof eigenlayerAbis.StrategyABI>;
+    readonly StrategyManager: Contract<typeof eigenlayerAbis.StrategyManagerABI>;
+}
+export interface EnsContracts {
+    readonly BaseRegistrar: Contract<typeof ensAbis.BaseRegistrarABI>;
+    readonly Registry: Contract<typeof ensAbis.ENSRegistryABI>;
+}
+export interface Erc20Contracts {
+    readonly ERC20: InterfaceContract<typeof erc20Abis.ERC20ABI>;
+}
+export interface Erc3156Contracts {
+    readonly FlashLender: InterfaceContract<typeof erc3156Abis.FlashLenderABI>;
+}
+export interface Erc4626Contracts {
+    readonly Vault: InterfaceContract<typeof erc4626Abis.VaultABI>;
+}
+export interface EthenaContracts {
+    readonly Susde: Contract<typeof ethenaAbis.StakedUSDeABI>;
+    readonly USDe: Contract<typeof ethenaAbis.USDeABI>;
+}
+export interface EtherfiContracts {
+    readonly EETH: Contract<typeof etherfiAbis.EETHABI>;
+    readonly LiquidityPool: Contract<typeof etherfiAbis.LiquidityPoolABI>;
+    readonly WeETH: Contract<typeof etherfiAbis.WeETHABI>;
+}
+export interface EulerV2Contracts {
+    readonly EthereumVaultConnector: Contract<typeof eulerV2Abis.EVCABI>;
+    readonly EVault: InterfaceContract<typeof eulerV2Abis.EVaultABI>;
+}
+export interface FenixContracts {
+    readonly Router: Contract<typeof fenixAbis.FenixRouterABI>;
+}
+export interface FluidContracts {
+    readonly Lending: InterfaceContract<typeof fluidAbis.FluidLendingABI>;
+    readonly Vault: InterfaceContract<typeof fluidAbis.FluidVaultABI>;
+    readonly Liquidity: AddressOnlyContract;
+}
+export interface FraxContracts {
+    readonly Frax: Contract<typeof fraxAbis.FraxERC20ABI>;
+}
+export interface FraxEtherContracts {
+    readonly FrxETHMinter: Contract<typeof fraxEtherAbis.FrxETHMinterABI>;
+    readonly SfrxETH: Contract<typeof fraxEtherAbis.SfrxETHABI>;
+}
+export interface GainsNetworkContracts {
+    readonly Diamond: Contract<typeof gainsNetworkAbis.DiamondABI>;
+    readonly Gns: AddressOnlyContract;
+}
+export interface GammaContracts {
+    readonly Hypervisor: InterfaceContract<typeof gammaAbis.HypervisorABI>;
+    readonly UniProxy: Contract<typeof gammaAbis.UniProxyABI>;
+    readonly UniProxyLegacy: Contract<typeof gammaAbis.UniProxyLegacyABI>;
+}
+export interface GelatoContracts {
+    readonly Automate: Contract<typeof gelatoAbis.GelatoAutomateABI>;
+}
+export interface GhoContracts {
+    readonly Gho: Contract<typeof ghoAbis.GhoTokenABI>;
+}
+export interface GmxV1Contracts {
+    readonly PositionRouter: Contract<typeof gmxV1Abis.PositionRouterABI>;
+    readonly Router: Contract<typeof gmxV1Abis.RouterABI>;
+    readonly Vault: Contract<typeof gmxV1Abis.VaultABI>;
+    readonly Glp: AddressOnlyContract;
+}
+export interface GmxV2Contracts {
+    readonly ExchangeRouter: Contract<typeof gmxV2Abis.ExchangeRouterABI>;
+    readonly DataStore: AddressOnlyContract;
+}
+export interface HarvestContracts {
+    readonly Vault: InterfaceContract<typeof harvestAbis.VaultABI>;
+    readonly Controller: AddressOnlyContract;
+    readonly Farm: AddressOnlyContract;
+    readonly DepositHelper: AddressOnlyContract;
+}
+export interface HegicContracts {
+    readonly OperationalTreasury: Contract<typeof hegicAbis.HegicABI>;
+    readonly Hegic: AddressOnlyContract;
+}
+export interface HopContracts {
+    readonly L1EthBridge: Contract<typeof hopAbis.HopL1BridgeABI>;
+    readonly L1UsdcBridge: Contract<typeof hopAbis.HopL1BridgeABI>;
+    readonly L2AmmWrapper: Contract<typeof hopAbis.HopL2AmmWrapperABI>;
+}
+export interface HyperlaneContracts {
+    readonly Mailbox: Contract<typeof hyperlaneAbis.HyperlaneMailboxABI>;
+}
+export interface InstadappContracts {
+    readonly FlashloanAggregator: Contract<typeof instadappAbis.FlashAggregatorABI>;
+}
+export interface KelpContracts {
+    readonly LRTDepositPool: Contract<typeof kelpAbis.LRTDepositPoolABI>;
+    readonly RsETH: Contract<typeof kelpAbis.RsETHABI>;
+}
+export interface KimContracts {
+    readonly V2Router: Contract<typeof kimAbis.KimRouterABI>;
+}
+export interface KyberswapContracts {
+    readonly ElasticRouter: Contract<typeof kyberswapAbis.KyberSwapElasticRouterABI>;
+    readonly MetaAggregationRouterV2: Contract<typeof kyberswapAbis.KyberSwapMetaAggregationRouterABI>;
+    readonly ElasticFactory: AddressOnlyContract;
+}
+export interface KyberswapAggregatorContracts {
+    readonly MetaAggregationRouter: Contract<typeof kyberswapAggregatorAbis.KyberSwapMetaAggregationRouterABI>;
+}
+export interface LayerbankContracts {
+    readonly LToken: InterfaceContract<typeof layerbankAbis.LTokenABI>;
+    readonly Core: Contract<typeof layerbankAbis.LayerBankCoreABI>;
+}
+export interface LayerzeroContracts {
+    readonly EndpointV2: Contract<typeof layerzeroAbis.LayerZeroEndpointV2ABI>;
+}
+export interface LevelFinanceContracts {
+    readonly LiquidityPool: Contract<typeof levelFinanceAbis.LiquidityPoolABI>;
+}
+export interface LidoContracts {
+    readonly StETH: Contract<typeof lidoAbis.LidoABI>;
+    readonly WstETH: Contract<typeof lidoAbis.WstETHABI>;
+}
+export interface LifiContracts {
+    readonly LiFiDiamond: Contract<typeof lifiAbis.LiFiDiamondABI>;
+}
+export interface LineaBridgeContracts {
+    readonly L1MessageService: Contract<typeof lineaBridgeAbis.LineaL1MessageServiceABI>;
+    readonly L2MessageService: AddressOnlyContract;
+}
+export interface LiquityV1Contracts {
+    readonly BorrowerOperations: Contract<typeof liquityV1Abis.BorrowerOperationsABI>;
+    readonly Lusd: AddressOnlyContract;
+}
+export interface LiquityV2Contracts {
+    readonly Bold: Contract<typeof liquityV2Abis.BoldTokenABI>;
+}
+export interface LynexContracts {
+    readonly Router: Contract<typeof lynexAbis.LynexRouterABI>;
+}
+export interface MakerContracts {
+    readonly Pot: Contract<typeof makerAbis.PotABI>;
+    readonly SDAI: Contract<typeof makerAbis.SavingsDaiABI>;
+    readonly Dai: AddressOnlyContract;
+    readonly Usds: AddressOnlyContract;
+    readonly Vat: AddressOnlyContract;
+}
+export interface MantleMethContracts {
+    readonly METH: Contract<typeof mantleMethAbis.METHABI>;
+    readonly Staking: Contract<typeof mantleMethAbis.METHStakingABI>;
+}
+export interface MaverickContracts {
+    readonly V2Factory: Contract<typeof maverickAbis.MaverickV2FactoryABI>;
+    readonly V2Router: Contract<typeof maverickAbis.MaverickV2RouterABI>;
+    readonly V2Pool: InterfaceContract<typeof maverickAbis.MaverickV2PoolABI>;
+}
+export interface MoonwellContracts {
+    readonly MToken: InterfaceContract<typeof moonwellAbis.MTokenABI>;
+    readonly Comptroller: Contract<typeof moonwellAbis.MoonwellComptrollerABI>;
+}
+export interface MorphoBlueContracts {
+    readonly Morpho: Contract<typeof morphoBlueAbis.MorphoABI>;
+    readonly Bundler3: AddressOnlyContract;
+}
+export interface MuxProtocolContracts {
+    readonly LiquidityPool: Contract<typeof muxProtocolAbis.LiquidityPoolABI>;
+    readonly OrderBook: Contract<typeof muxProtocolAbis.OrderBookABI>;
+}
+export interface OlympusContracts {
+    readonly Staking: Contract<typeof olympusAbis.StakingABI>;
+    readonly Ohm: AddressOnlyContract;
+    readonly StakingHelper: AddressOnlyContract;
+}
+export interface OneinchContracts {
+    readonly AggregationRouterV6: Contract<typeof oneinchAbis.AggregationRouterV6ABI>;
+}
+export interface OpenoceanContracts {
+    readonly ExchangeV2: Contract<typeof openoceanAbis.OpenOceanExchangeV2ABI>;
+}
+export interface OptimismBridgeContracts {
+    readonly L1StandardBridge: Contract<typeof optimismBridgeAbis.OptimismL1StandardBridgeABI>;
+    readonly L2StandardBridge: AddressOnlyContract;
+}
+export interface OpynContracts {
+    readonly Controller: Contract<typeof opynAbis.ControllerABI>;
+    readonly OSQTH: AddressOnlyContract;
+}
+export interface PancakeswapV2Contracts {
+    readonly Factory: Contract<typeof pancakeswapV2Abis.PancakeSwapV2FactoryABI>;
+    readonly Router: Contract<typeof pancakeswapV2Abis.PancakeSwapV2RouterABI>;
+    readonly Pair: InterfaceContract<typeof pancakeswapV2Abis.PancakeSwapV2PairABI>;
+}
+export interface PancakeswapV3Contracts {
+    readonly Factory: Contract<typeof pancakeswapV3Abis.PancakeSwapV3FactoryABI>;
+    readonly NonfungiblePositionManager: Contract<typeof pancakeswapV3Abis.PancakeSwapV3NFPMABI>;
+    readonly SmartRouter: Contract<typeof pancakeswapV3Abis.PancakeSwapV3SmartRouterABI>;
+    readonly Pool: InterfaceContract<typeof pancakeswapV3Abis.PancakeSwapV3PoolABI>;
+}
+export interface ParaswapContracts {
+    readonly AugustusV5: Contract<typeof paraswapAbis.AugustusV5ABI>;
+    readonly AugustusV6: AddressOnlyContract;
+}
+export interface PendleContracts {
+    readonly Router: Contract<typeof pendleAbis.PendleRouterABI>;
+}
+export interface Permit2Contracts {
+    readonly Permit2: Contract<typeof permit2Abis.Permit2ABI>;
+}
+export interface PerpetualProtocolContracts {
+    readonly ClearingHouse: Contract<typeof perpetualProtocolAbis.ClearingHouseABI>;
+    readonly Vault: Contract<typeof perpetualProtocolAbis.VaultABI>;
+}
+export interface PolygonBridgeContracts {
+    readonly RootChainManager: Contract<typeof polygonBridgeAbis.PolygonRootChainManagerABI>;
+    readonly Erc20Predicate: AddressOnlyContract;
+    readonly EtherPredicate: AddressOnlyContract;
+    readonly ChildChainManager: AddressOnlyContract;
+}
+export interface PremiaContracts {
+    readonly Diamond: InterfaceContract<typeof premiaAbis.DiamondABI>;
+    readonly PoolFactory: AddressOnlyContract;
+}
+export interface PufferContracts {
+    readonly PufferVault: Contract<typeof pufferAbis.PufferVaultABI>;
+    readonly PufETH: AddressOnlyContract;
+}
+export interface PythContracts {
+    readonly Oracle: Contract<typeof pythAbis.PythOracleABI>;
+}
+export interface QuickswapContracts {
+    readonly V2Router: Contract<typeof quickswapAbis.QuickSwapV2RouterABI>;
+    readonly V3SwapRouter: Contract<typeof quickswapAbis.QuickSwapV3SwapRouterABI>;
+    readonly V2Factory: Contract<typeof quickswapAbis.QuickSwapV2FactoryABI>;
+    readonly V2Pair: InterfaceContract<typeof quickswapAbis.QuickSwapV2PairABI>;
+    readonly V3Factory: Contract<typeof quickswapAbis.QuickSwapV3FactoryABI>;
+    readonly V3Pool: InterfaceContract<typeof quickswapAbis.QuickSwapV3PoolABI>;
+}
+export interface RadiantContracts {
+    readonly LendingPool: AddressOnlyContract;
+}
+export interface RamsesContracts {
+    readonly Router: Contract<typeof ramsesAbis.RamsesRouterABI>;
+}
+export interface ReflexerContracts {
+    readonly CoinJoin: Contract<typeof reflexerAbis.CoinJoinABI>;
+    readonly ETHJoin: Contract<typeof reflexerAbis.ETHJoinABI>;
+    readonly SAFEEngine: Contract<typeof reflexerAbis.SAFEEngineABI>;
+    readonly Rai: AddressOnlyContract;
+}
+export interface RenzoContracts {
+    readonly EzETH: Contract<typeof renzoAbis.EzETHABI>;
+    readonly RestakeManager: Contract<typeof renzoAbis.RestakeManagerABI>;
+}
+export interface RocketPoolContracts {
+    readonly RETH: Contract<typeof rocketPoolAbis.RETHABI>;
+    readonly RocketDepositPool: Contract<typeof rocketPoolAbis.RocketDepositPoolABI>;
+}
+export interface SablierContracts {
+    readonly LockupLinear: Contract<typeof sablierAbis.LockupLinearABI>;
+}
+export interface SafeContracts {
+    readonly SafeV141: Contract<typeof safeAbis.SafeABI>;
+    readonly SafeL2V130: Contract<typeof safeAbis.SafeABI>;
+}
+export interface ScrollBridgeContracts {
+    readonly L1GatewayRouter: Contract<typeof scrollBridgeAbis.ScrollL1GatewayRouterABI>;
+    readonly L1ScrollMessenger: Contract<typeof scrollBridgeAbis.ScrollL1MessengerABI>;
+    readonly L2ScrollMessenger: AddressOnlyContract;
+    readonly L2GatewayRouter: AddressOnlyContract;
+}
+export interface SeamlessContracts {
+    readonly Pool: Contract<typeof seamlessAbis.SeamlessPoolABI>;
+    readonly PoolAddressesProvider: AddressOnlyContract;
+}
+export interface SeaportContracts {
+    readonly SeaportV16: Contract<typeof seaportAbis.SeaportABI>;
+}
+export interface SiloContracts {
+    readonly Silo: InterfaceContract<typeof siloAbis.SiloABI>;
+    readonly SiloRepository: Contract<typeof siloAbis.SiloRepositoryABI>;
+}
+export interface SocketContracts {
+    readonly SocketGateway: Contract<typeof socketAbis.SocketGatewayABI>;
+}
+export interface SommelierContracts {
+    readonly Cellar: InterfaceContract<typeof sommelierAbis.CellarABI>;
+    readonly CellarRouter: AddressOnlyContract;
+}
+export interface SparkContracts {
+    readonly Pool: Contract<typeof sparkAbis.SparkPoolABI>;
+    readonly PoolAddressesProvider: AddressOnlyContract;
+}
+export interface SpookyswapContracts {
+    readonly V2Router: Contract<typeof spookyswapAbis.SpookySwapRouterABI>;
+}
+export interface SquidContracts {
+    readonly SquidRouter: Contract<typeof squidAbis.SquidRouterABI>;
+}
+export interface StaderContracts {
+    readonly ETHx: Contract<typeof staderAbis.ETHxABI>;
+    readonly StakePoolManager: Contract<typeof staderAbis.StakePoolManagerABI>;
+}
+export interface StargateContracts {
+    readonly PoolNative: Contract<typeof stargateAbis.StargatePoolABI>;
+    readonly PoolUSDC: Contract<typeof stargateAbis.StargatePoolABI>;
+    readonly PoolUSDT: Contract<typeof stargateAbis.StargatePoolABI>;
+}
+export interface SuperfluidContracts {
+    readonly CFAForwarder: Contract<typeof superfluidAbis.CFAForwarderABI>;
+    readonly Host: AddressOnlyContract;
+}
+export interface SushiswapV2Contracts {
+    readonly Factory: Contract<typeof sushiswapV2Abis.SushiSwapV2FactoryABI>;
+    readonly Router: Contract<typeof sushiswapV2Abis.SushiSwapV2RouterABI>;
+    readonly Pair: InterfaceContract<typeof sushiswapV2Abis.SushiSwapV2PairABI>;
+}
+export interface SwellContracts {
+    readonly RswETH: Contract<typeof swellAbis.RswETHABI>;
+    readonly SwETH: Contract<typeof swellAbis.SwETHABI>;
+}
+export interface SynapseContracts {
+    readonly SynapseBridge: Contract<typeof synapseAbis.SynapseBridgeABI>;
+    readonly CctpRouter: AddressOnlyContract;
+}
+export interface SyncswapContracts {
+    readonly Router: Contract<typeof syncswapAbis.SyncSwapRouterABI>;
+}
+export interface SynthetixV3Contracts {
+    readonly CoreProxy: Contract<typeof synthetixV3Abis.CoreProxyABI>;
+    readonly PerpsMarketProxy: Contract<typeof synthetixV3Abis.PerpsMarketProxyABI>;
+}
+export interface SynthraV3Contracts {
+    readonly Factory: Contract<typeof synthraV3Abis.SynthraV3FactoryABI>;
+    readonly SwapRouter02: Contract<typeof synthraV3Abis.SynthraV3SwapRouter02ABI>;
+    readonly QuoterV2: Contract<typeof synthraV3Abis.SynthraV3QuoterV2ABI>;
+    readonly NonfungiblePositionManager: Contract<typeof synthraV3Abis.SynthraV3NonfungiblePositionManagerABI>;
+    readonly Pool: InterfaceContract<typeof synthraV3Abis.SynthraV3PoolABI>;
+}
+export interface ThalesContracts {
+    readonly SpeedMarketsAMM: Contract<typeof thalesAbis.SpeedMarketsAMMABI>;
+    readonly ThalesAMM: Contract<typeof thalesAbis.ThalesAMMABI>;
+    readonly PositionalMarket: InterfaceContract<typeof thalesAbis.PositionalMarketABI>;
+}
+export interface ThenaContracts {
+    readonly RouterV2: Contract<typeof thenaAbis.ThenaRouterABI>;
+}
+export interface ThrusterContracts {
+    readonly V3SwapRouter: Contract<typeof thrusterAbis.ThrusterV3SwapRouterABI>;
+}
+export interface TokemakContracts {
+    readonly Autopool: InterfaceContract<typeof tokemakAbis.AutopoolABI>;
+    readonly Toke: AddressOnlyContract;
+    readonly SystemRegistry: AddressOnlyContract;
+    readonly AutopoolRegistry: AddressOnlyContract;
+}
+export interface TraderJoeContracts {
+    readonly LBFactory: Contract<typeof traderJoeAbis.LBFactoryABI>;
+    readonly LBRouter: Contract<typeof traderJoeAbis.LBRouterABI>;
+    readonly LBPair: InterfaceContract<typeof traderJoeAbis.LBPairABI>;
+}
+export interface UniswapV2Contracts {
+    readonly Factory: Contract<typeof uniswapV2Abis.UniswapV2FactoryABI>;
+    readonly Router: Contract<typeof uniswapV2Abis.UniswapV2RouterABI>;
+    readonly Pair: InterfaceContract<typeof uniswapV2Abis.UniswapV2PairABI>;
+}
+export interface UniswapV3Contracts {
+    readonly Factory: Contract<typeof uniswapV3Abis.UniswapV3FactoryABI>;
+    readonly NonfungiblePositionManager: Contract<typeof uniswapV3Abis.UniswapV3NonfungiblePositionManagerABI>;
+    readonly QuoterV2: Contract<typeof uniswapV3Abis.UniswapV3QuoterV2ABI>;
+    readonly SwapRouter: Contract<typeof uniswapV3Abis.UniswapV3SwapRouterABI>;
+    readonly SwapRouter02: Contract<typeof uniswapV3Abis.UniswapV3SwapRouter02ABI>;
+    readonly Pool: InterfaceContract<typeof uniswapV3Abis.UniswapV3PoolABI>;
+}
+export interface UniswapV4Contracts {
+    readonly PoolManager: Contract<typeof uniswapV4Abis.UniswapV4PoolManagerABI>;
+    readonly PositionManager: Contract<typeof uniswapV4Abis.UniswapV4PositionManagerABI>;
+    readonly UniversalRouter: Contract<typeof uniswapV4Abis.UniswapV4UniversalRouterABI>;
+    readonly StateView: Contract<typeof uniswapV4Abis.UniswapV4StateViewABI>;
+}
+export interface UnitflowV3Contracts {
+    readonly Factory: Contract<typeof unitflowV3Abis.UnitFlowV3FactoryABI>;
+    readonly Router: Contract<typeof unitflowV3Abis.UnitFlowV3RouterABI>;
+    readonly Quoter: Contract<typeof unitflowV3Abis.UnitFlowV3QuoterABI>;
+    readonly Pool: InterfaceContract<typeof unitflowV3Abis.UnitFlowV3PoolABI>;
+}
+export interface VelodromeContracts {
+    readonly PoolFactory: Contract<typeof velodromeAbis.VelodromePoolFactoryABI>;
+    readonly RouterV2: Contract<typeof velodromeAbis.VelodromeRouterABI>;
+    readonly Pool: InterfaceContract<typeof velodromeAbis.VelodromePoolABI>;
+}
+export interface VenusContracts {
+    readonly VBNB: Contract<typeof venusAbis.VBNBABI>;
+    readonly VToken: InterfaceContract<typeof venusAbis.VTokenABI>;
+    readonly Comptroller: Contract<typeof venusAbis.VenusComptrollerABI>;
+}
+export interface VertexContracts {
+    readonly Clearinghouse: Contract<typeof vertexAbis.ClearinghouseABI>;
+    readonly Endpoint: Contract<typeof vertexAbis.EndpointABI>;
+}
+export interface WormholeContracts {
+    readonly CoreBridge: Contract<typeof wormholeAbis.WormholeCoreBridgeABI>;
+    readonly TokenBridge: Contract<typeof wormholeAbis.WormholeTokenBridgeABI>;
+}
+export interface YearnV3Contracts {
+    readonly Vault: InterfaceContract<typeof yearnV3Abis.YearnV3VaultABI>;
+    readonly VaultFactory: AddressOnlyContract;
+}
+export interface ZerolendContracts {
+    readonly Pool: Contract<typeof zerolendAbis.ZeroLendPoolABI>;
+}
+export interface ZeroxContracts {
+    readonly ExchangeProxy: Contract<typeof zeroxAbis.ExchangeProxyABI>;
+}
+export interface ZksyncBridgeContracts {
+    readonly DiamondProxy: Contract<typeof zksyncBridgeAbis.ZkSyncDiamondProxyABI>;
+    readonly L2Bridge: AddressOnlyContract;
+}
+export interface AaveFamilyContracts {
+    readonly LendingPool: AaveV2Contracts["LendingPool"];
+    readonly Pool: AaveV3Contracts["Pool"];
+    readonly PoolAddressesProvider: AaveV3Contracts["PoolAddressesProvider"];
+    readonly MainSpoke: AaveV4Contracts["MainSpoke"];
+    readonly ForexSpoke: AaveV4Contracts["ForexSpoke"];
+    readonly BluechipSpoke: AaveV4Contracts["BluechipSpoke"];
+    readonly EthenaCorrelatedSpoke: AaveV4Contracts["EthenaCorrelatedSpoke"];
+    readonly EthenaEcosystemSpoke: AaveV4Contracts["EthenaEcosystemSpoke"];
+    readonly GoldSpoke: AaveV4Contracts["GoldSpoke"];
+    readonly PaxgGoldSpoke: AaveV4Contracts["PaxgGoldSpoke"];
+    readonly LombardBtcSpoke: AaveV4Contracts["LombardBtcSpoke"];
+    readonly UsdgPendleSpoke: AaveV4Contracts["UsdgPendleSpoke"];
+    readonly EtherfiESpoke: AaveV4Contracts["EtherfiESpoke"];
+    readonly KelpESpoke: AaveV4Contracts["KelpESpoke"];
+    readonly LidoESpoke: AaveV4Contracts["LidoESpoke"];
+    readonly UsdgMapleESpoke: AaveV4Contracts["UsdgMapleESpoke"];
+    readonly Mag7Spoke: AaveV4Contracts["Mag7Spoke"];
+    readonly AvaxCorrelatedSpoke: AaveV4Contracts["AvaxCorrelatedSpoke"];
+    readonly CoreHub: AaveV4Contracts["CoreHub"];
+    readonly PlusHub: AaveV4Contracts["PlusHub"];
+    readonly PrimeHub: AaveV4Contracts["PrimeHub"];
+    readonly GlobalDollarHub: AaveV4Contracts["GlobalDollarHub"];
+    readonly EquitiesHub: AaveV4Contracts["EquitiesHub"];
+}
+export interface BalancerFamilyContracts {
+    readonly Vault: BalancerV2Contracts["Vault"];
+}
+export interface CompoundFamilyContracts {
+    readonly CUSDC: CompoundV2Contracts["CUSDC"];
+    readonly Comptroller: CompoundV2Contracts["Comptroller"];
+    readonly CETH: CompoundV2Contracts["CETH"];
+    readonly CUSDCv3: CompoundV3Contracts["CUSDCv3"];
+    readonly CWETHv3: CompoundV3Contracts["CWETHv3"];
+    readonly CUSDTv3: CompoundV3Contracts["CUSDTv3"];
+}
+export interface EulerFamilyContracts {
+    readonly EthereumVaultConnector: EulerV2Contracts["EthereumVaultConnector"];
+    readonly EVault: EulerV2Contracts["EVault"];
+}
+export interface GmxFamilyContracts {
+    readonly PositionRouter: GmxV1Contracts["PositionRouter"];
+    readonly Router: GmxV1Contracts["Router"];
+    readonly Vault: GmxV1Contracts["Vault"];
+    readonly Glp: GmxV1Contracts["Glp"];
+    readonly ExchangeRouter: GmxV2Contracts["ExchangeRouter"];
+    readonly DataStore: GmxV2Contracts["DataStore"];
+}
+export interface LiquityFamilyContracts {
+    readonly BorrowerOperations: LiquityV1Contracts["BorrowerOperations"];
+    readonly Lusd: LiquityV1Contracts["Lusd"];
+    readonly Bold: LiquityV2Contracts["Bold"];
+}
+export interface PancakeswapFamilyContracts {
+    readonly Router: PancakeswapV2Contracts["Router"];
+    readonly Pair: PancakeswapV2Contracts["Pair"];
+    readonly NonfungiblePositionManager: PancakeswapV3Contracts["NonfungiblePositionManager"];
+    readonly SmartRouter: PancakeswapV3Contracts["SmartRouter"];
+    readonly Pool: PancakeswapV3Contracts["Pool"];
+}
+export interface SushiswapFamilyContracts {
+    readonly Factory: SushiswapV2Contracts["Factory"];
+    readonly Router: SushiswapV2Contracts["Router"];
+    readonly Pair: SushiswapV2Contracts["Pair"];
+}
+export interface SynthetixFamilyContracts {
+    readonly CoreProxy: SynthetixV3Contracts["CoreProxy"];
+    readonly PerpsMarketProxy: SynthetixV3Contracts["PerpsMarketProxy"];
+}
+export interface SynthraFamilyContracts {
+    readonly Factory: SynthraV3Contracts["Factory"];
+    readonly SwapRouter02: SynthraV3Contracts["SwapRouter02"];
+    readonly QuoterV2: SynthraV3Contracts["QuoterV2"];
+    readonly NonfungiblePositionManager: SynthraV3Contracts["NonfungiblePositionManager"];
+    readonly Pool: SynthraV3Contracts["Pool"];
+}
+export interface UniswapFamilyContracts {
+    readonly Router: UniswapV2Contracts["Router"];
+    readonly Pair: UniswapV2Contracts["Pair"];
+    readonly NonfungiblePositionManager: UniswapV3Contracts["NonfungiblePositionManager"];
+    readonly QuoterV2: UniswapV3Contracts["QuoterV2"];
+    readonly SwapRouter: UniswapV3Contracts["SwapRouter"];
+    readonly SwapRouter02: UniswapV3Contracts["SwapRouter02"];
+    readonly Pool: UniswapV3Contracts["Pool"];
+    readonly PoolManager: UniswapV4Contracts["PoolManager"];
+    readonly PositionManager: UniswapV4Contracts["PositionManager"];
+    readonly UniversalRouter: UniswapV4Contracts["UniversalRouter"];
+    readonly StateView: UniswapV4Contracts["StateView"];
+}
+export interface UnitflowFamilyContracts {
+    readonly Factory: UnitflowV3Contracts["Factory"];
+    readonly Router: UnitflowV3Contracts["Router"];
+    readonly Quoter: UnitflowV3Contracts["Quoter"];
+    readonly Pool: UnitflowV3Contracts["Pool"];
+}
+export interface YearnFamilyContracts {
+    readonly Vault: YearnV3Contracts["Vault"];
+    readonly VaultFactory: YearnV3Contracts["VaultFactory"];
+}
+/** The contract tree every chain accessor carries: one namespace per registry protocol and one
+ *  per family alias. Chain-independent: whether a contract is deployed on a chain is its
+ *  `.available`. */
+export interface ChainContracts {
+    readonly AaveV2: AaveV2Contracts;
+    readonly AaveV3: AaveV3Contracts;
+    readonly AaveV4: AaveV4Contracts;
+    readonly Abracadabra: AbracadabraContracts;
+    readonly Across: AcrossContracts;
+    readonly Aerodrome: AerodromeContracts;
+    readonly AerodromeSlipstream: AerodromeSlipstreamContracts;
+    readonly Aevo: AevoContracts;
+    readonly Alchemix: AlchemixContracts;
+    readonly Ambient: AmbientContracts;
+    readonly ArbitrumBridge: ArbitrumBridgeContracts;
+    readonly Arrakis: ArrakisContracts;
+    readonly Axelar: AxelarContracts;
+    readonly BalancerV2: BalancerV2Contracts;
+    readonly BaseBridge: BaseBridgeContracts;
+    readonly Baseswap: BaseswapContracts;
+    readonly Beefy: BeefyContracts;
+    readonly Benqi: BenqiContracts;
+    readonly Camelot: CamelotContracts;
+    readonly Cbeth: CbethContracts;
+    readonly Cctp: CctpContracts;
+    readonly Celer: CelerContracts;
+    readonly Chainlink: ChainlinkContracts;
+    readonly ChainlinkCcip: ChainlinkCcipContracts;
+    readonly CircleGateway: CircleGatewayContracts;
+    readonly CompoundV2: CompoundV2Contracts;
+    readonly CompoundV3: CompoundV3Contracts;
+    readonly Connext: ConnextContracts;
+    readonly Convex: ConvexContracts;
+    readonly Cowswap: CowswapContracts;
+    readonly Crvusd: CrvusdContracts;
+    readonly Curve: CurveContracts;
+    readonly Debridge: DebridgeContracts;
+    readonly Dodo: DodoContracts;
+    readonly EcoRoutes: EcoRoutesContracts;
+    readonly Eigenlayer: EigenlayerContracts;
+    readonly Ens: EnsContracts;
+    readonly Erc20: Erc20Contracts;
+    readonly Erc3156: Erc3156Contracts;
+    readonly Erc4626: Erc4626Contracts;
+    readonly Ethena: EthenaContracts;
+    readonly Etherfi: EtherfiContracts;
+    readonly EulerV2: EulerV2Contracts;
+    readonly Fenix: FenixContracts;
+    readonly Fluid: FluidContracts;
+    readonly Frax: FraxContracts;
+    readonly FraxEther: FraxEtherContracts;
+    readonly GainsNetwork: GainsNetworkContracts;
+    readonly Gamma: GammaContracts;
+    readonly Gelato: GelatoContracts;
+    readonly Gho: GhoContracts;
+    readonly GmxV1: GmxV1Contracts;
+    readonly GmxV2: GmxV2Contracts;
+    readonly Harvest: HarvestContracts;
+    readonly Hegic: HegicContracts;
+    readonly Hop: HopContracts;
+    readonly Hyperlane: HyperlaneContracts;
+    readonly Instadapp: InstadappContracts;
+    readonly Kelp: KelpContracts;
+    readonly Kim: KimContracts;
+    readonly Kyberswap: KyberswapContracts;
+    readonly KyberswapAggregator: KyberswapAggregatorContracts;
+    readonly Layerbank: LayerbankContracts;
+    readonly Layerzero: LayerzeroContracts;
+    readonly LevelFinance: LevelFinanceContracts;
+    readonly Lido: LidoContracts;
+    readonly Lifi: LifiContracts;
+    readonly LineaBridge: LineaBridgeContracts;
+    readonly LiquityV1: LiquityV1Contracts;
+    readonly LiquityV2: LiquityV2Contracts;
+    readonly Lynex: LynexContracts;
+    readonly Maker: MakerContracts;
+    readonly MantleMeth: MantleMethContracts;
+    readonly Maverick: MaverickContracts;
+    readonly Moonwell: MoonwellContracts;
+    readonly MorphoBlue: MorphoBlueContracts;
+    readonly MuxProtocol: MuxProtocolContracts;
+    readonly Olympus: OlympusContracts;
+    readonly Oneinch: OneinchContracts;
+    readonly Openocean: OpenoceanContracts;
+    readonly OptimismBridge: OptimismBridgeContracts;
+    readonly Opyn: OpynContracts;
+    readonly PancakeswapV2: PancakeswapV2Contracts;
+    readonly PancakeswapV3: PancakeswapV3Contracts;
+    readonly Paraswap: ParaswapContracts;
+    readonly Pendle: PendleContracts;
+    readonly Permit2: Permit2Contracts;
+    readonly PerpetualProtocol: PerpetualProtocolContracts;
+    readonly PolygonBridge: PolygonBridgeContracts;
+    readonly Premia: PremiaContracts;
+    readonly Puffer: PufferContracts;
+    readonly Pyth: PythContracts;
+    readonly Quickswap: QuickswapContracts;
+    readonly Radiant: RadiantContracts;
+    readonly Ramses: RamsesContracts;
+    readonly Reflexer: ReflexerContracts;
+    readonly Renzo: RenzoContracts;
+    readonly RocketPool: RocketPoolContracts;
+    readonly Sablier: SablierContracts;
+    readonly Safe: SafeContracts;
+    readonly ScrollBridge: ScrollBridgeContracts;
+    readonly Seamless: SeamlessContracts;
+    readonly Seaport: SeaportContracts;
+    readonly Silo: SiloContracts;
+    readonly Socket: SocketContracts;
+    readonly Sommelier: SommelierContracts;
+    readonly Spark: SparkContracts;
+    readonly Spookyswap: SpookyswapContracts;
+    readonly Squid: SquidContracts;
+    readonly Stader: StaderContracts;
+    readonly Stargate: StargateContracts;
+    readonly Superfluid: SuperfluidContracts;
+    readonly SushiswapV2: SushiswapV2Contracts;
+    readonly Swell: SwellContracts;
+    readonly Synapse: SynapseContracts;
+    readonly Syncswap: SyncswapContracts;
+    readonly SynthetixV3: SynthetixV3Contracts;
+    readonly SynthraV3: SynthraV3Contracts;
+    readonly Thales: ThalesContracts;
+    readonly Thena: ThenaContracts;
+    readonly Thruster: ThrusterContracts;
+    readonly Tokemak: TokemakContracts;
+    readonly TraderJoe: TraderJoeContracts;
+    readonly UniswapV2: UniswapV2Contracts;
+    readonly UniswapV3: UniswapV3Contracts;
+    readonly UniswapV4: UniswapV4Contracts;
+    readonly UnitflowV3: UnitflowV3Contracts;
+    readonly Velodrome: VelodromeContracts;
+    readonly Venus: VenusContracts;
+    readonly Vertex: VertexContracts;
+    readonly Wormhole: WormholeContracts;
+    readonly YearnV3: YearnV3Contracts;
+    readonly Zerolend: ZerolendContracts;
+    readonly Zerox: ZeroxContracts;
+    readonly ZksyncBridge: ZksyncBridgeContracts;
+    readonly Aave: AaveFamilyContracts;
+    readonly Balancer: BalancerFamilyContracts;
+    readonly Compound: CompoundFamilyContracts;
+    readonly Euler: EulerFamilyContracts;
+    readonly Gmx: GmxFamilyContracts;
+    readonly Liquity: LiquityFamilyContracts;
+    readonly Pancakeswap: PancakeswapFamilyContracts;
+    readonly Sushiswap: SushiswapFamilyContracts;
+    readonly Synthetix: SynthetixFamilyContracts;
+    readonly Synthra: SynthraFamilyContracts;
+    readonly Uniswap: UniswapFamilyContracts;
+    readonly Unitflow: UnitflowFamilyContracts;
+    readonly Yearn: YearnFamilyContracts;
+}
+//# sourceMappingURL=contracts.generated.d.ts.map