@morpho-org/blue-sdk 1.0.5 → 1.2.0

package/lib/token/Token.d.ts

@@ -1,4 +1,4 @@
-import { BigNumberish } from "ethers";
+import { ChainId } from "../chain";
 import { RoundingDirection } from "../maths";
 import { Address } from "../types";
 export interface InputToken {
@@ -8,6 +8,7 @@ export interface InputToken {
     name?: string;
 }
 export declare class Token implements InputToken {
+    static native(chainId: ChainId): Token;
     /**
      * The token's address.
      */
@@ -36,10 +37,10 @@ export declare class TokenWithPrice extends Token {
      * Quotes an amount in USD (scaled by WAD) in this token.
      * @param amount The amount of USD to quote.
      */
-    fromUsd(amount: BigNumberish, rounding?: RoundingDirection): bigint | null;
+    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: BigNumberish, rounding?: RoundingDirection): bigint | null;
+    toUsd(amount: bigint, rounding?: RoundingDirection): bigint | null;
 }

package/lib/token/Token.js

@@ -1,9 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenWithPrice = exports.Token = void 0;
-const ethers_1 = require("ethers");
+const addresses_1 = require("../addresses");
+const chain_1 = require("../chain");
 const maths_1 = require("../maths");
 class Token {
+    static native(chainId) {
+        const currency = chain_1.ChainUtils.CHAIN_METADATA[chainId].nativeCurrency;
+        return new Token({ ...currency, address: addresses_1.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 = decimals;
@@ -13,6 +34,10 @@ class Token {
 }
 exports.Token = Token;
 class TokenWithPrice extends Token {
+    /**
+     * Price of the token in USD (scaled by WAD).
+     */
+    price;
     constructor(token, price) {
         super(token);
         this.price = price;
@@ -24,7 +49,7 @@ class TokenWithPrice extends Token {
     fromUsd(amount, rounding = "Down") {
         if (this.price == null)
             return null;
-        return maths_1.MathLib.mulDiv(amount, (0, ethers_1.parseUnits)("1", this.decimals), this.price, rounding);
+        return maths_1.MathLib.mulDiv(amount, 10n ** BigInt(this.decimals), this.price, rounding);
     }
     /**
      * Quotes an amount of tokens in USD (scaled by WAD).
@@ -33,7 +58,7 @@ class TokenWithPrice extends Token {
     toUsd(amount, rounding = "Down") {
         if (this.price == null)
             return null;
-        return maths_1.MathLib.mulDiv(amount, this.price, (0, ethers_1.parseUnits)("1", this.decimals), rounding);
+        return maths_1.MathLib.mulDiv(amount, this.price, 10n ** BigInt(this.decimals), rounding);
     }
 }
 exports.TokenWithPrice = TokenWithPrice;

package/lib/token/WrappedToken.d.ts

@@ -1,6 +1,6 @@
 import { RoundingDirection } from "../maths";
 import { Address } from "../types";
-import { Vault } from "../vault";
+import { Vault, VaultConfig } from "../vault";
 import { InputToken, Token } from "./Token";
 export declare abstract class WrappedToken extends Token {
     readonly underlying: Address;
@@ -33,10 +33,10 @@ export declare class ExchangeRateWrappedToken extends WrappedToken {
     constructor(token: InputToken, underlying: Address, wrappedTokenExchangeRate: bigint);
 }
 export declare class VaultToken extends WrappedToken {
-    readonly underlying: Address;
     protected _wrap(amount: bigint, rounding: RoundingDirection): bigint;
     protected _unwrap(amount: bigint, rounding: RoundingDirection): bigint;
     totalAssets: bigint;
     totalSupply: bigint;
-    constructor(token: InputToken, underlying: Address, { totalAssets, totalSupply }: Pick<Vault, "totalAssets" | "totalSupply">);
+    config: VaultConfig;
+    constructor(token: InputToken, { totalAssets, totalSupply, config, }: Pick<Vault, "totalAssets" | "totalSupply" | "config">);
 }

package/lib/token/WrappedToken.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultToken = exports.ExchangeRateWrappedToken = exports.ConstantWrappedToken = exports.WrappedToken = void 0;
-const ethers_1 = require("ethers");
-const ethers_2 = require("../ethers");
 const maths_1 = require("../maths");
+const vault_1 = require("../vault");
 const Token_1 = require("./Token");
 class WrappedToken extends Token_1.Token {
+    underlying;
+    _noSlippage = false;
     constructor(token, underlying) {
         super(token);
         this.underlying = underlying;
-        this._noSlippage = false;
     }
     /** The expected amount when wrapping `unwrappedAmount` */
     toWrappedExactAmountIn(unwrappedAmount, slippage = 0n, rounding = "Down") {
@@ -42,21 +42,25 @@ class WrappedToken extends Token_1.Token {
 }
 exports.WrappedToken = WrappedToken;
 class ConstantWrappedToken extends WrappedToken {
+    underlying;
+    _underlyingDecimals;
+    _noSlippage = true;
     constructor(token, underlying, _underlyingDecimals = 18) {
         super(token, underlying);
         this.underlying = underlying;
         this._underlyingDecimals = _underlyingDecimals;
-        this._noSlippage = true;
     }
     _wrap(amount) {
-        return (0, ethers_2.safeParseUnits)((0, ethers_1.formatUnits)(amount, this._underlyingDecimals), this.decimals);
+        return maths_1.MathLib.mulDivDown(amount, 10n ** BigInt(this.decimals), 10n ** BigInt(this._underlyingDecimals));
     }
     _unwrap(amount) {
-        return (0, ethers_2.safeParseUnits)((0, ethers_1.formatUnits)(amount, this.decimals), this._underlyingDecimals);
+        return maths_1.MathLib.mulDivDown(amount, 10n ** BigInt(this._underlyingDecimals), 10n ** BigInt(this.decimals));
     }
 }
 exports.ConstantWrappedToken = ConstantWrappedToken;
 class ExchangeRateWrappedToken extends WrappedToken {
+    underlying;
+    wrappedTokenExchangeRate;
     _wrap(amount, rounding) {
         return maths_1.MathLib.wDiv(amount, this.wrappedTokenExchangeRate, rounding);
     }
@@ -72,16 +76,19 @@ class ExchangeRateWrappedToken extends WrappedToken {
 exports.ExchangeRateWrappedToken = ExchangeRateWrappedToken;
 class VaultToken extends WrappedToken {
     _wrap(amount, rounding) {
-        return maths_1.SharesMath.toShares(amount, this.totalAssets, this.totalSupply, rounding);
+        return vault_1.VaultUtils.toShares(amount, this, this.config, rounding);
     }
     _unwrap(amount, rounding) {
-        return maths_1.SharesMath.toAssets(amount, this.totalAssets, this.totalSupply, rounding);
+        return vault_1.VaultUtils.toAssets(amount, this, this.config, rounding);
     }
-    constructor(token, underlying, { totalAssets, totalSupply }) {
-        super(token, underlying);
-        this.underlying = underlying;
+    totalAssets;
+    totalSupply;
+    config;
+    constructor(token, { totalAssets, totalSupply, config, }) {
+        super(token, config.asset);
         this.totalAssets = totalAssets;
         this.totalSupply = totalSupply;
+        this.config = config;
     }
 }
 exports.VaultToken = VaultToken;

package/lib/token/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./TokenNamespace";
+export * from "./Token";
 export * from "./WrappedToken";

package/lib/token/index.js

@@ -14,5 +14,5 @@ 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("./TokenNamespace"), exports);
+__exportStar(require("./Token"), exports);
 __exportStar(require("./WrappedToken"), exports);

package/lib/types.d.ts

@@ -11,6 +11,7 @@ export type Address = string;
 export type MarketId = `0x${Hex64}` & {
     __TYPE__: "marketId";
 };
+export type BigIntish = bigint | string;
 /**
  * The possible transaction type on the Blue contract
  */

package/lib/types.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMarketId = exports.isFetched = exports.TransactionType = void 0;
-const ethers_1 = require("ethers");
+exports.isMarketId = exports.TransactionType = void 0;
+exports.isFetched = isFetched;
 /**
  * The possible transaction type on the Blue contract
  */
@@ -18,6 +18,5 @@ var TransactionType;
 function isFetched(v) {
     return v !== undefined && v !== null;
 }
-exports.isFetched = isFetched;
-const isMarketId = (value) => (0, ethers_1.isHexString)(value, 32);
+const isMarketId = (value) => typeof value === "string" && /^0x[0-9A-Fa-f]{64}$/.test(value);
 exports.isMarketId = isMarketId;

package/lib/user/User.js

@@ -2,6 +2,18 @@
 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;

package/lib/vault/Vault.d.ts

@@ -1,10 +1,9 @@
-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";
+import { InputVaultMarketAllocation, VaultMarketAllocation } from "./VaultMarketAllocation";
 export interface Pending<T> {
     value: T;
     validAt: bigint;
@@ -28,18 +27,18 @@ export interface InputVault {
     curator: Address;
     owner: Address;
     guardian: Address;
-    fee: BigNumberish;
+    fee: bigint;
     feeRecipient: Address;
     skimRecipient: Address;
-    pendingTimelock: Pending<BigNumberish>;
+    pendingTimelock: Pending<bigint>;
     pendingGuardian: Pending<Address>;
     pendingOwner: Address;
-    timelock: BigNumberish;
+    timelock: bigint;
     supplyQueue: MarketId[];
     withdrawQueue: MarketId[];
-    totalSupply: BigNumberish;
-    totalAssets: BigNumberish;
-    lastTotalAssets: BigNumberish;
+    totalSupply: bigint;
+    totalAssets: bigint;
+    lastTotalAssets: bigint;
     publicAllocatorConfig?: VaultPublicAllocatorConfig;
 }
 export declare class Vault implements InputVault {
@@ -118,8 +117,8 @@ export declare class Vault implements InputVault {
      * 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;
+    toAssets(shares: bigint, rounding?: RoundingDirection): bigint;
+    toShares(assets: bigint, rounding?: RoundingDirection): bigint;
 }
 export interface CollateralAllocation {
     address: Address;
@@ -134,7 +133,7 @@ export declare class AccrualVault extends Vault implements InputAccrualVault {
     /**
      * The allocation of the vault on each market enabled.
      */
-    readonly allocations: Map<MarketId, VaultAllocation>;
+    readonly allocations: Map<MarketId, VaultMarketAllocation>;
     /**
      * The ERC4626 vault's share token.
      */
@@ -148,7 +147,7 @@ export declare class AccrualVault extends Vault implements 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">[]);
+    allocations: Omit<InputVaultMarketAllocation, "proportion">[]);
     /**
      * The vault's liquidity directly available from allocated markets.
      */
@@ -161,6 +160,7 @@ export declare class AccrualVault extends Vault implements InputAccrualVault {
      * 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;
     accrueInterest(timestamp: bigint): AccrualVault;

package/lib/vault/Vault.js

@@ -1,33 +1,100 @@
 "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 VaultMarketAllocation_1 = require("./VaultMarketAllocation");
 const VaultUtils_1 = require("./VaultUtils");
 class Vault {
+    /**
+     * 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, }) {
         this.config = config;
         this.curator = curator;
         this.owner = owner;
         this.guardian = guardian;
-        this.fee = (0, ethers_1.toBigInt)(fee);
+        this.fee = fee;
         this.feeRecipient = feeRecipient;
         this.skimRecipient = skimRecipient;
         this.pendingTimelock = {
-            value: (0, ethers_1.toBigInt)(pendingTimelock.value),
+            value: pendingTimelock.value,
             validAt: pendingTimelock.validAt,
         };
         this.pendingGuardian = pendingGuardian;
         this.pendingOwner = pendingOwner;
-        this.timelock = (0, ethers_1.toBigInt)(timelock);
+        this.timelock = 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.totalSupply = totalSupply;
+        this.totalAssets = totalAssets;
+        this.lastTotalAssets = lastTotalAssets;
         this.publicAllocatorConfig = publicAllocatorConfig;
     }
     get address() {
@@ -40,7 +107,7 @@ class Vault {
      * 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);
+        return maths_1.MathLib.zeroFloorSub(this.totalAssets, this.lastTotalAssets);
     }
     toAssets(shares, rounding) {
         return VaultUtils_1.VaultUtils.toAssets(shares, this, this.config, rounding);
@@ -51,6 +118,18 @@ class Vault {
 }
 exports.Vault = Vault;
 class AccrualVault extends Vault {
+    /**
+     * The allocation of the vault on each market enabled.
+     */
+    allocations;
+    /**
+     * The ERC4626 vault's share token.
+     */
+    token;
+    /**
+     * 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,
@@ -64,17 +143,14 @@ class AccrualVault extends Vault {
         });
         this.allocations = new Map(allocations.map(({ config, position }) => [
             position.market.id,
-            new VaultAllocation_1.VaultAllocation({
+            new VaultMarketAllocation_1.VaultMarketAllocation({
                 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()) {
+        for (const { marketId, position } of this.allocations.values()) {
             const address = position.market.config.collateralToken;
             let exposure = this.collateralAllocations.get(address);
             if (!exposure)
@@ -87,8 +163,8 @@ class AccrualVault extends Vault {
                 }));
             exposure.lltvs.add(position.market.config.lltv);
             exposure.oracles.add(position.market.config.oracle);
-            exposure.markets.add(position.market.id);
-            exposure.proportion += proportion;
+            exposure.markets.add(marketId);
+            exposure.proportion += this.getAllocationProportion(marketId);
         }
     }
     /**
@@ -111,11 +187,19 @@ class AccrualVault extends Vault {
     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.MathUtils.zeroFloorSub(cap, supplyAssets)
-                : 0n), ethers_1.MaxUint256), 0n);
+                ? maths_1.MathLib.zeroFloorSub(cap, supplyAssets)
+                : 0n), maths_1.MathLib.MAX_UINT_256), 0n);
         if (assets > suppliable)
             return {
                 value: suppliable,

package/lib/vault/VaultConfig.js

@@ -3,14 +3,21 @@ 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) {
-        var _a;
         this.chainId = chainId;
         this.address = address;
         this.decimals = decimals;
@@ -19,8 +26,7 @@ class VaultConfig {
         this.name = name;
         this.asset = asset;
         if (chainId != null)
-            ((_a = VaultConfig._CACHE)[chainId] ?? (_a[chainId] = {}))[address] = this;
+            (VaultConfig._CACHE[chainId] ??= {})[address] = this;
     }
 }
 exports.VaultConfig = VaultConfig;
-VaultConfig._CACHE = {};

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;

package/lib/vault/VaultMarketConfig.d.ts

@@ -0,0 +1,43 @@
+import { Address, MarketId } from "../types";
+import { Pending } from "./Vault";
+import { VaultMarketPublicAllocatorConfig } from "./VaultMarketPublicAllocatorConfig";
+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.
+     */
+    vault: Address;
+    /**
+     * The market's id.
+     */
+    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.
+     */
+    publicAllocatorConfig?: VaultMarketPublicAllocatorConfig;
+    constructor({ vault, marketId, cap, pendingCap, removableAt, enabled, publicAllocatorConfig, }: InputVaultMarketConfig);
+}

package/lib/vault/VaultMarketConfig.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultMarketConfig = void 0;
+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;
+    }
+}
+exports.VaultMarketConfig = VaultMarketConfig;