@morpho-org/blue-sdk 5.16.0 → 5.18.0

package/lib/esm/vault/Vault.js

@@ -0,0 +1,289 @@
+import { Time } from "@morpho-org/morpho-ts";
+import { MarketUtils } from "../market/index.js";
+import { MathLib } from "../math/index.js";
+import { VaultToken } from "../token/index.js";
+import { CapacityLimitReason } from "../utils.js";
+import { VaultMarketAllocation, } from "./VaultMarketAllocation.js";
+export class Vault extends VaultToken {
+    /**
+     * The MetaMorpho vault's owner address.
+     */
+    owner;
+    /**
+     * The MetaMorpho vault's curator address.
+     */
+    curator;
+    /**
+     * The MetaMorpho vault's guardian address.
+     */
+    guardian;
+    /**
+     * The MetaMorpho vault's skim recipient address (mostly used to skim reward tokens claimed to the vault).
+     */
+    skimRecipient;
+    /**
+     * The MetaMorpho vault's fee recipient address.
+     */
+    feeRecipient;
+    /**
+     * The MetaMorpho vault's timelock (in seconds).
+     */
+    timelock;
+    /**
+     * The MetaMorpho vault's fee.
+     */
+    fee;
+    /**
+     * The MetaMorpho vault's pending owner address and activation timestamp.
+     */
+    pendingOwner;
+    /**
+     * The MetaMorpho vault's pending guardian address and activation timestamp.
+     */
+    pendingGuardian;
+    /**
+     * The MetaMorpho vault's pending timelock (in seconds) and activation timestamp.
+     */
+    pendingTimelock;
+    /**
+     * The MetaMorpho vault's ordered supply queue.
+     */
+    supplyQueue;
+    /**
+     * The MetaMorpho vault's ordered withdraw queue.
+     */
+    withdrawQueue;
+    /**
+     * The MetaMorpho vault's last total assets used to calculate performance fees.
+     */
+    lastTotalAssets;
+    /**
+     * The MetaMorpho vault's lost assets due to realized bad debt.
+     * Only defined for MetaMorpho V1.1 vaults.
+     */
+    lostAssets;
+    /**
+     * The MetaMorpho vault's public allocator configuration.
+     */
+    publicAllocatorConfig;
+    constructor({ curator, owner, guardian, publicAllocatorConfig, fee, feeRecipient, skimRecipient, pendingTimelock, pendingGuardian, pendingOwner, timelock, supplyQueue, withdrawQueue, totalSupply, totalAssets, lastTotalAssets, lostAssets, ...config }) {
+        super(config, { totalAssets, totalSupply });
+        this.curator = curator;
+        this.owner = owner;
+        this.guardian = guardian;
+        this.fee = fee;
+        this.feeRecipient = feeRecipient;
+        this.skimRecipient = skimRecipient;
+        this.pendingTimelock = {
+            value: pendingTimelock.value,
+            validAt: pendingTimelock.validAt,
+        };
+        this.pendingGuardian = pendingGuardian;
+        this.pendingOwner = pendingOwner;
+        this.timelock = timelock;
+        this.supplyQueue = supplyQueue;
+        this.withdrawQueue = withdrawQueue;
+        this.lastTotalAssets = lastTotalAssets;
+        this.lostAssets = lostAssets;
+        this.publicAllocatorConfig = publicAllocatorConfig;
+    }
+    /**
+     * The amount of interest in assets accrued since the last interaction with the vault.
+     */
+    get totalInterest() {
+        return MathLib.zeroFloorSub(this.totalAssets, this.lastTotalAssets);
+    }
+    toAssets(shares, rounding = "Down") {
+        return this._unwrap(shares, rounding);
+    }
+    toShares(assets, rounding = "Up") {
+        return this._wrap(assets, rounding);
+    }
+}
+export class AccrualVault extends Vault {
+    /**
+     * The allocation of the vault on each market enabled.
+     */
+    allocations;
+    /**
+     * The proportion of assets of the vault supplied to markets collateralized by each collateral asset.
+     */
+    collateralAllocations;
+    constructor(vault, 
+    /**
+     * The allocation of the vault on each market of the withdraw queue,
+     * in the same order as the withdraw queue.
+     */
+    allocations) {
+        super({
+            ...vault,
+            withdrawQueue: allocations.map(({ position }) => position.market.id),
+            totalAssets: allocations.reduce((total, { position }) => total + position.supplyAssets, 0n),
+        });
+        this.allocations = new Map(allocations.map((allocation) => [
+            allocation.position.market.id,
+            new VaultMarketAllocation(allocation),
+        ]));
+        this.collateralAllocations = new Map();
+        for (const { marketId, position } of this.allocations.values()) {
+            const address = position.market.params.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.params.lltv);
+            exposure.oracles.add(position.market.params.oracle);
+            exposure.markets.add(marketId);
+            exposure.proportion += this.getAllocationProportion(marketId);
+        }
+    }
+    /**
+     * The vault's liquidity directly available from allocated markets.
+     */
+    get liquidity() {
+        return this.allocations
+            .values()
+            .reduce((total, { position }) => total + position.withdrawCapacityLimit.value, 0n);
+    }
+    /**
+     * The MetaMorpho vault's current instantaneous Annual Percentage Yield (APY)
+     * weighted-averaged over its market deposits, before deducting the performance fee.
+     * If interested in the APY at a specific timestamp, use `getApy(timestamp)` instead.
+     */
+    get apy() {
+        return this.getApy();
+    }
+    /**
+     * The MetaMorpho vault's current instantaneous Annual Percentage Yield (APY)
+     * weighted-averaged over its market deposits, after deducting the performance fee.
+     * If interested in the APY at a specific timestamp, use `getNetApy(timestamp)` instead.
+     */
+    get netApy() {
+        return this.getNetApy();
+    }
+    /**
+     * The MetaMorpho vault's per-second rate at which interest _would_ accrue,
+     * weighted-averaged over its market deposits, before deducting the performance fee,
+     * if interest was to be accrued on each market at the given timestamp.
+     */
+    _getAvgRate(timestamp = Time.timestamp()) {
+        if (this.totalAssets === 0n)
+            return 0n;
+        return (this.allocations
+            .values()
+            .reduce((total, { position }) => total +
+            position.market.getAvgSupplyRate(timestamp) * position.supplyAssets, 0n) / this.totalAssets);
+    }
+    /**
+     * The MetaMorpho vault's experienced Annual Percentage Yield (APY)
+     * weighted-averaged over its market deposits, before deducting the performance fee,
+     * if interest was to be accrued on each market at the given timestamp.
+     */
+    getApy(timestamp = Time.timestamp()) {
+        if (this.totalAssets === 0n)
+            return 0;
+        return MarketUtils.rateToApy(this._getAvgRate(timestamp));
+    }
+    /**
+     * The MetaMorpho vault's experienced Annual Percentage Yield (APY)
+     * weighted-averaged over its market deposits, after deducting the performance fee,
+     * if interest was to be accrued on each market at the given timestamp.
+     */
+    getNetApy(timestamp = Time.timestamp()) {
+        return MarketUtils.rateToApy(MathLib.wMulDown(this._getAvgRate(timestamp), MathLib.WAD - this.fee));
+    }
+    getAllocationProportion(marketId) {
+        if (this.totalAssets === 0n)
+            return 0n;
+        const allocation = this.allocations.get(marketId);
+        if (!allocation)
+            return 0n;
+        return MathLib.wDivDown(allocation.position.supplyAssets, this.totalAssets);
+    }
+    /**
+     * Returns the deposit capacity limit of a given amount of assets on the vault.
+     * @param assets The maximum amount of assets to deposit.
+     * @deprecated Use `maxDeposit` instead.
+     */
+    getDepositCapacityLimit(assets) {
+        return this.maxDeposit(assets);
+    }
+    /**
+     * Returns the withdraw capacity limit corresponding to a given amount of shares of the vault.
+     * @param shares The maximum amount of shares to redeem.
+     * @deprecated Use `maxWithdraw` instead.
+     */
+    getWithdrawCapacityLimit(shares) {
+        return this.maxWithdraw(shares);
+    }
+    /**
+     * Returns the maximum amount of assets that can be deposited to the vault.
+     * @param assets The maximum amount of assets to deposit.
+     */
+    maxDeposit(assets) {
+        assets = BigInt(assets);
+        const suppliable = this.allocations
+            .values()
+            .reduce((total, { config: { cap }, position: { marketId, supplyAssets } }) => MathLib.min(total +
+            (this.supplyQueue.includes(marketId)
+                ? MathLib.zeroFloorSub(cap, supplyAssets)
+                : 0n), MathLib.MAX_UINT_256), 0n);
+        if (assets > suppliable)
+            return {
+                value: suppliable,
+                limiter: CapacityLimitReason.cap,
+            };
+        return {
+            value: assets,
+            limiter: CapacityLimitReason.balance,
+        };
+    }
+    /**
+     * Returns the maximum amount of assets that can be withdrawn from the vault.
+     * @param shares The maximum amount of shares to redeem.
+     */
+    maxWithdraw(shares) {
+        const assets = this.toAssets(shares);
+        const { liquidity } = this;
+        if (assets > liquidity)
+            return {
+                value: liquidity,
+                limiter: CapacityLimitReason.liquidity,
+            };
+        return {
+            value: assets,
+            limiter: CapacityLimitReason.balance,
+        };
+    }
+    /**
+     * Returns a new vault derived from this vault, whose interest has been accrued up to the given timestamp.
+     * @param timestamp The timestamp at which to accrue interest. Must be greater than or equal to each of the vault's market's `lastUpdate`.
+     */
+    accrueInterest(timestamp) {
+        const vault = new AccrualVault(this, 
+        // Keep withdraw queue order.
+        this.withdrawQueue.map((marketId) => {
+            const { config, position } = this.allocations.get(marketId);
+            return {
+                config,
+                position: position.accrueInterest(timestamp),
+            };
+        }));
+        if (vault.lostAssets != null) {
+            vault.lostAssets += MathLib.max(vault.lastTotalAssets - vault.lostAssets - vault.totalAssets, 0n);
+            vault.totalAssets += vault.lostAssets;
+        }
+        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/lib/esm/vault/VaultConfig.d.ts

@@ -0,0 +1,11 @@
+import { type IToken, Token } from "../token/Token.js";
+import type { Address, BigIntish } from "../types.js";
+export interface IVaultConfig extends Omit<IToken, "decimals"> {
+    decimalsOffset: BigIntish;
+    asset: Address;
+}
+export declare class VaultConfig extends Token implements IVaultConfig {
+    readonly decimalsOffset: bigint;
+    readonly asset: `0x${string}`;
+    constructor({ decimalsOffset, asset, ...config }: IVaultConfig);
+}

package/lib/esm/vault/VaultConfig.js

@@ -0,0 +1,10 @@
+import { Token } from "../token/Token.js";
+export class VaultConfig extends Token {
+    decimalsOffset;
+    asset;
+    constructor({ decimalsOffset, asset, ...config }) {
+        super({ ...config, decimals: 18 });
+        this.decimalsOffset = BigInt(decimalsOffset);
+        this.asset = asset;
+    }
+}

package/lib/esm/vault/VaultMarketAllocation.d.ts

@@ -0,0 +1,20 @@
+import type { AccrualPosition } from "../position/index.js";
+import { type IVaultMarketConfig, VaultMarketConfig } from "./VaultMarketConfig.js";
+export interface IVaultMarketAllocation {
+    config: IVaultMarketConfig;
+    position: AccrualPosition;
+}
+export declare class VaultMarketAllocation implements IVaultMarketAllocation {
+    /**
+     * The vault's configuration on the corresponding market.
+     */
+    readonly config: VaultMarketConfig;
+    /**
+     * The vault's position on the corresponding market.
+     */
+    readonly position: AccrualPosition;
+    constructor({ config, position }: IVaultMarketAllocation);
+    get vault(): `0x${string}`;
+    get marketId(): import("../types.js").MarketId;
+    get utilization(): bigint;
+}

package/lib/esm/vault/VaultMarketAllocation.js

@@ -0,0 +1,27 @@
+import { MathLib } from "../math/index.js";
+import { VaultMarketConfig, } from "./VaultMarketConfig.js";
+export class VaultMarketAllocation {
+    /**
+     * The vault's configuration on the corresponding market.
+     */
+    config;
+    /**
+     * The vault's position on the corresponding market.
+     */
+    position;
+    constructor({ config, position }) {
+        this.config = new VaultMarketConfig(config);
+        this.position = position;
+    }
+    get vault() {
+        return this.config.vault;
+    }
+    get marketId() {
+        return this.config.marketId;
+    }
+    get utilization() {
+        if (this.config.cap === 0n)
+            return MathLib.MAX_UINT_256;
+        return MathLib.wDivDown(this.position.supplyAssets, this.config.cap);
+    }
+}

package/lib/esm/vault/VaultMarketConfig.d.ts

@@ -0,0 +1,43 @@
+import type { Address, MarketId } from "../types.js";
+import type { Pending } from "./Vault.js";
+import type { VaultMarketPublicAllocatorConfig } from "./VaultMarketPublicAllocatorConfig.js";
+export interface IVaultMarketConfig {
+    vault: Address;
+    marketId: MarketId;
+    cap: bigint;
+    pendingCap: Pending<bigint>;
+    removableAt: bigint;
+    enabled: boolean;
+    publicAllocatorConfig?: VaultMarketPublicAllocatorConfig;
+}
+export declare class VaultMarketConfig implements IVaultMarketConfig {
+    /**
+     * The vault's address.
+     */
+    readonly vault: Address;
+    /**
+     * The market's id.
+     */
+    readonly marketId: MarketId;
+    /**
+     * The maximum amount of tokens that can be allocated to this market.
+     */
+    cap: bigint;
+    /**
+     * The pending maximum amount of tokens that can be allocated to this market.
+     */
+    pendingCap: Pending<bigint>;
+    /**
+     * The timestamp at which the market can be removed from the withdraw queue.
+     */
+    removableAt: bigint;
+    /**
+     * Whether this market is enabled, i.e. whether additional tokens can be allocated to it.
+     */
+    enabled: boolean;
+    /**
+     * The vault's PublicAllocator configuration on the corresponding market.
+     */
+    readonly publicAllocatorConfig?: VaultMarketPublicAllocatorConfig;
+    constructor({ vault, marketId, cap, pendingCap, removableAt, enabled, publicAllocatorConfig, }: IVaultMarketConfig);
+}

package/lib/esm/vault/VaultMarketConfig.js

@@ -0,0 +1,39 @@
+export class VaultMarketConfig {
+    /**
+     * The vault's address.
+     */
+    vault;
+    /**
+     * The market's id.
+     */
+    marketId;
+    /**
+     * The maximum amount of tokens that can be allocated to this market.
+     */
+    cap;
+    /**
+     * The pending maximum amount of tokens that can be allocated to this market.
+     */
+    pendingCap;
+    /**
+     * The timestamp at which the market can be removed from the withdraw queue.
+     */
+    removableAt;
+    /**
+     * Whether this market is enabled, i.e. whether additional tokens can be allocated to it.
+     */
+    enabled;
+    /**
+     * The vault's PublicAllocator configuration on the corresponding market.
+     */
+    publicAllocatorConfig;
+    constructor({ vault, marketId, cap, pendingCap, removableAt, enabled, publicAllocatorConfig, }) {
+        this.vault = vault;
+        this.marketId = marketId;
+        this.cap = cap;
+        this.pendingCap = pendingCap;
+        this.removableAt = removableAt;
+        this.enabled = enabled;
+        this.publicAllocatorConfig = publicAllocatorConfig;
+    }
+}

package/lib/esm/vault/VaultMarketPublicAllocatorConfig.d.ts

@@ -0,0 +1,29 @@
+import type { Address, MarketId } from "../types.js";
+/**
+ * The vault's configuration of a market on the PublicAllocator.
+ */
+export interface IVaultMarketPublicAllocatorConfig {
+    vault: Address;
+    marketId: MarketId;
+    maxIn: bigint;
+    maxOut: bigint;
+}
+export declare class VaultMarketPublicAllocatorConfig implements IVaultMarketPublicAllocatorConfig {
+    /**
+     * The vault's address.
+     */
+    readonly vault: Address;
+    /**
+     * The market's id.
+     */
+    readonly marketId: MarketId;
+    /**
+     * The maximum amount of tokens that can be allocated to this market by the vault via the PublicAllocator.
+     */
+    maxIn: bigint;
+    /**
+     * The maximum amount of tokens that can be allocated out of this market by the vault via the PublicAllocator.
+     */
+    maxOut: bigint;
+    constructor({ vault, marketId, maxIn, maxOut, }: IVaultMarketPublicAllocatorConfig);
+}

package/lib/esm/vault/VaultMarketPublicAllocatorConfig.js

@@ -0,0 +1,24 @@
+export class VaultMarketPublicAllocatorConfig {
+    /**
+     * The vault's address.
+     */
+    vault;
+    /**
+     * The market's id.
+     */
+    marketId;
+    /**
+     * The maximum amount of tokens that can be allocated to this market by the vault via the PublicAllocator.
+     */
+    maxIn;
+    /**
+     * The maximum amount of tokens that can be allocated out of this market by the vault via the PublicAllocator.
+     */
+    maxOut;
+    constructor({ vault, marketId, maxIn, maxOut, }) {
+        this.vault = vault;
+        this.marketId = marketId;
+        this.maxIn = maxIn;
+        this.maxOut = maxOut;
+    }
+}

package/lib/esm/vault/VaultUser.d.ts

@@ -0,0 +1,26 @@
+import type { Address } from "../types.js";
+export interface IVaultUser {
+    vault: Address;
+    user: Address;
+    isAllocator: boolean;
+    allowance: bigint;
+}
+export declare class VaultUser implements IVaultUser {
+    /**
+     * The vault's address.
+     */
+    readonly vault: Address;
+    /**
+     * The user's address.
+     */
+    readonly user: Address;
+    /**
+     * Whether the user is an allocator of the vault.
+     */
+    isAllocator: boolean;
+    /**
+     * The allowance of the vault over the user's underlying assets.
+     */
+    allowance: bigint;
+    constructor({ vault, user, isAllocator, allowance }: IVaultUser);
+}

package/lib/esm/vault/VaultUser.js

@@ -0,0 +1,24 @@
+export class VaultUser {
+    /**
+     * The vault's address.
+     */
+    vault;
+    /**
+     * The user's address.
+     */
+    user;
+    /**
+     * Whether the user is an allocator of the vault.
+     */
+    isAllocator;
+    /**
+     * The allowance of the vault over the user's underlying assets.
+     */
+    allowance;
+    constructor({ vault, user, isAllocator, allowance }) {
+        this.vault = vault;
+        this.user = user;
+        this.isAllocator = isAllocator;
+        this.allowance = allowance;
+    }
+}

package/lib/esm/vault/VaultUtils.d.ts

@@ -0,0 +1,16 @@
+import { type RoundingDirection } from "../math/index.js";
+import type { BigIntish } from "../types.js";
+export declare namespace VaultUtils {
+    const VIRTUAL_ASSETS = 1n;
+    function decimalsOffset(decimals: BigIntish): bigint;
+    function toAssets(shares: BigIntish, { totalAssets, totalSupply, decimalsOffset, }: {
+        totalAssets: BigIntish;
+        totalSupply: BigIntish;
+        decimalsOffset: BigIntish;
+    }, rounding?: RoundingDirection): bigint;
+    function toShares(assets: BigIntish, { totalAssets, totalSupply, decimalsOffset, }: {
+        totalAssets: BigIntish;
+        totalSupply: BigIntish;
+        decimalsOffset: BigIntish;
+    }, rounding?: RoundingDirection): bigint;
+}

package/lib/esm/vault/VaultUtils.js

@@ -0,0 +1,17 @@
+import { MathLib } from "../math/index.js";
+export var VaultUtils;
+(function (VaultUtils) {
+    VaultUtils.VIRTUAL_ASSETS = 1n;
+    function decimalsOffset(decimals) {
+        return MathLib.zeroFloorSub(18n, decimals);
+    }
+    VaultUtils.decimalsOffset = decimalsOffset;
+    function toAssets(shares, { totalAssets, totalSupply, decimalsOffset, }, rounding = "Down") {
+        return MathLib.mulDiv(shares, BigInt(totalAssets) + VaultUtils.VIRTUAL_ASSETS, BigInt(totalSupply) + 10n ** BigInt(decimalsOffset), rounding);
+    }
+    VaultUtils.toAssets = toAssets;
+    function toShares(assets, { totalAssets, totalSupply, decimalsOffset, }, rounding = "Up") {
+        return MathLib.mulDiv(assets, BigInt(totalSupply) + 10n ** BigInt(decimalsOffset), BigInt(totalAssets) + VaultUtils.VIRTUAL_ASSETS, rounding);
+    }
+    VaultUtils.toShares = toShares;
+})(VaultUtils || (VaultUtils = {}));

package/lib/esm/vault/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./VaultUtils.js";
+export * from "./VaultConfig.js";
+export * from "./VaultMarketAllocation.js";
+export * from "./VaultMarketConfig.js";
+export * from "./VaultMarketPublicAllocatorConfig.js";
+export * from "./VaultUser.js";
+export * from "./Vault.js";
+export * from "./v2/index.js";

package/lib/esm/vault/index.js

@@ -0,0 +1,8 @@
+export * from "./VaultUtils.js";
+export * from "./VaultConfig.js";
+export * from "./VaultMarketAllocation.js";
+export * from "./VaultMarketConfig.js";
+export * from "./VaultMarketPublicAllocatorConfig.js";
+export * from "./VaultUser.js";
+export * from "./Vault.js";
+export * from "./v2/index.js";