@morpho-org/blue-sdk 5.15.0 → 5.17.0

package/lib/esm/token/ExchangeRateWrappedToken.d.ts

@@ -0,0 +1,11 @@
+import { type RoundingDirection } from "../math/index.js";
+import type { Address } from "../types.js";
+import type { IToken } from "./Token.js";
+import { WrappedToken } from "./WrappedToken.js";
+export declare class ExchangeRateWrappedToken extends WrappedToken {
+    readonly underlying: Address;
+    wrappedTokenExchangeRate: bigint;
+    constructor(token: IToken, underlying: Address, wrappedTokenExchangeRate: bigint);
+    protected _wrap(amount: bigint, rounding: RoundingDirection): bigint;
+    protected _unwrap(amount: bigint, rounding: RoundingDirection): bigint;
+}

package/lib/esm/token/ExchangeRateWrappedToken.js

@@ -0,0 +1,17 @@
+import { MathLib } from "../math/index.js";
+import { WrappedToken } from "./WrappedToken.js";
+export class ExchangeRateWrappedToken extends WrappedToken {
+    underlying;
+    wrappedTokenExchangeRate;
+    constructor(token, underlying, wrappedTokenExchangeRate) {
+        super(token, underlying);
+        this.underlying = underlying;
+        this.wrappedTokenExchangeRate = wrappedTokenExchangeRate;
+    }
+    _wrap(amount, rounding) {
+        return MathLib.wDiv(amount, this.wrappedTokenExchangeRate, rounding);
+    }
+    _unwrap(amount, rounding) {
+        return MathLib.wMul(amount, this.wrappedTokenExchangeRate, rounding);
+    }
+}

package/lib/esm/token/Token.d.ts

@@ -0,0 +1,52 @@
+import { type ChainId } from "../chain.js";
+import { type RoundingDirection } from "../math/index.js";
+import type { Address, BigIntish } from "../types.js";
+import type { Eip5267Domain } from "./Eip5267Domain.js";
+export interface IToken {
+    address: Address;
+    name?: string;
+    symbol?: string;
+    decimals?: BigIntish;
+    price?: BigIntish;
+    eip5267Domain?: Eip5267Domain;
+}
+export declare class Token implements IToken {
+    static native(chainId: ChainId): Token;
+    /**
+     * The token's address.
+     */
+    readonly address: Address;
+    /**
+     * The token's name.
+     */
+    readonly name?: string;
+    /**
+     * The token's symbol.
+     */
+    readonly symbol?: string;
+    /**
+     * The token's number of decimals. Defaults to 0.
+     */
+    readonly decimals: number;
+    /**
+     * The eip712 domain of the token if it can be directly queried onchain
+     */
+    readonly eip5267Domain?: Eip5267Domain;
+    /**
+     * Price of the token in USD (scaled by WAD).
+     */
+    price?: bigint;
+    constructor({ address, name, symbol, decimals, price, eip5267Domain, }: IToken);
+    /**
+     * Quotes an amount in USD (scaled by WAD) in this token.
+     * Returns `undefined` iff the token's price is undefined.
+     * @param amount The amount of USD to quote.
+     */
+    fromUsd(amount: bigint, rounding?: RoundingDirection): bigint | undefined;
+    /**
+     * Quotes an amount of tokens in USD (scaled by WAD).
+     * Returns `undefined` iff the token's price is undefined.
+     * @param amount The amount of tokens to quote.
+     */
+    toUsd(amount: bigint, rounding?: RoundingDirection): bigint | undefined;
+}

package/lib/esm/token/Token.js

@@ -0,0 +1,62 @@
+import { NATIVE_ADDRESS } from "../addresses.js";
+import { ChainUtils } from "../chain.js";
+import { MathLib } from "../math/index.js";
+export class Token {
+    static native(chainId) {
+        const currency = ChainUtils.CHAIN_METADATA[chainId].nativeCurrency;
+        return new Token({ ...currency, address: NATIVE_ADDRESS });
+    }
+    /**
+     * The token's address.
+     */
+    address;
+    /**
+     * The token's name.
+     */
+    name;
+    /**
+     * The token's symbol.
+     */
+    symbol;
+    /**
+     * The token's number of decimals. Defaults to 0.
+     */
+    decimals;
+    /**
+     * The eip712 domain of the token if it can be directly queried onchain
+     */
+    eip5267Domain;
+    /**
+     * Price of the token in USD (scaled by WAD).
+     */
+    price;
+    constructor({ address, name, symbol, decimals = 0, price, eip5267Domain, }) {
+        this.address = address;
+        this.name = name;
+        this.symbol = symbol;
+        this.decimals = Number(decimals);
+        this.eip5267Domain = eip5267Domain;
+        if (price != null)
+            this.price = BigInt(price);
+    }
+    /**
+     * Quotes an amount in USD (scaled by WAD) in this token.
+     * Returns `undefined` iff the token's price is undefined.
+     * @param amount The amount of USD to quote.
+     */
+    fromUsd(amount, rounding = "Down") {
+        if (this.price == null)
+            return;
+        return MathLib.mulDiv(amount, 10n ** BigInt(this.decimals), this.price, rounding);
+    }
+    /**
+     * Quotes an amount of tokens in USD (scaled by WAD).
+     * Returns `undefined` iff the token's price is undefined.
+     * @param amount The amount of tokens to quote.
+     */
+    toUsd(amount, rounding = "Down") {
+        if (this.price == null)
+            return;
+        return MathLib.mulDiv(amount, this.price, 10n ** BigInt(this.decimals), rounding);
+    }
+}

package/lib/esm/token/VaultToken.d.ts

@@ -0,0 +1,23 @@
+import type { RoundingDirection } from "../math/index.js";
+import type { Address, BigIntish } from "../types.js";
+import type { IVaultConfig } from "../vault/VaultConfig.js";
+import { WrappedToken } from "./WrappedToken.js";
+export interface IVaultToken {
+    totalAssets: bigint;
+    totalSupply: bigint;
+}
+export declare class VaultToken extends WrappedToken implements IVaultToken {
+    readonly asset: Address;
+    readonly decimalsOffset: bigint;
+    /**
+     * The ERC4626 vault's total supply of shares.
+     */
+    totalSupply: bigint;
+    /**
+     * The ERC4626 vault's total assets.
+     */
+    totalAssets: bigint;
+    constructor(config: IVaultConfig, { totalAssets, totalSupply }: IVaultToken);
+    protected _wrap(amount: BigIntish, rounding: RoundingDirection): bigint;
+    protected _unwrap(amount: BigIntish, rounding: RoundingDirection): bigint;
+}

package/lib/esm/token/VaultToken.js

@@ -0,0 +1,27 @@
+import { VaultUtils } from "../vault/VaultUtils.js";
+import { WrappedToken } from "./WrappedToken.js";
+export class VaultToken extends WrappedToken {
+    asset;
+    decimalsOffset;
+    /**
+     * The ERC4626 vault's total supply of shares.
+     */
+    totalSupply;
+    /**
+     * The ERC4626 vault's total assets.
+     */
+    totalAssets;
+    constructor(config, { totalAssets, totalSupply }) {
+        super(config, config.asset);
+        this.asset = config.asset;
+        this.totalAssets = totalAssets;
+        this.totalSupply = totalSupply;
+        this.decimalsOffset = BigInt(config.decimalsOffset);
+    }
+    _wrap(amount, rounding) {
+        return VaultUtils.toShares(amount, this, rounding);
+    }
+    _unwrap(amount, rounding) {
+        return VaultUtils.toAssets(amount, this, rounding);
+    }
+}

package/lib/esm/token/WrappedToken.d.ts

@@ -0,0 +1,17 @@
+import { type RoundingDirection } from "../math/index.js";
+import type { Address } from "../types.js";
+import { type IToken, Token } from "./Token.js";
+export declare abstract class WrappedToken extends Token {
+    readonly underlying: Address;
+    constructor(token: IToken, underlying: Address);
+    /** The expected amount when wrapping `unwrappedAmount` */
+    toWrappedExactAmountIn(unwrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    protected abstract _wrap(amount: bigint, rounding: RoundingDirection): bigint;
+    protected abstract _unwrap(amount: bigint, rounding: RoundingDirection): bigint;
+}

package/lib/esm/token/WrappedToken.js

@@ -0,0 +1,29 @@
+import { MathLib } from "../math/index.js";
+import { Token } from "./Token.js";
+export class WrappedToken extends Token {
+    underlying;
+    constructor(token, underlying) {
+        super(token);
+        this.underlying = underlying;
+    }
+    /** The expected amount when wrapping `unwrappedAmount` */
+    toWrappedExactAmountIn(unwrappedAmount, slippage = 0n, rounding = "Down") {
+        const wrappedAmount = this._wrap(unwrappedAmount, rounding);
+        return MathLib.wMulDown(wrappedAmount, MathLib.WAD - slippage);
+    }
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount, slippage = 0n, rounding = "Up") {
+        const wAmountTarget = MathLib.wDiv(wrappedAmount, MathLib.WAD - slippage, rounding);
+        return this._unwrap(wAmountTarget, rounding);
+    }
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount, slippage = 0n, rounding = "Down") {
+        const unwrappedAmount = this._unwrap(wrappedAmount, rounding);
+        return MathLib.wMulUp(unwrappedAmount, MathLib.WAD - slippage);
+    }
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount, slippage = 0n, rounding = "Up") {
+        const unwrappedAmountToTarget = MathLib.wDiv(unwrappedAmount, MathLib.WAD - slippage, rounding);
+        return this._wrap(unwrappedAmountToTarget, rounding);
+    }
+}

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

@@ -0,0 +1,6 @@
+export * from "./Token.js";
+export * from "./WrappedToken.js";
+export * from "./ConstantWrappedToken.js";
+export * from "./ExchangeRateWrappedToken.js";
+export * from "./VaultToken.js";
+export * from "./Eip5267Domain.js";

package/lib/esm/token/index.js

@@ -0,0 +1,6 @@
+export * from "./Token.js";
+export * from "./WrappedToken.js";
+export * from "./ConstantWrappedToken.js";
+export * from "./ExchangeRateWrappedToken.js";
+export * from "./VaultToken.js";
+export * from "./Eip5267Domain.js";

package/lib/esm/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The address of a Contract, or an EOA
+ */
+export type Address = `0x${string}`;
+/**
+ * The id of a market used on the Blue contract
+ */
+export type MarketId = `0x${string}` & {
+    __TYPE__: "marketId";
+};
+export type BigIntish = bigint | string | number | boolean;
+/**
+ * The possible transaction type on the Blue contract
+ */
+export declare enum TransactionType {
+    Supply = "Supply",
+    SupplyCollateral = "Supply Collateral",
+    Withdraw = "Withdraw",
+    WithdrawCollateral = "Withdraw Collateral",
+    Borrow = "Borrow",
+    Repay = "Repay"
+}
+export type Loadable<T> = T | undefined;
+export type Failable<T> = T | null;
+export type Fetchable<T> = Failable<Loadable<T>>;
+export declare const isMarketId: (value: unknown) => value is MarketId;

package/lib/esm/types.js

@@ -0,0 +1,13 @@
+/**
+ * The possible transaction type on the Blue contract
+ */
+export var TransactionType;
+(function (TransactionType) {
+    TransactionType["Supply"] = "Supply";
+    TransactionType["SupplyCollateral"] = "Supply Collateral";
+    TransactionType["Withdraw"] = "Withdraw";
+    TransactionType["WithdrawCollateral"] = "Withdraw Collateral";
+    TransactionType["Borrow"] = "Borrow";
+    TransactionType["Repay"] = "Repay";
+})(TransactionType || (TransactionType = {}));
+export const isMarketId = (value) => typeof value === "string" && /^0x[0-9A-Fa-f]{64}$/.test(value);

package/lib/esm/user/User.d.ts

@@ -0,0 +1,20 @@
+import type { Address } from "../types.js";
+export declare class User {
+    /**
+     * The user's address.
+     */
+    readonly address: Address;
+    /**
+     * Whether the bundler is authorized to manage the user's position on Morpho Blue.
+     */
+    isBundlerAuthorized: boolean;
+    /**
+     * The user's nonce on Morpho Blue.
+     */
+    morphoNonce: bigint;
+    constructor({ address, isBundlerAuthorized, morphoNonce, }: {
+        address: Address;
+        isBundlerAuthorized: boolean;
+        morphoNonce: bigint;
+    });
+}

package/lib/esm/user/User.js

@@ -0,0 +1,19 @@
+export class User {
+    /**
+     * The user's address.
+     */
+    address;
+    /**
+     * Whether the bundler is authorized to manage the user's position on Morpho Blue.
+     */
+    isBundlerAuthorized;
+    /**
+     * The user's nonce on Morpho Blue.
+     */
+    morphoNonce;
+    constructor({ address, isBundlerAuthorized, morphoNonce, }) {
+        this.address = address;
+        this.isBundlerAuthorized = isBundlerAuthorized;
+        this.morphoNonce = morphoNonce;
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./User.js";

package/lib/esm/user/index.js

@@ -0,0 +1 @@
+export * from "./User.js";

package/lib/esm/utils.d.ts

@@ -0,0 +1,13 @@
+export declare enum CapacityLimitReason {
+    liquidity = "Liquidity",
+    balance = "Balance",
+    position = "Position",
+    collateral = "Collateral",
+    cap = "Cap",
+    vaultV2_absoluteCap = "VaultV2_AbsoluteCap",
+    vaultV2_relativeCap = "VaultV2_RelativeCap"
+}
+export interface CapacityLimit {
+    value: bigint;
+    limiter: CapacityLimitReason;
+}

package/lib/esm/utils.js

@@ -0,0 +1,10 @@
+export var CapacityLimitReason;
+(function (CapacityLimitReason) {
+    CapacityLimitReason["liquidity"] = "Liquidity";
+    CapacityLimitReason["balance"] = "Balance";
+    CapacityLimitReason["position"] = "Position";
+    CapacityLimitReason["collateral"] = "Collateral";
+    CapacityLimitReason["cap"] = "Cap";
+    CapacityLimitReason["vaultV2_absoluteCap"] = "VaultV2_AbsoluteCap";
+    CapacityLimitReason["vaultV2_relativeCap"] = "VaultV2_RelativeCap";
+})(CapacityLimitReason || (CapacityLimitReason = {}));

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

@@ -0,0 +1,214 @@
+import { type RoundingDirection } from "../math/index.js";
+import { VaultToken } from "../token/index.js";
+import type { Address, BigIntish, MarketId } from "../types.js";
+import { type CapacityLimit } from "../utils.js";
+import type { IVaultConfig } from "./VaultConfig.js";
+import { type IVaultMarketAllocation, VaultMarketAllocation } from "./VaultMarketAllocation.js";
+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 IVault extends IVaultConfig {
+    curator: Address;
+    owner: Address;
+    guardian: Address;
+    fee: bigint;
+    feeRecipient: Address;
+    skimRecipient: Address;
+    pendingTimelock: Pending<bigint>;
+    pendingGuardian: Pending<Address>;
+    pendingOwner: Address;
+    timelock: bigint;
+    supplyQueue: MarketId[];
+    withdrawQueue: MarketId[];
+    totalSupply: bigint;
+    totalAssets: bigint;
+    lastTotalAssets: bigint;
+    lostAssets?: bigint;
+    publicAllocatorConfig?: VaultPublicAllocatorConfig;
+}
+export declare class Vault extends VaultToken implements IVault {
+    /**
+     * The vault's share token's name.
+     */
+    readonly name: string;
+    /**
+     * The vault's share token's symbol.
+     */
+    readonly symbol: string;
+    /**
+     * 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 MetaMorpho vault's last total assets used to calculate performance fees.
+     */
+    lastTotalAssets: bigint;
+    /**
+     * The MetaMorpho vault's lost assets due to realized bad debt.
+     * Only defined for MetaMorpho V1.1 vaults.
+     */
+    lostAssets?: bigint;
+    /**
+     * The MetaMorpho vault's public allocator configuration.
+     */
+    publicAllocatorConfig?: VaultPublicAllocatorConfig;
+    constructor({ curator, owner, guardian, publicAllocatorConfig, fee, feeRecipient, skimRecipient, pendingTimelock, pendingGuardian, pendingOwner, timelock, supplyQueue, withdrawQueue, totalSupply, totalAssets, lastTotalAssets, lostAssets, ...config }: IVault);
+    /**
+     * The amount of interest in assets accrued since the last interaction with the vault.
+     */
+    get totalInterest(): bigint;
+    toAssets(shares: BigIntish, rounding?: RoundingDirection): bigint;
+    toShares(assets: BigIntish, rounding?: RoundingDirection): bigint;
+}
+export interface CollateralAllocation {
+    address: Address;
+    lltvs: Set<bigint>;
+    oracles: Set<Address>;
+    markets: Set<MarketId>;
+    proportion: bigint;
+}
+export interface IAccrualVault extends Omit<IVault, "withdrawQueue" | "totalAssets"> {
+}
+export declare class AccrualVault extends Vault implements IAccrualVault {
+    /**
+     * @inheritdoc
+     * Reflects the sum of assets of the vault's allocations.
+     * Only includes virtually accrued interest if the vault's allocations include virtually accrued interest.
+     */
+    totalAssets: bigint;
+    /**
+     * The allocation of the vault on each market enabled.
+     */
+    readonly allocations: Map<MarketId, VaultMarketAllocation>;
+    /**
+     * The proportion of assets of the vault supplied to markets collateralized by each collateral asset.
+     */
+    readonly collateralAllocations: Map<Address, CollateralAllocation>;
+    constructor(vault: IAccrualVault, 
+    /**
+     * The allocation of the vault on each market of the withdraw queue,
+     * in the same order as the withdraw queue.
+     */
+    allocations: Omit<IVaultMarketAllocation, "proportion">[]);
+    /**
+     * The vault's liquidity directly available from allocated markets.
+     */
+    get liquidity(): bigint;
+    /**
+     * 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(): number;
+    /**
+     * 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(): number;
+    /**
+     * 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.
+     */
+    private _getAvgRate;
+    /**
+     * 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?: BigIntish): number;
+    /**
+     * 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?: BigIntish): number;
+    getAllocationProportion(marketId: MarketId): bigint;
+    /**
+     * 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: bigint): CapacityLimit;
+    /**
+     * 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: bigint): CapacityLimit;
+    /**
+     * Returns the maximum amount of assets that can be deposited to the vault.
+     * @param assets The maximum amount of assets to deposit.
+     */
+    maxDeposit(assets: BigIntish): CapacityLimit;
+    /**
+     * Returns the maximum amount of assets that can be withdrawn from the vault.
+     * @param shares The maximum amount of shares to redeem.
+     */
+    maxWithdraw(shares: BigIntish): CapacityLimit;
+    /**
+     * 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?: BigIntish): AccrualVault;
+}