@morpho-org/blue-sdk 1.0.0 → 1.0.1

package/src/vault/Vault.ts

@@ -1,370 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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
-    );
-  }
-}