@morpho-org/blue-sdk 2.0.0-next.1 → 2.0.0-next.4

package/lib/token/ConstantWrappedToken.js

@@ -0,0 +1,30 @@
+import { MathLib } from "../math/index.js";
+import { WrappedToken } from "./WrappedToken.js";
+export class ConstantWrappedToken extends WrappedToken {
+    underlyingDecimals;
+    constructor(token, underlying, underlyingDecimals = 18n) {
+        super(token, underlying);
+        this.underlyingDecimals = BigInt(underlyingDecimals);
+    }
+    toWrappedExactAmountIn(unwrappedAmount, _slippage, rounding = "Down") {
+        return super.toWrappedExactAmountIn(unwrappedAmount, 0n, rounding);
+    }
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount, _slippage, rounding = "Up") {
+        return super.toWrappedExactAmountOut(wrappedAmount, 0n, rounding);
+    }
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount, _slippage, rounding = "Down") {
+        return super.toUnwrappedExactAmountIn(wrappedAmount, 0n, rounding);
+    }
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount, _slippage, rounding = "Up") {
+        return super.toUnwrappedExactAmountOut(unwrappedAmount, 0n, rounding);
+    }
+    _wrap(amount) {
+        return MathLib.mulDivDown(amount, 10n ** BigInt(this.decimals), 10n ** this.underlyingDecimals);
+    }
+    _unwrap(amount) {
+        return MathLib.mulDivDown(amount, 10n ** this.underlyingDecimals, 10n ** BigInt(this.decimals));
+    }
+}

package/lib/token/ExchangeRateWrappedToken.d.ts

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

package/lib/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/token/Token.d.ts

@@ -0,0 +1,46 @@
+import { type ChainId } from "../chain.js";
+import { type RoundingDirection } from "../math/index.js";
+import type { Address, BigIntish } from "../types.js";
+export interface InputToken {
+    address: Address;
+    decimals: BigIntish;
+    symbol: string;
+    name?: string;
+}
+export declare class Token implements InputToken {
+    static native(chainId: ChainId): Token;
+    /**
+     * The token's address.
+     */
+    readonly address: Address;
+    /**
+     * The token's number of decimals.
+     */
+    readonly decimals: number;
+    /**
+     * The token's symbol.
+     */
+    readonly symbol: string;
+    /**
+     * The name of the token (defaults to the symbol).
+     */
+    readonly name: string;
+    constructor({ address, decimals, symbol, name }: InputToken);
+}
+export declare class TokenWithPrice extends Token {
+    /**
+     * Price of the token in USD (scaled by WAD).
+     */
+    price?: bigint;
+    constructor(token: InputToken, price?: bigint);
+    /**
+     * Quotes an amount in USD (scaled by WAD) in this token.
+     * @param amount The amount of USD to quote.
+     */
+    fromUsd(amount: bigint, rounding?: RoundingDirection): bigint | null;
+    /**
+     * Quotes an amount of tokens in USD (scaled by WAD).
+     * @param amount The amount of tokens to quote.
+     */
+    toUsd(amount: bigint, rounding?: RoundingDirection): bigint | null;
+}

package/lib/token/Token.js

@@ -0,0 +1,59 @@
+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 number of decimals.
+     */
+    decimals;
+    /**
+     * The token's symbol.
+     */
+    symbol;
+    /**
+     * The name of the token (defaults to the symbol).
+     */
+    name;
+    constructor({ address, decimals, symbol, name }) {
+        this.address = address;
+        this.decimals = Number(decimals);
+        this.symbol = symbol;
+        this.name = name ?? symbol;
+    }
+}
+export class TokenWithPrice extends Token {
+    /**
+     * Price of the token in USD (scaled by WAD).
+     */
+    price;
+    constructor(token, price) {
+        super(token);
+        this.price = price;
+    }
+    /**
+     * Quotes an amount in USD (scaled by WAD) in this token.
+     * @param amount The amount of USD to quote.
+     */
+    fromUsd(amount, rounding = "Down") {
+        if (this.price == null)
+            return null;
+        return MathLib.mulDiv(amount, 10n ** BigInt(this.decimals), this.price, rounding);
+    }
+    /**
+     * Quotes an amount of tokens in USD (scaled by WAD).
+     * @param amount The amount of tokens to quote.
+     */
+    toUsd(amount, rounding = "Down") {
+        if (this.price == null)
+            return null;
+        return MathLib.mulDiv(amount, this.price, 10n ** BigInt(this.decimals), rounding);
+    }
+}

package/lib/token/VaultToken.d.ts

@@ -0,0 +1,23 @@
+import type { RoundingDirection } from "../math/index.js";
+import type { Address } from "../types.js";
+import type { InputVaultConfig } from "../vault/VaultConfig.js";
+import { WrappedToken } from "./WrappedToken.js";
+export interface InputVaultToken {
+    totalAssets: bigint;
+    totalSupply: bigint;
+}
+export declare class VaultToken extends WrappedToken implements InputVaultToken {
+    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: InputVaultConfig, { totalAssets, totalSupply }: InputVaultToken);
+    protected _wrap(amount: bigint, rounding?: RoundingDirection): bigint;
+    protected _unwrap(amount: bigint, rounding?: RoundingDirection): bigint;
+}

package/lib/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/token/WrappedToken.d.ts

@@ -0,0 +1,17 @@
+import { type RoundingDirection } from "../math/index.js";
+import type { Address } from "../types.js";
+import { type InputToken, Token } from "./Token.js";
+export declare abstract class WrappedToken extends Token {
+    readonly underlying: Address;
+    constructor(token: InputToken, 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/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.wMul(wrappedAmount, MathLib.WAD - slippage, "Down");
+    }
+    /** 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.wMul(unwrappedAmount, MathLib.WAD - slippage, "Up");
+    }
+    /** 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/token/index.d.ts

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

package/lib/token/index.js

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

package/lib/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 function isFetched<T>(v: Fetchable<T>): v is T;
+export declare const isMarketId: (value: unknown) => value is MarketId;

package/lib/types.js

@@ -0,0 +1,17 @@
+/**
+ * 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 = {}));
+// TODO: replace with isDefined
+export function isFetched(v) {
+    return v !== undefined && v !== null;
+}
+export const isMarketId = (value) => typeof value === "string" && /^0x[0-9A-Fa-f]{64}$/.test(value);

package/lib/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/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/user/index.d.ts

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

package/lib/user/index.js

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

package/lib/vault/Vault.d.ts

@@ -0,0 +1,152 @@
+import { type CapacityLimit } from "../market/index.js";
+import { type RoundingDirection } from "../math/index.js";
+import { VaultToken } from "../token/index.js";
+import type { Address, BigIntish, MarketId } from "../types.js";
+import type { InputVaultConfig } from "./VaultConfig.js";
+import { type InputVaultMarketAllocation, 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 InputVault extends InputVaultConfig {
+    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;
+    publicAllocatorConfig?: VaultPublicAllocatorConfig;
+}
+export declare class Vault extends VaultToken implements InputVault {
+    /**
+     * 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 public allocator configuration.
+     */
+    publicAllocatorConfig?: VaultPublicAllocatorConfig;
+    constructor({ curator, owner, guardian, publicAllocatorConfig, fee, feeRecipient, skimRecipient, pendingTimelock, pendingGuardian, pendingOwner, timelock, supplyQueue, withdrawQueue, totalSupply, totalAssets, lastTotalAssets, ...config }: InputVault);
+    /**
+     * The amount of interest in assets accrued since the last interaction with the vault.
+     */
+    get totalInterest(): bigint;
+    toAssets(shares: bigint, rounding?: RoundingDirection): bigint;
+    toShares(assets: bigint, rounding?: RoundingDirection): bigint;
+}
+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 declare class AccrualVault extends Vault implements InputAccrualVault {
+    /**
+     * 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: InputAccrualVault, 
+    /**
+     * The allocation of the vault on each market of the withdraw queue,
+     * in the same order as the withdraw queue.
+     */
+    allocations: Omit<InputVaultMarketAllocation, "proportion">[]);
+    /**
+     * The vault's liquidity directly available from allocated markets.
+     */
+    get liquidity(): bigint;
+    /**
+     * The MetaMorpho vault's average APY on its assets, including the performance fee.
+     */
+    get avgApy(): bigint;
+    /**
+     * The MetaMorpho vault's average APY on its assets, excluding the performance fee.
+     */
+    get netApy(): bigint;
+    getAllocationProportion(marketId: MarketId): bigint;
+    getDepositCapacityLimit(assets: bigint): CapacityLimit;
+    getWithdrawCapacityLimit(shares: bigint): 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;
+}