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

package/lib/vault/Vault.js

@@ -0,0 +1,221 @@
+import { CapacityLimitReason } from "../market/index.js";
+import { MathLib } from "../math/index.js";
+import { VaultToken } from "../token/index.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 public allocator configuration.
+     */
+    publicAllocatorConfig;
+    constructor({ curator, owner, guardian, publicAllocatorConfig, fee, feeRecipient, skimRecipient, pendingTimelock, pendingGuardian, pendingOwner, timelock, supplyQueue, withdrawQueue, totalSupply, totalAssets, lastTotalAssets, ...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.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) {
+        return this._unwrap(shares, rounding);
+    }
+    toShares(assets, rounding) {
+        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.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 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 (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 MathLib.wMulDown(this.avgApy, 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);
+    }
+    getDepositCapacityLimit(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,
+        };
+    }
+    getWithdrawCapacityLimit(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),
+            };
+        }));
+        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/vault/VaultConfig.d.ts

@@ -0,0 +1,22 @@
+import type { ChainId } from "../chain.js";
+import type { Address, BigIntish } from "../types.js";
+export interface InputVaultConfig {
+    address: Address;
+    decimals: BigIntish;
+    decimalsOffset: BigIntish;
+    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,28 @@
+import { UnknownVaultConfigError } from "../errors.js";
+export class VaultConfig {
+    chainId;
+    static _CACHE = {};
+    static get(address, chainId) {
+        const config = VaultConfig._CACHE[chainId]?.[address];
+        if (!config)
+            throw new 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 = Number(decimals);
+        this.decimalsOffset = BigInt(decimalsOffset);
+        this.symbol = symbol;
+        this.name = name;
+        this.asset = asset;
+        if (chainId != null)
+            (VaultConfig._CACHE[chainId] ??= {})[address] = this;
+    }
+}

package/lib/vault/VaultMarketAllocation.d.ts

@@ -0,0 +1,20 @@
+import type { AccrualPosition } from "../position/index.js";
+import type { VaultMarketConfig } from "./VaultMarketConfig.js";
+export interface InputVaultMarketAllocation {
+    config: VaultMarketConfig;
+    position: AccrualPosition;
+}
+export declare class VaultMarketAllocation implements InputVaultMarketAllocation {
+    /**
+     * 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 }: InputVaultMarketAllocation);
+    get vault(): `0x${string}`;
+    get marketId(): import("../types.js").MarketId;
+    get utilization(): bigint;
+}

package/lib/vault/VaultMarketAllocation.js

@@ -0,0 +1,26 @@
+import { MathLib } from "../math/index.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 = 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/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 InputVaultMarketConfig {
+    vault: Address;
+    marketId: MarketId;
+    cap: bigint;
+    pendingCap: Pending<bigint>;
+    removableAt: bigint;
+    enabled: boolean;
+    publicAllocatorConfig: VaultMarketPublicAllocatorConfig;
+}
+export declare class VaultMarketConfig implements InputVaultMarketConfig {
+    /**
+     * 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, }: InputVaultMarketConfig);
+}

package/lib/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/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 InputVaultMarketPublicAllocatorConfig {
+    vault: Address;
+    marketId: MarketId;
+    maxIn: bigint;
+    maxOut: bigint;
+}
+export declare class VaultMarketPublicAllocatorConfig implements InputVaultMarketPublicAllocatorConfig {
+    /**
+     * 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, }: InputVaultMarketPublicAllocatorConfig);
+}

package/lib/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/vault/VaultUser.d.ts

@@ -0,0 +1,26 @@
+import type { Address } from "../types.js";
+export interface InputVaultUser {
+    vault: Address;
+    user: Address;
+    isAllocator: boolean;
+    allowance: bigint;
+}
+export declare class VaultUser implements InputVaultUser {
+    /**
+     * 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 }: InputVaultUser);
+}

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

@@ -0,0 +1,7 @@
+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";

package/lib/vault/index.js

@@ -0,0 +1,7 @@
+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";

package/package.json

@@ -1,44 +1,28 @@
 {
   "name": "@morpho-org/blue-sdk",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.2",
   "author": "Morpho Labs <contact@morpho.org>",
   "license": "MIT",
   "type": "module",
-  "main": "src/index.ts",
+  "main": "lib/index.js",
   "files": [
     "lib"
   ],
-  "scripts": {
-    "prepublish": "$npm_execpath build",
-    "build": "tsc --build tsconfig.build.json",
-    "test": "vitest"
-  },
   "dependencies": {
     "keccak256": "^1.0.6"
   },
   "peerDependencies": {
-    "@morpho-org/morpho-ts": "workspace:^"
+    "@morpho-org/morpho-ts": "^1.12.4"
   },
   "devDependencies": {
-    "@morpho-org/morpho-ts": "workspace:^",
-    "@morpho-org/test": "workspace:^",
-    "@morpho-org/test-viem": "workspace:^",
     "@types/node": "^22.1.0",
     "typescript": "^5.6.3",
     "viem": "^2.21.19",
     "viem-deal": "^2.0.0",
-    "vitest": "^2.1.3"
-  },
-  "publishConfig": {
-    "main": "lib/index.js",
-    "types": "lib/index.d.ts",
-    "exports": {
-      ".": {
-        "types": "./lib/index.d.ts",
-        "default": "./lib/index.js"
-      }
-    },
-    "access": "public"
+    "vitest": "^2.1.3",
+    "@morpho-org/morpho-ts": "^1.12.4",
+    "@morpho-org/test-viem": "^1.12.4",
+    "@morpho-org/test": "^1.12.4"
   },
   "release": {
     "branches": [
@@ -48,6 +32,30 @@
         "prerelease": true
       }
     ],
-    "extends": "semantic-release-monorepo"
+    "extends": "semantic-release-monorepo",
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      [
+        "@semantic-release/exec",
+        {
+          "prepareCmd": "pnpm version ${nextRelease.version} --no-git-tag-version",
+          "publishCmd": "pnpm publish --access public --tag ${nextRelease.channel} --no-git-checks"
+        }
+      ],
+      "@semantic-release/github"
+    ]
+  },
+  "scripts": {
+    "prepublish": "$npm_execpath build",
+    "build": "tsc --build tsconfig.build.json",
+    "test": "vitest"
+  },
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    }
   }
-}
+}