@morpho-org/blue-sdk 1.0.0 → 1.0.1

package/lib/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMarketId = exports.isFetched = exports.TransactionType = void 0;
+const ethers_1 = require("ethers");
+/**
+ * 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;
+}
+exports.isFetched = isFetched;
+const isMarketId = (value) => (0, ethers_1.isHexString)(value, 32);
+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,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+class User {
+    constructor({ address, isBundlerAuthorized, morphoNonce, }) {
+        this.address = address;
+        this.isBundlerAuthorized = isBundlerAuthorized;
+        this.morphoNonce = morphoNonce;
+    }
+}
+exports.User = User;

package/lib/user/index.js

@@ -0,0 +1,18 @@
+"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.types"), exports);
+__exportStar(require("./User"), exports);

package/lib/user/user.types.d.ts

@@ -0,0 +1,18 @@
+import { Token } from "../token";
+export interface MaxBalanceDecomposition {
+    maxBalance: bigint;
+    decomposition: {
+        base: BalanceDecompositionFragment;
+    } & {
+        [T in Exclude<PeripheralTokenType, "base">]?: BalanceDecompositionFragment;
+    };
+}
+export type PeripheralTokenType = "base" | "wrapped" | "erc4626" | "wrapped-erc4626";
+export interface PeripheralToken {
+    token: Token;
+    type: PeripheralTokenType;
+}
+export interface BalanceDecompositionFragment extends PeripheralToken {
+    underlyingValue: bigint;
+    value: bigint;
+}

package/lib/user/user.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/vault/Vault.d.ts

@@ -0,0 +1,167 @@
+import { BigNumberish } from "ethers";
+import { CapacityLimit } from "../market";
+import { RoundingDirection } from "../maths";
+import { Token } from "../token";
+import { Address, MarketId } from "../types";
+import { InputVaultAllocation, VaultAllocation } from "./VaultAllocation";
+import { VaultConfig } from "./VaultConfig";
+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;
+    supplyQueue: MarketId[];
+    withdrawQueue: MarketId[];
+    totalSupply: BigNumberish;
+    totalAssets: BigNumberish;
+    lastTotalAssets: BigNumberish;
+    publicAllocatorConfig?: VaultPublicAllocatorConfig;
+}
+export declare class Vault 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 address(): string;
+    get asset(): string;
+    /**
+     * The amount of interest in assets accrued since the last interaction with the vault.
+     */
+    get totalInterest(): bigint;
+    toAssets(shares: BigNumberish, rounding?: RoundingDirection): bigint;
+    toShares(assets: BigNumberish, 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, VaultAllocation>;
+    /**
+     * The ERC4626 vault's share token.
+     */
+    token: Token;
+    /**
+     * 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<InputVaultAllocation, "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;
+    getDepositCapacityLimit(assets: bigint): CapacityLimit;
+    getWithdrawCapacityLimit(shares: bigint): CapacityLimit;
+    accrueInterest(timestamp: bigint): AccrualVault;
+}

package/lib/vault/Vault.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccrualVault = exports.Vault = void 0;
+const ethers_1 = require("ethers");
+const market_1 = require("../market");
+const maths_1 = require("../maths");
+const token_1 = require("../token");
+const VaultAllocation_1 = require("./VaultAllocation");
+const VaultUtils_1 = require("./VaultUtils");
+class Vault {
+    constructor({ config, curator, owner, guardian, publicAllocatorConfig, fee, feeRecipient, skimRecipient, pendingTimelock, pendingGuardian, pendingOwner, timelock, supplyQueue, withdrawQueue, totalSupply, totalAssets, lastTotalAssets, }) {
+        this.config = config;
+        this.curator = curator;
+        this.owner = owner;
+        this.guardian = guardian;
+        this.fee = (0, ethers_1.toBigInt)(fee);
+        this.feeRecipient = feeRecipient;
+        this.skimRecipient = skimRecipient;
+        this.pendingTimelock = {
+            value: (0, ethers_1.toBigInt)(pendingTimelock.value),
+            validAt: pendingTimelock.validAt,
+        };
+        this.pendingGuardian = pendingGuardian;
+        this.pendingOwner = pendingOwner;
+        this.timelock = (0, ethers_1.toBigInt)(timelock);
+        this.supplyQueue = supplyQueue;
+        this.withdrawQueue = withdrawQueue;
+        this.totalSupply = (0, ethers_1.toBigInt)(totalSupply);
+        this.totalAssets = (0, ethers_1.toBigInt)(totalAssets);
+        this.lastTotalAssets = (0, ethers_1.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 maths_1.MathUtils.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 {
+    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(({ config, position }) => [
+            position.market.id,
+            new VaultAllocation_1.VaultAllocation({
+                config,
+                position,
+                proportion: this.totalAssets === 0n
+                    ? 0n
+                    : maths_1.MathLib.wDivDown(position.supplyAssets, this.totalAssets),
+            }),
+        ]));
+        this.token = new token_1.Token(this.config);
+        this.collateralAllocations = new Map();
+        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 maths_1.MathLib.wMulDown(this.avgApy, maths_1.MathLib.WAD - this.fee);
+    }
+    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.MathUtils.zeroFloorSub(cap, supplyAssets)
+                : 0n), ethers_1.MaxUint256), 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,
+        };
+    }
+    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/VaultAllocation.d.ts

@@ -0,0 +1,38 @@
+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 declare class VaultAllocation implements InputVaultAllocation {
+    /**
+     * The vault's configuration on the corresponding market.
+     */
+    config: VaultMarketConfig;
+    /**
+     * The vault's position on the corresponding market.
+     */
+    readonly position: AccrualPosition;
+    /**
+     * The vault's proportion of assets supplied on the corresponding market,
+     * with regard to the total assets of the vault.
+     */
+    readonly proportion: bigint;
+    constructor({ config, position, proportion }: InputVaultAllocation);
+    get utilization(): bigint;
+}

package/lib/vault/VaultAllocation.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultAllocation = void 0;
+const ethers_1 = require("ethers");
+const maths_1 = require("../maths");
+class VaultAllocation {
+    constructor({ config, position, proportion }) {
+        this.config = config;
+        this.position = position;
+        this.proportion = proportion;
+    }
+    get utilization() {
+        if (this.config.cap === 0n)
+            return ethers_1.MaxUint256;
+        return maths_1.MathLib.wDivDown(this.position.supplyAssets, this.config.cap);
+    }
+}
+exports.VaultAllocation = VaultAllocation;

package/lib/vault/VaultConfig.d.ts

@@ -0,0 +1,23 @@
+import { ChainId } from "../chain";
+import { Address } from "../types";
+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);
+}
+export {};

package/lib/vault/VaultConfig.js

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

package/lib/vault/VaultUtils.d.ts

@@ -0,0 +1,17 @@
+import { BigNumberish } from "ethers";
+import { RoundingDirection } from "../maths";
+export declare namespace VaultUtils {
+    const VIRTUAL_ASSETS = 1n;
+    function toAssets(shares: BigNumberish, { totalAssets, totalSupply, }: {
+        totalAssets: BigNumberish;
+        totalSupply: BigNumberish;
+    }, { decimalsOffset }: {
+        decimalsOffset: BigNumberish;
+    }, rounding?: RoundingDirection): bigint;
+    function toShares(assets: BigNumberish, { totalAssets, totalSupply, }: {
+        totalAssets: BigNumberish;
+        totalSupply: BigNumberish;
+    }, { decimalsOffset }: {
+        decimalsOffset: BigNumberish;
+    }, rounding?: RoundingDirection): bigint;
+}

package/lib/vault/VaultUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultUtils = void 0;
+const ethers_1 = require("ethers");
+const maths_1 = require("../maths");
+var VaultUtils;
+(function (VaultUtils) {
+    VaultUtils.VIRTUAL_ASSETS = 1n;
+    function toAssets(shares, { totalAssets, totalSupply, }, { decimalsOffset }, rounding = "Down") {
+        return maths_1.MathLib.mulDiv(shares, (0, ethers_1.toBigInt)(totalAssets) + VaultUtils.VIRTUAL_ASSETS, (0, ethers_1.toBigInt)(totalSupply) + 10n ** (0, ethers_1.toBigInt)(decimalsOffset), rounding);
+    }
+    VaultUtils.toAssets = toAssets;
+    function toShares(assets, { totalAssets, totalSupply, }, { decimalsOffset }, rounding = "Up") {
+        return maths_1.MathLib.mulDiv(assets, (0, ethers_1.toBigInt)(totalSupply) + 10n ** (0, ethers_1.toBigInt)(decimalsOffset), (0, ethers_1.toBigInt)(totalAssets) + VaultUtils.VIRTUAL_ASSETS, rounding);
+    }
+    VaultUtils.toShares = toShares;
+})(VaultUtils || (exports.VaultUtils = VaultUtils = {}));

package/lib/vault/index.js

@@ -0,0 +1,20 @@
+"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("./VaultUtils"), exports);
+__exportStar(require("./VaultConfig"), exports);
+__exportStar(require("./VaultAllocation"), exports);
+__exportStar(require("./Vault"), exports);

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@morpho-org/blue-sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "author": "Morpho Association <contact@morpho.org>",
   "license": "MIT",
   "main": "src/index.ts",
   "files": [
-    "src"
+    "lib"
   ],
   "scripts": {
     "prepublish": "yarn build",
@@ -15,14 +15,14 @@
     "test:blue-sdk": "yarn test"
   },
   "dependencies": {
-    "@morpho-org/morpho-ts": "1.0.0",
+    "@morpho-org/morpho-ts": "1.0.1",
     "ethers": "^6.12.1",
     "ethers-multicall-provider": "^6.3.0",
     "ethers-types": "^3.15.1",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "@morpho-org/morpho-test": "1.0.0",
+    "@morpho-org/morpho-test": "1.0.1",
     "@types/jest": "^29.5.12",
     "jest": "^29.6.2",
     "ts-jest": "^29.1.1",
@@ -50,5 +50,5 @@
     ],
     "preset": "ts-jest"
   },
-  "gitHead": "ba4bc39fbf7d9e2fe2282b451940fb90305544fa"
+  "gitHead": "474aa49a57a91da7d47a0bf666b5fccede4d395e"
 }