@morpho-org/blue-sdk 1.0.1 → 1.0.2

package/src/vault/Vault.ts

@@ -0,0 +1,370 @@
+import { BigNumberish, MaxUint256, toBigInt } from "ethers";
+
+import { CapacityLimit, CapacityLimitReason } from "../market";
+import { MathLib, MathUtils, RoundingDirection } from "../maths";
+import { Token } from "../token";
+import { Address, MarketId } from "../types";
+
+import { InputVaultAllocation, VaultAllocation } from "./VaultAllocation";
+import { VaultConfig } from "./VaultConfig";
+import { VaultUtils } from "./VaultUtils";
+
+export interface Pending<T> {
+  value: T;
+  validAt: bigint;
+}
+
+export interface VaultPublicAllocatorConfig {
+  /**
+   * The PublicAllocator's admin address.
+   */
+  admin: Address;
+  /**
+   * The PublicAllocator's reallocation fee (in native token).
+   */
+  fee: bigint;
+  /**
+   * The PublicAllocator's reallocation fee accrued so far (in native token).
+   */
+  accruedFee: bigint;
+}
+
+export interface InputVault {
+  config: VaultConfig;
+  curator: Address;
+  owner: Address;
+  guardian: Address;
+  fee: BigNumberish;
+  feeRecipient: Address;
+  skimRecipient: Address;
+  pendingTimelock: Pending<BigNumberish>;
+  pendingGuardian: Pending<Address>;
+  pendingOwner: Address;
+  timelock: BigNumberish; // seconds
+  supplyQueue: MarketId[];
+  withdrawQueue: MarketId[];
+  totalSupply: BigNumberish;
+  totalAssets: BigNumberish;
+  lastTotalAssets: BigNumberish;
+  publicAllocatorConfig?: VaultPublicAllocatorConfig;
+}
+
+export class Vault implements InputVault {
+  /**
+   * The MetaMorpho vault's config.
+   */
+  public readonly config: VaultConfig;
+
+  /**
+   * The MetaMorpho vault's owner address.
+   */
+  owner: Address;
+  /**
+   * The MetaMorpho vault's curator address.
+   */
+  curator: Address;
+  /**
+   * The MetaMorpho vault's guardian address.
+   */
+  guardian: Address;
+  /**
+   * The MetaMorpho vault's skim recipient address (mostly used to skim reward tokens claimed to the vault).
+   */
+  skimRecipient: Address;
+  /**
+   * The MetaMorpho vault's fee recipient address.
+   */
+  feeRecipient: Address;
+
+  /**
+   * The MetaMorpho vault's timelock (in seconds).
+   */
+  timelock: bigint;
+  /**
+   * The MetaMorpho vault's fee.
+   */
+  fee: bigint;
+
+  /**
+   * The MetaMorpho vault's pending owner address and activation timestamp.
+   */
+  pendingOwner: Address;
+  /**
+   * The MetaMorpho vault's pending guardian address and activation timestamp.
+   */
+  pendingGuardian: Pending<Address>;
+  /**
+   * The MetaMorpho vault's pending timelock (in seconds) and activation timestamp.
+   */
+  pendingTimelock: Pending<bigint>;
+
+  /**
+   * The MetaMorpho vault's ordered supply queue.
+   */
+  supplyQueue: MarketId[];
+  /**
+   * The MetaMorpho vault's ordered withdraw queue.
+   */
+  withdrawQueue: MarketId[];
+
+  /**
+   * The ERC4626 vault's total supply of shares.
+   */
+  totalSupply: bigint;
+  /**
+   * The ERC4626 vault's total assets.
+   */
+  totalAssets: bigint;
+  /**
+   * The MetaMorpho vault's last total assets used to calculate performance fees.
+   */
+  lastTotalAssets: bigint;
+
+  /**
+   * The MetaMorpho vault's public allocator configuration.
+   */
+  publicAllocatorConfig?: VaultPublicAllocatorConfig;
+
+  constructor({
+    config,
+    curator,
+    owner,
+    guardian,
+    publicAllocatorConfig,
+    fee,
+    feeRecipient,
+    skimRecipient,
+    pendingTimelock,
+    pendingGuardian,
+    pendingOwner,
+    timelock,
+    supplyQueue,
+    withdrawQueue,
+    totalSupply,
+    totalAssets,
+    lastTotalAssets,
+  }: InputVault) {
+    this.config = config;
+    this.curator = curator;
+    this.owner = owner;
+    this.guardian = guardian;
+    this.fee = toBigInt(fee);
+    this.feeRecipient = feeRecipient;
+    this.skimRecipient = skimRecipient;
+    this.pendingTimelock = {
+      value: toBigInt(pendingTimelock.value),
+      validAt: pendingTimelock.validAt,
+    };
+    this.pendingGuardian = pendingGuardian;
+    this.pendingOwner = pendingOwner;
+    this.timelock = toBigInt(timelock);
+    this.supplyQueue = supplyQueue;
+    this.withdrawQueue = withdrawQueue;
+    this.totalSupply = toBigInt(totalSupply);
+    this.totalAssets = toBigInt(totalAssets);
+    this.lastTotalAssets = toBigInt(lastTotalAssets);
+    this.publicAllocatorConfig = publicAllocatorConfig;
+  }
+
+  get address() {
+    return this.config.address;
+  }
+
+  get asset() {
+    return this.config.asset;
+  }
+
+  /**
+   * The amount of interest in assets accrued since the last interaction with the vault.
+   */
+  get totalInterest() {
+    return MathUtils.zeroFloorSub(this.totalAssets, this.lastTotalAssets);
+  }
+
+  public toAssets(shares: BigNumberish, rounding?: RoundingDirection) {
+    return VaultUtils.toAssets(shares, this, this.config, rounding);
+  }
+
+  public toShares(assets: BigNumberish, rounding?: RoundingDirection) {
+    return VaultUtils.toShares(assets, this, this.config, rounding);
+  }
+}
+
+export interface CollateralAllocation {
+  address: Address;
+  lltvs: Set<bigint>;
+  oracles: Set<Address>;
+  markets: Set<MarketId>;
+  proportion: bigint;
+}
+
+export interface InputAccrualVault
+  extends Omit<InputVault, "withdrawQueue" | "totalAssets"> {}
+
+export class AccrualVault extends Vault implements InputAccrualVault {
+  /**
+   * The allocation of the vault on each market enabled.
+   */
+  public readonly allocations: Map<MarketId, VaultAllocation>;
+
+  /**
+   * The ERC4626 vault's share token.
+   */
+  public token: Token;
+
+  /**
+   * The proportion of assets of the vault supplied to markets collateralized by each collateral asset.
+   */
+  public readonly collateralAllocations: Map<Address, CollateralAllocation>;
+
+  constructor(
+    vault: InputAccrualVault,
+    /**
+     * The allocation of the vault on each market of the withdraw queue,
+     * in the same order as the withdraw queue.
+     */
+    allocations: Omit<InputVaultAllocation, "proportion">[]
+  ) {
+    super({
+      ...vault,
+      withdrawQueue: allocations.map(({ position }) => position.market.id),
+      totalAssets: allocations.reduce(
+        (total, { position }) => total + position.supplyAssets,
+        0n
+      ),
+    });
+
+    this.allocations = new Map(
+      allocations.map(({ config, position }) => [
+        position.market.id,
+        new VaultAllocation({
+          config,
+          position,
+          proportion:
+            this.totalAssets === 0n
+              ? 0n
+              : MathLib.wDivDown(position.supplyAssets, this.totalAssets),
+        }),
+      ])
+    );
+    this.token = new Token(this.config);
+
+    this.collateralAllocations = new Map<Address, CollateralAllocation>();
+
+    for (const { position, proportion } of this.allocations.values()) {
+      const address = position.market.config.collateralToken;
+
+      let exposure = this.collateralAllocations.get(address);
+      if (!exposure)
+        this.collateralAllocations.set(
+          address,
+          (exposure = {
+            address,
+            lltvs: new Set(),
+            oracles: new Set(),
+            markets: new Set(),
+            proportion: 0n,
+          })
+        );
+
+      exposure.lltvs.add(position.market.config.lltv);
+      exposure.oracles.add(position.market.config.oracle);
+      exposure.markets.add(position.market.id);
+      exposure.proportion += proportion;
+    }
+  }
+
+  /**
+   * The vault's liquidity directly available from allocated markets.
+   */
+  get liquidity() {
+    return Array.from(this.allocations.values()).reduce(
+      (total, { position }) => total + position.withdrawCapacityLimit.value,
+      0n
+    );
+  }
+
+  /**
+   * The MetaMorpho vault's average APY on its assets, including the performance fee.
+   */
+  get avgApy() {
+    if (this.totalAssets === 0n) return 0n;
+    return (
+      Array.from(this.allocations.values()).reduce(
+        (total, { position }) =>
+          total + position.market.supplyApy * position.supplyAssets,
+        0n
+      ) / this.totalAssets
+    );
+  }
+
+  /**
+   * The MetaMorpho vault's average APY on its assets, excluding the performance fee.
+   */
+  get netApy() {
+    return MathLib.wMulDown(this.avgApy, MathLib.WAD - this.fee);
+  }
+
+  public getDepositCapacityLimit(assets: bigint): CapacityLimit {
+    const suppliable = Array.from(this.allocations.values()).reduce(
+      (total, { config: { cap }, position: { marketId, supplyAssets } }) =>
+        MathLib.min(
+          total +
+            (this.supplyQueue.includes(marketId)
+              ? MathUtils.zeroFloorSub(cap, supplyAssets)
+              : 0n),
+          MaxUint256
+        ),
+      0n
+    );
+
+    if (assets > suppliable)
+      return {
+        value: suppliable,
+        limiter: CapacityLimitReason.cap,
+      };
+
+    return {
+      value: assets,
+      limiter: CapacityLimitReason.balance,
+    };
+  }
+
+  public getWithdrawCapacityLimit(shares: bigint): CapacityLimit {
+    const assets = this.toAssets(shares);
+    const { liquidity } = this;
+
+    if (assets > liquidity)
+      return {
+        value: liquidity,
+        limiter: CapacityLimitReason.liquidity,
+      };
+
+    return {
+      value: assets,
+      limiter: CapacityLimitReason.balance,
+    };
+  }
+
+  public accrueInterest(timestamp: bigint) {
+    const vault = new AccrualVault(
+      this,
+      Array.from(this.allocations.values(), ({ config, position }) => ({
+        config,
+        position: position.accrueInterest(timestamp),
+      }))
+    );
+
+    const feeAssets = MathLib.wMulDown(vault.totalInterest, vault.fee);
+
+    vault.totalAssets -= feeAssets;
+
+    const feeShares = vault.toShares(feeAssets, "Down");
+
+    vault.totalAssets += feeAssets;
+    vault.totalSupply += feeShares;
+    vault.lastTotalAssets = vault.totalAssets;
+
+    return vault;
+  }
+}

package/src/vault/VaultAllocation.ts

@@ -0,0 +1,58 @@
+import { MaxUint256 } from "ethers";
+
+import { MathLib } from "../maths";
+import { AccrualPosition } from "../position";
+
+import { Pending } from "./Vault";
+
+/**
+ * The vault's configuration of a market on the PublicAllocator.
+ */
+export interface VaultMarketPublicAllocatorConfig {
+  maxIn: bigint;
+  maxOut: bigint;
+}
+
+export interface VaultMarketConfig {
+  cap: bigint;
+  pendingCap: Pending<bigint>;
+  removableAt: bigint;
+  enabled: boolean;
+  readonly publicAllocatorConfig?: VaultMarketPublicAllocatorConfig;
+}
+
+export interface InputVaultAllocation {
+  config: VaultMarketConfig;
+  position: AccrualPosition;
+  proportion: bigint;
+}
+
+export class VaultAllocation implements InputVaultAllocation {
+  /**
+   * The vault's configuration on the corresponding market.
+   */
+  public config: VaultMarketConfig;
+
+  /**
+   * The vault's position on the corresponding market.
+   */
+  public readonly position: AccrualPosition;
+
+  /**
+   * The vault's proportion of assets supplied on the corresponding market,
+   * with regard to the total assets of the vault.
+   */
+  public readonly proportion: bigint;
+
+  constructor({ config, position, proportion }: InputVaultAllocation) {
+    this.config = config;
+    this.position = position;
+    this.proportion = proportion;
+  }
+
+  get utilization() {
+    if (this.config.cap === 0n) return MaxUint256;
+
+    return MathLib.wDivDown(this.position.supplyAssets, this.config.cap);
+  }
+}

package/src/vault/VaultConfig.ts

@@ -0,0 +1,55 @@
+import { ChainId } from "../chain";
+import { UnknownVaultConfigError } from "../errors";
+import { Address } from "../types";
+
+interface InputVaultConfig {
+  address: Address;
+  decimals: number;
+  decimalsOffset: bigint;
+  symbol: string;
+  name: string;
+  asset: Address;
+}
+
+export class VaultConfig implements InputVaultConfig {
+  protected static readonly _CACHE: Record<
+    number,
+    Record<Address, VaultConfig>
+  > = {};
+
+  static get(address: Address, chainId: ChainId) {
+    const config = VaultConfig._CACHE[chainId]?.[address];
+
+    if (!config) throw new UnknownVaultConfigError(address);
+
+    return config;
+  }
+
+  public readonly address: Address;
+  public readonly decimals: number;
+  public readonly decimalsOffset: bigint;
+  public readonly symbol: string;
+  public readonly name: string;
+  public readonly asset: Address;
+
+  constructor(
+    {
+      address,
+      decimals,
+      decimalsOffset,
+      symbol,
+      name,
+      asset,
+    }: InputVaultConfig,
+    public readonly chainId?: number
+  ) {
+    this.address = address;
+    this.decimals = decimals;
+    this.decimalsOffset = decimalsOffset;
+    this.symbol = symbol;
+    this.name = name;
+    this.asset = asset;
+
+    if (chainId != null) (VaultConfig._CACHE[chainId] ??= {})[address] = this;
+  }
+}

package/src/vault/VaultUtils.ts

@@ -0,0 +1,47 @@
+import { BigNumberish, toBigInt } from "ethers";
+
+import { MathLib, RoundingDirection } from "../maths";
+
+export namespace VaultUtils {
+  export const VIRTUAL_ASSETS = 1n;
+
+  export function toAssets(
+    shares: BigNumberish,
+    {
+      totalAssets,
+      totalSupply,
+    }: {
+      totalAssets: BigNumberish;
+      totalSupply: BigNumberish;
+    },
+    { decimalsOffset }: { decimalsOffset: BigNumberish },
+    rounding: RoundingDirection = "Down"
+  ) {
+    return MathLib.mulDiv(
+      shares,
+      toBigInt(totalAssets) + VIRTUAL_ASSETS,
+      toBigInt(totalSupply) + 10n ** toBigInt(decimalsOffset),
+      rounding
+    );
+  }
+
+  export function toShares(
+    assets: BigNumberish,
+    {
+      totalAssets,
+      totalSupply,
+    }: {
+      totalAssets: BigNumberish;
+      totalSupply: BigNumberish;
+    },
+    { decimalsOffset }: { decimalsOffset: BigNumberish },
+    rounding: RoundingDirection = "Up"
+  ) {
+    return MathLib.mulDiv(
+      assets,
+      toBigInt(totalSupply) + 10n ** toBigInt(decimalsOffset),
+      toBigInt(totalAssets) + VIRTUAL_ASSETS,
+      rounding
+    );
+  }
+}

package/lib/addresses.d.ts

@@ -1,168 +0,0 @@
-import { ChainId } from "./chain";
-import { Address } from "./types";
-/** Address used to replicate an erc20-behaviour for native token.
- *
- * NB: data might differ from expected onchain native token data
- */
-export declare const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
-export declare const addresses: {
-    readonly 5: {
-        readonly morpho: "0x64c7044050Ba0431252df24fEd4d9635a275CB41";
-        readonly permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-        readonly bundler: "0xCFFbEEAFCD79Fd68FD56Dbc31A419f290A2Fe9e0";
-        readonly urd: "0x820755E757a590683dc43115290eb1Cb20a60405";
-        readonly wNative: "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6";
-        readonly stEth: "0x1643E812aE58766192Cf7D2Cf9567dF2C37e9B7F";
-        readonly wstEth: "0x6320cD32aA674d2898A68ec82e869385Fc5f7E2f";
-        readonly rEth: "0x178E141a0E3b34152f73Ff610437A7bf9B83267A";
-        readonly sDai: "0xD8134205b0328F5676aaeFb3B2a0DC15f4029d8C";
-        readonly dai: "0x11fE4B6AE13d2a6055C8D9cF65c55bac32B5d844";
-        readonly usdc: "0x62bD2A599664D421132d7C54AB4DbE3233f4f0Ae";
-        readonly usdt: "0x576e379FA7B899b4De1E251e935B31543Df3e954";
-    };
-    readonly 1: {
-        readonly morpho: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb";
-        readonly adaptiveCurveIrm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC";
-        readonly publicAllocator: "0xfd32fA2ca22c76dD6E550706Ad913FC6CE91c75D";
-        readonly permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-        readonly bundler: "0x4095F064B8d3c3548A3bebfd0Bbfd04750E30077";
-        readonly aaveV3OptimizerBundler: "0x16F38d2E764E7BeBF625a8E995b34968226D2F9c";
-        readonly aaveV2Bundler: "0xb3dCc75DB379925edFd3007511A8CE0cB4aa8e76";
-        readonly aaveV3Bundler: "0x98ccB155E86bb478d514a827d16f58c6912f9BDC";
-        readonly morphoToken: "0x9994E35Db50125E0DF82e4c2dde62496CE330999";
-        readonly rEth: "0xae78736Cd615f374D3085123A210448E74Fc6393";
-        readonly sDai: "0x83F20F44975D03b1b09e64809B757c47f942BEeA";
-        readonly dai: "0x6B175474E89094C44Da98b954EedeAC495271d0F";
-        readonly mkr: "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2";
-        readonly wstEth: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0";
-        readonly wNative: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
-        readonly stEth: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84";
-        readonly USDe: "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3";
-        readonly sUSDe: "0x9D39A5DE30e57443BfF2A8307A4256c8797A3497";
-        readonly bIB01: "0xCA30c93B02514f86d5C86a6e375E3A330B435Fb5";
-        readonly wbIB01: "0xcA2A7068e551d5C4482eb34880b194E4b945712F";
-        readonly bC3M: "0x2F123cF3F37CE3328CC9B5b8415f9EC5109b45e7";
-        readonly wbC3M: "0x95D7337d43340E2721960Dc402D9b9117f0d81a2";
-        readonly usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
-        readonly usdt: "0xdAC17F958D2ee523a2206206994597C13D831ec7";
-        readonly wbtc: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599";
-        readonly sWise: "0x48C3399719B582dD63eB5AADf12A40B4C3f52FA2";
-        readonly osEth: "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38";
-        readonly weEth: "0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee";
-        readonly ezEth: "0xbf5495Efe5DB9ce00f80364C8B423567e58d2110";
-        readonly pyUsd: "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8";
-        readonly crvUsd: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E";
-        readonly morphoOperator: "0x640428D38189B11B844dAEBDBAAbbdfbd8aE0143";
-        readonly butterfly: "0xc55126051B22eBb829D00368f4B12Bde432de5Da";
-        readonly marketRewardsProgramRegistry: "0x5148bF15bb722E1854F66430Bc9FeD0E9FDaCE7D";
-        readonly timeBoundedUrd: "0x330eefa8a787552DC5cAd3C3cA644844B1E61Ddb";
-        readonly rsEth: "0xA1290d69c65A6Fe4DF752f95823fae25cB99e5A7";
-        readonly "stkcvxcrvUSDTWBTCWETH-morpho": "0xb0Ce26C88e4e7DCa51968b6047f44646f5064278";
-        readonly crvUSDTWBTCWETH: "0xf5f5B97624542D72A9E06f04804Bf81baA15e2B4";
-        readonly "stkcvxcrvUSDCWBTCWETH-morpho": "0x0ea1a65A2c255f24Ee8D81eA6AaC54Decd9d269e";
-        readonly crvUSDCWBTCWETH: "0x7F86Bf177Dd4F3494b841a37e810A34dD56c829B";
-        readonly "stkcvxcrvCRVUSDTBTCWSTETH-morpho": "0x3ce8Ec9f3d89aD0A2DdbCC3FDB8991BD241Fc82E";
-        readonly crvCRVUSDTBTCWSTETH: "0x2889302a794dA87fBF1D6Db415C1492194663D13";
-        readonly "stkcvxTryLSD-morpho": "0x6BA072F0d22806F2C52e9792AF47f2D59103BEBE";
-        readonly tryLSD: "0x2570f1bD5D2735314FC102eb12Fc1aFe9e6E7193";
-        readonly "stkcvxcrvUSDETHCRV-morpho": "0xAc904BAfBb5FB04Deb2b6198FdCEedE75a78Ce5a";
-        readonly crvUSDETHCRV: "0x4eBdF703948ddCEA3B11f675B4D1Fba9d2414A14";
-    };
-    readonly 8453: {
-        readonly morpho: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb";
-        readonly permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-        readonly bundler: "0xb5D342521EB5b983aE6a6324A4D9eac87C9D1987";
-        readonly wNative: "0x4200000000000000000000000000000000000006";
-        readonly adaptiveCurveIrm: "0x46415998764C29aB2a25CbeA6254146D50D22687";
-        readonly publicAllocator: "0xA090dD1a701408Df1d4d0B85b716c87565f90467";
-        readonly usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-        readonly cbEth: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22";
-    };
-};
-interface ChainAddresses {
-    morpho: Address;
-    permit2: Address;
-    bundler: Address;
-    wNative: Address;
-    adaptiveCurveIrm?: Address;
-    publicAllocator?: Address;
-    morphoToken?: Address;
-    wstEth?: Address;
-    stEth?: Address;
-    dai?: Address;
-    mkr?: Address;
-    rEth?: Address;
-    sDai?: Address;
-    usdc?: Address;
-    usdt?: Address;
-    bIB01?: Address;
-    wbIB01?: Address;
-    bC3M?: Address;
-    wbC3M?: Address;
-    wbtc?: Address;
-    sWise?: Address;
-    osEth?: Address;
-    weEth?: Address;
-    ezEth?: Address;
-    pyUsd?: Address;
-    sUSDe?: Address;
-    USDe?: Address;
-    marketRewardsProgramRegistry?: Address;
-    timeBoundedUrd?: Address;
-    rsEth?: Address;
-    crvUsd?: Address;
-    morphoOperator?: Address;
-    butterfly?: Address;
-    aaveV3OptimizerBundler?: Address;
-    aaveV2Bundler?: Address;
-    aaveV3Bundler?: Address;
-    "stkcvxcrvUSDTWBTCWETH-morpho"?: Address;
-    crvUSDTWBTCWETH?: Address;
-    "stkcvxcrvUSDCWBTCWETH-morpho"?: Address;
-    crvUSDCWBTCWETH?: Address;
-    "stkcvxcrvCRVUSDTBTCWSTETH-morpho"?: Address;
-    crvCRVUSDTBTCWSTETH?: Address;
-    "stkcvxTryLSD-morpho"?: Address;
-    tryLSD?: Address;
-    "stkcvxcrvUSDETHCRV-morpho"?: Address;
-    crvUSDETHCRV?: Address;
-}
-export type AddressLabel = keyof (typeof addresses)[ChainId];
-declare const _default: {
-    1: ChainAddresses;
-    5: ChainAddresses;
-    8453: ChainAddresses;
-};
-export default _default;
-export declare const getChainAddresses: (chainId: number) => ChainAddresses;
-export declare const wrapping: {
-    [n in ChainId]: {
-        [unwrapped: string]: string;
-    };
-};
-export declare const reverseWrapping: {
-    1: {
-        [unwrapped: string]: string;
-    };
-    5: {
-        [unwrapped: string]: string;
-    };
-    8453: {
-        [unwrapped: string]: string;
-    };
-};
-export declare function getUnwrappedToken(wrappedToken: Address, chainId: ChainId): string | undefined;
-export declare function getWrappedToken(unWrappedToken: Address, chainId: ChainId): string | undefined;
-export declare const erc20WrapperTokens: {
-    [id in ChainId]: Set<Address>;
-};
-export declare const wrappedBackedTokens: {
-    [id in ChainId]: Set<Address>;
-};
-export declare const getWrappedBackedTokens: (chainId: number) => Set<string>;
-/** /!\  These tokens can not be listed in `erc20WrapperTokens` because the following specs are different:
- * - calling `depositFor` supplies on blue instead of minting wrapped token to the user
- */
-export declare const convexWrapperTokens: {
-    [id in ChainId]: Set<Address>;
-};