@morpho-org/blue-sdk 1.0.0-integ-650.0

package/lib/token/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Token"), exports);
+__exportStar(require("./WrappedToken"), exports);
+__exportStar(require("./ConstantWrappedToken"), exports);
+__exportStar(require("./ExchangeRateWrappedToken"), exports);
+__exportStar(require("./VaultToken"), exports);

package/lib/types.d.ts

@@ -0,0 +1,30 @@
+export type Hex64 = string & {
+    __LENGTH__: 64;
+};
+/**
+ * The address of a Contract, or an EOA
+ */
+export type Address = string;
+/**
+ * The id of a market used on the Blue contract
+ */
+export type MarketId = `0x${Hex64}` & {
+    __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: any) => value is MarketId;

package/lib/types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMarketId = exports.TransactionType = void 0;
+exports.isFetched = isFetched;
+/**
+ * The possible transaction type on the Blue contract
+ */
+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 || (exports.TransactionType = TransactionType = {}));
+// TODO: replace with isDefined
+function isFetched(v) {
+    return v !== undefined && v !== null;
+}
+const isMarketId = (value) => typeof value === "string" && /^0x[0-9A-Fa-f]{64}$/.test(value);
+exports.isMarketId = isMarketId;

package/lib/user/User.d.ts

@@ -0,0 +1,20 @@
+import { Address } from "../types";
+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,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+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;
+    }
+}
+exports.User = User;

package/lib/user/index.d.ts

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

package/lib/user/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./User"), exports);

package/lib/vault/Vault.d.ts

@@ -0,0 +1,166 @@
+import { CapacityLimit } from "../market";
+import { RoundingDirection } from "../maths";
+import { VaultToken } from "../token";
+import { Address, BigIntish, MarketId } from "../types";
+import { VaultConfig } from "./VaultConfig";
+import { InputVaultMarketAllocation, VaultMarketAllocation } from "./VaultMarketAllocation";
+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: 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 config.
+     */
+    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);
+    get asset(): string;
+    /**
+     * 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;
+}

package/lib/vault/Vault.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccrualVault = exports.Vault = void 0;
+const market_1 = require("../market");
+const maths_1 = require("../maths");
+const token_1 = require("../token");
+const VaultMarketAllocation_1 = require("./VaultMarketAllocation");
+const VaultUtils_1 = require("./VaultUtils");
+class Vault extends token_1.VaultToken {
+    /**
+     * The MetaMorpho vault's config.
+     */
+    config;
+    /**
+     * 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 ERC4626 vault's total supply of shares.
+     */
+    totalSupply;
+    /**
+     * The ERC4626 vault's total assets.
+     */
+    totalAssets;
+    /**
+     * The MetaMorpho vault's last total assets used to calculate performance fees.
+     */
+    lastTotalAssets;
+    /**
+     * The MetaMorpho vault's public allocator configuration.
+     */
+    publicAllocatorConfig;
+    constructor({ config, curator, owner, guardian, publicAllocatorConfig, fee, feeRecipient, skimRecipient, pendingTimelock, pendingGuardian, pendingOwner, timelock, supplyQueue, withdrawQueue, totalSupply, totalAssets, lastTotalAssets, }) {
+        super(config, { totalAssets, totalSupply });
+        this.config = config;
+        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.totalSupply = totalSupply;
+        this.totalAssets = totalAssets;
+        this.lastTotalAssets = lastTotalAssets;
+        this.publicAllocatorConfig = publicAllocatorConfig;
+    }
+    get asset() {
+        return this.config.asset;
+    }
+    /**
+     * The amount of interest in assets accrued since the last interaction with the vault.
+     */
+    get totalInterest() {
+        return maths_1.MathLib.zeroFloorSub(this.totalAssets, this.lastTotalAssets);
+    }
+    toAssets(shares, rounding) {
+        return VaultUtils_1.VaultUtils.toAssets(shares, this, this.config, rounding);
+    }
+    toShares(assets, rounding) {
+        return VaultUtils_1.VaultUtils.toShares(assets, this, this.config, rounding);
+    }
+}
+exports.Vault = Vault;
+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_1.VaultMarketAllocation(allocation),
+        ]));
+        this.collateralAllocations = new Map();
+        for (const { marketId, position } 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(marketId);
+            exposure.proportion += this.getAllocationProportion(marketId);
+        }
+    }
+    /**
+     * 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 maths_1.MathLib.wMulDown(this.avgApy, maths_1.MathLib.WAD - this.fee);
+    }
+    getAllocationProportion(marketId) {
+        if (this.totalAssets === 0n)
+            return 0n;
+        const allocation = this.allocations.get(marketId);
+        if (!allocation)
+            return 0n;
+        return maths_1.MathLib.wDivDown(allocation.position.supplyAssets, this.totalAssets);
+    }
+    getDepositCapacityLimit(assets) {
+        const suppliable = Array.from(this.allocations.values()).reduce((total, { config: { cap }, position: { marketId, supplyAssets } }) => maths_1.MathLib.min(total +
+            (this.supplyQueue.includes(marketId)
+                ? maths_1.MathLib.zeroFloorSub(cap, supplyAssets)
+                : 0n), maths_1.MathLib.MAX_UINT_256), 0n);
+        if (assets > suppliable)
+            return {
+                value: suppliable,
+                limiter: market_1.CapacityLimitReason.cap,
+            };
+        return {
+            value: assets,
+            limiter: market_1.CapacityLimitReason.balance,
+        };
+    }
+    getWithdrawCapacityLimit(shares) {
+        const assets = this.toAssets(shares);
+        const { liquidity } = this;
+        if (assets > liquidity)
+            return {
+                value: liquidity,
+                limiter: market_1.CapacityLimitReason.liquidity,
+            };
+        return {
+            value: assets,
+            limiter: market_1.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, Array.from(this.allocations.values(), ({ config, position }) => ({
+            config,
+            position: position.accrueInterest(timestamp),
+        })));
+        const feeAssets = maths_1.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;
+    }
+}
+exports.AccrualVault = AccrualVault;

package/lib/vault/VaultConfig.d.ts

@@ -0,0 +1,22 @@
+import { ChainId } from "../chain";
+import { Address } from "../types";
+export interface InputVaultConfig {
+    address: Address;
+    decimals: number;
+    decimalsOffset: bigint;
+    symbol: string;
+    name: string;
+    asset: Address;
+}
+export declare class VaultConfig implements InputVaultConfig {
+    readonly chainId?: number | undefined;
+    protected static readonly _CACHE: Record<number, Record<Address, VaultConfig>>;
+    static get(address: Address, chainId: ChainId): VaultConfig;
+    readonly address: Address;
+    readonly decimals: number;
+    readonly decimalsOffset: bigint;
+    readonly symbol: string;
+    readonly name: string;
+    readonly asset: Address;
+    constructor({ address, decimals, decimalsOffset, symbol, name, asset, }: InputVaultConfig, chainId?: number | undefined);
+}

package/lib/vault/VaultConfig.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultConfig = void 0;
+const errors_1 = require("../errors");
+class VaultConfig {
+    chainId;
+    static _CACHE = {};
+    static get(address, chainId) {
+        const config = VaultConfig._CACHE[chainId]?.[address];
+        if (!config)
+            throw new errors_1.UnknownVaultConfigError(address);
+        return config;
+    }
+    address;
+    decimals;
+    decimalsOffset;
+    symbol;
+    name;
+    asset;
+    constructor({ address, decimals, decimalsOffset, symbol, name, asset, }, chainId) {
+        this.chainId = chainId;
+        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;
+    }
+}
+exports.VaultConfig = VaultConfig;

package/lib/vault/VaultMarketAllocation.d.ts

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

package/lib/vault/VaultMarketAllocation.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultMarketAllocation = void 0;
+const maths_1 = require("../maths");
+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 = config;
+        this.position = position;
+    }
+    get vault() {
+        return this.config.vault;
+    }
+    get marketId() {
+        return this.config.marketId;
+    }
+    get utilization() {
+        if (this.config.cap === 0n)
+            return maths_1.MathLib.MAX_UINT_256;
+        return maths_1.MathLib.wDivDown(this.position.supplyAssets, this.config.cap);
+    }
+}
+exports.VaultMarketAllocation = VaultMarketAllocation;