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

package/lib/position/Position.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccrualPosition = exports.Position = void 0;
+const errors_1 = require("../errors");
+const market_1 = require("../market");
+class Position {
+    /**
+     * The user holding this position.
+     */
+    user;
+    /**
+     * The id of the market on which this position is held.
+     */
+    marketId;
+    /**
+     * The amount of supply shares held with this position.
+     */
+    supplyShares;
+    /**
+     * The amount of borrow shares held with this position.
+     */
+    borrowShares;
+    /**
+     * The amount of collateral assets held with this position.
+     */
+    collateral;
+    constructor({ user, marketId, supplyShares, borrowShares, collateral, }) {
+        this.user = user;
+        this.marketId = marketId;
+        this.supplyShares = supplyShares;
+        this.borrowShares = borrowShares;
+        this.collateral = collateral;
+    }
+}
+exports.Position = Position;
+class AccrualPosition extends Position {
+    /**
+     * The market on which this position is held.
+     */
+    market;
+    constructor(position, market) {
+        super({ ...position, marketId: market.id });
+        this.market = market;
+    }
+    get supplyAssets() {
+        return this.market.toSupplyAssets(this.supplyShares);
+    }
+    get borrowAssets() {
+        return this.market.toBorrowAssets(this.borrowShares);
+    }
+    /**
+     * The value of this position's collateral quoted in loan assets.
+     */
+    get collateralValue() {
+        return this.market.getCollateralValue(this.collateral);
+    }
+    /**
+     * The maximum amount of loan assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowAssets() {
+        return this.market.getMaxBorrowAssets(this.collateral);
+    }
+    /**
+     * The maximum additional amount of assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowableAssets() {
+        return this.market.getMaxBorrowableAssets(this);
+    }
+    /**
+     * The maximum amount of collateral that can be seized in exchange for the outstanding debt.
+     */
+    get seizableCollateral() {
+        return this.market.getSeizableCollateral(this);
+    }
+    /**
+     * The maximum amount of collateral that can be withdrawn.
+     */
+    get withdrawableCollateral() {
+        return this.market.getWithdrawableCollateral(this);
+    }
+    /**
+     * Whether this position is healthy.
+     */
+    get isHealthy() {
+        return this.market.isHealthy(this);
+    }
+    /**
+     * The price of the collateral quoted in loan assets that would allow this position to be liquidated.
+     */
+    get liquidationPrice() {
+        return this.market.getLiquidationPrice(this);
+    }
+    /**
+     * The variation of the price of the collateral quoted in loan assets that would allow this position to be liquidated,
+     * relative to the current collateral price (scaled by WAD).
+     */
+    get priceVariationToLiquidation() {
+        return this.market.getPriceVariationToLiquidation(this);
+    }
+    /**
+     * This position's Loan-To-Value (debt over collateral power, scaled by WAD).
+     * If the collateral price is 0, LTV is `MaxUint256`.
+     */
+    get ltv() {
+        return this.market.getLtv(this);
+    }
+    /**
+     * This position's health factor (collateral power over debt, scaled by WAD).
+     * If the debt is 0, health factor is `MaxUint256`.
+     */
+    get healthFactor() {
+        return this.market.getHealthFactor(this);
+    }
+    /**
+     * The percentage of this position's borrow power currently used (scaled by WAD).
+     * If the collateral price is 0, usage is `MaxUint256`.
+     */
+    get borrowCapacityUsage() {
+        return this.market.getBorrowCapacityUsage(this);
+    }
+    get borrowCapacityLimit() {
+        return this.market.getBorrowCapacityLimit(this);
+    }
+    get withdrawCapacityLimit() {
+        return this.market.getWithdrawCapacityLimit(this);
+    }
+    get withdrawCollateralCapacityLimit() {
+        return this.market.getWithdrawCollateralCapacityLimit(this);
+    }
+    /**
+     * Returns a new position derived from this position, 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 the market's `lastUpdate`.
+     */
+    accrueInterest(timestamp) {
+        return new AccrualPosition(this, this.market.accrueInterest(timestamp));
+    }
+    supply(assets, shares, timestamp) {
+        let { market } = this;
+        ({ market, assets, shares } = market.supply(assets, shares, timestamp));
+        this.supplyShares += shares;
+        return {
+            position: new AccrualPosition(this, market),
+            assets,
+            shares,
+        };
+    }
+    withdraw(assets, shares, timestamp) {
+        let { market } = this;
+        ({ market, assets, shares } = market.withdraw(assets, shares, timestamp));
+        this.supplyShares -= shares;
+        if (this.supplyShares < 0n)
+            throw new errors_1.BlueErrors.InsufficientPosition(this.user, this.marketId);
+        return {
+            position: new AccrualPosition(this, market),
+            assets,
+            shares,
+        };
+    }
+    supplyCollateral(assets) {
+        this.collateral += assets;
+        return new AccrualPosition(this, new market_1.Market(this.market));
+    }
+    withdrawCollateral(assets, timestamp) {
+        const market = this.market.accrueInterest(timestamp);
+        this.collateral -= assets;
+        if (this.collateral < 0n)
+            throw new errors_1.BlueErrors.InsufficientPosition(this.user, this.marketId);
+        if (!market.isHealthy(this))
+            throw new errors_1.BlueErrors.InsufficientCollateral(this.user, this.marketId);
+        return new AccrualPosition(this, market);
+    }
+    borrow(assets, shares, timestamp) {
+        let { market } = this;
+        ({ market, assets, shares } = market.borrow(assets, shares, timestamp));
+        this.borrowShares += shares;
+        if (!market.isHealthy(this))
+            throw new errors_1.BlueErrors.InsufficientCollateral(this.user, this.marketId);
+        return {
+            position: new AccrualPosition(this, market),
+            assets,
+            shares,
+        };
+    }
+    repay(assets, shares, timestamp) {
+        let { market } = this;
+        ({ market, assets, shares } = market.repay(assets, shares, timestamp));
+        this.borrowShares -= shares;
+        if (this.borrowShares < 0n)
+            throw new errors_1.BlueErrors.InsufficientPosition(this.user, this.marketId);
+        return {
+            position: new AccrualPosition(this, market),
+            assets,
+            shares,
+        };
+    }
+    getRepayCapacityLimit(loanTokenBalance) {
+        return this.market.getRepayCapacityLimit(this.borrowShares, loanTokenBalance);
+    }
+    getMaxCapacities(loanTokenBalance, collateralTokenBalance, options) {
+        return this.market.getMaxCapacities(this, loanTokenBalance, collateralTokenBalance, options);
+    }
+}
+exports.AccrualPosition = AccrualPosition;

package/lib/position/index.d.ts

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

package/lib/position/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("./Position"), exports);

package/lib/tests/mocks/markets.d.ts

@@ -0,0 +1,19 @@
+import { MarketConfig } from "../../market";
+export declare const MAINNET_MARKETS: {
+    eth_wstEth: MarketConfig;
+    eth_wstEth_2: MarketConfig;
+    eth_rEth: MarketConfig;
+    usdt_wbtc: MarketConfig;
+    usdt_wstEth: MarketConfig;
+    usdc_wbtc: MarketConfig;
+    usdc_wstEth: MarketConfig;
+    usdc_sDai: MarketConfig;
+    idle_usdc: MarketConfig;
+    crvUsd_stkcvxcrvUSDTWBTCWETH: MarketConfig;
+    crvUsd_stkcvxcrvUSDCWBTCWETH: MarketConfig;
+    crvUsd_stkcvxcrvCRVUSDTBTCWSTETH: MarketConfig;
+    crvUsd_stkcvxTryLSD: MarketConfig;
+    crvUsd_stkcvxcrvUSDETHCRV: MarketConfig;
+    "crvUsd_stkcvx2BTC-f": MarketConfig;
+    usda_re7Eth: MarketConfig;
+};

package/lib/tests/mocks/markets.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAINNET_MARKETS = void 0;
+const market_1 = require("../../market");
+exports.MAINNET_MARKETS = {
+    eth_wstEth: new market_1.MarketConfig({
+        loanToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+        oracle: "0x2a01EB9496094dA03c4E364Def50f5aD1280AD72",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 945000000000000000n,
+    }),
+    eth_wstEth_2: new market_1.MarketConfig({
+        loanToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+        oracle: "0xbD60A6770b27E084E8617335ddE769241B0e71D8",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 945000000000000000n,
+    }),
+    eth_rEth: new market_1.MarketConfig({
+        loanToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        collateralToken: "0xae78736Cd615f374D3085123A210448E74Fc6393",
+        oracle: "0x1b4A3F92e5Fffd1d35A98751c9FE4472483579bB",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 945000000000000000n,
+    }),
+    usdt_wbtc: new market_1.MarketConfig({
+        loanToken: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        collateralToken: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+        oracle: "0x008bF4B1cDA0cc9f0e882E0697f036667652E1ef",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    usdt_wstEth: new market_1.MarketConfig({
+        loanToken: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+        oracle: "0x95DB30fAb9A3754e42423000DF27732CB2396992",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    usdc_wbtc: new market_1.MarketConfig({
+        // USDC(wBTC, 86%, Chainlink, AdaptiveCurve)
+        loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        collateralToken: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+        oracle: "0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    usdc_wstEth: new market_1.MarketConfig({
+        // USDC(wstETH, 86%, Chainlink, AdaptiveCurve)
+        loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+        oracle: "0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    usdc_sDai: new market_1.MarketConfig({
+        // USDC(wstETH, 86%, Chainlink, AdaptiveCurve)
+        loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        collateralToken: "0x83F20F44975D03b1b09e64809B757c47f942BEeA",
+        oracle: "0x6CAFE228eC0B0bC2D076577d56D35Fe704318f6d",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 96500000000000000000n,
+    }),
+    idle_usdc: new market_1.MarketConfig({
+        loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        collateralToken: "0x0000000000000000000000000000000000000000",
+        oracle: "0x0000000000000000000000000000000000000000",
+        irm: "0x0000000000000000000000000000000000000000",
+        lltv: 0n,
+    }),
+    crvUsd_stkcvxcrvUSDTWBTCWETH: new market_1.MarketConfig({
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        collateralToken: "0xb0Ce26C88e4e7DCa51968b6047f44646f5064278",
+        oracle: "0x077Af6c2D4A75D4145d141F9e9421864C3940CB3",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    crvUsd_stkcvxcrvUSDCWBTCWETH: new market_1.MarketConfig({
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        collateralToken: "0x0ea1a65A2c255f24Ee8D81eA6AaC54Decd9d269e",
+        oracle: "0xd2F7C3B2fC97cC7b6AfDd76D163394680EFc35b9",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    crvUsd_stkcvxcrvCRVUSDTBTCWSTETH: new market_1.MarketConfig({
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        collateralToken: "0x3ce8Ec9f3d89aD0A2DdbCC3FDB8991BD241Fc82E",
+        oracle: "0xa9f7900476F43C45Ebf56cEa669B9c960C176112",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    crvUsd_stkcvxTryLSD: new market_1.MarketConfig({
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        collateralToken: "0x6BA072F0d22806F2C52e9792AF47f2D59103BEBE",
+        oracle: "0x18B0d7311a97c5377445C80c768ab5201Bb27B5a",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    crvUsd_stkcvxcrvUSDETHCRV: new market_1.MarketConfig({
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        collateralToken: "0xAc904BAfBb5FB04Deb2b6198FdCEedE75a78Ce5a",
+        oracle: "0xad7e157815df05029125B568E39d5402550d60bb",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    "crvUsd_stkcvx2BTC-f": new market_1.MarketConfig({
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        collateralToken: "0x385E12cf4040543Bc8C18e05C1298Be5B04f3f5e",
+        oracle: "0x20c4fA59f032bEC6de1905B7201CB88DFD968abA",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+    usda_re7Eth: new market_1.MarketConfig({
+        loanToken: "0x0000206329b97DB379d5E1Bf586BbDB969C63274",
+        collateralToken: "0x78Fc2c2eD1A4cDb5402365934aE5648aDAd094d0",
+        oracle: "0x76052A2A28fDCB8124f4686C63C68355b142de3B",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: 860000000000000000n,
+    }),
+};

package/lib/token/ConstantWrappedToken.d.ts

@@ -0,0 +1,18 @@
+import { RoundingDirection } from "../maths";
+import { Address } from "../types";
+import { InputToken } from "./Token";
+import { WrappedToken } from "./WrappedToken";
+export declare class ConstantWrappedToken extends WrappedToken {
+    readonly underlying: Address;
+    private readonly _underlyingDecimals;
+    constructor(token: InputToken, underlying: Address, _underlyingDecimals?: number);
+    toWrappedExactAmountIn(unwrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    protected _wrap(amount: bigint): bigint;
+    protected _unwrap(amount: bigint): bigint;
+}

package/lib/token/ConstantWrappedToken.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantWrappedToken = void 0;
+const maths_1 = require("../maths");
+const WrappedToken_1 = require("./WrappedToken");
+class ConstantWrappedToken extends WrappedToken_1.WrappedToken {
+    underlying;
+    _underlyingDecimals;
+    constructor(token, underlying, _underlyingDecimals = 18) {
+        super(token, underlying);
+        this.underlying = underlying;
+        this._underlyingDecimals = _underlyingDecimals;
+    }
+    toWrappedExactAmountIn(unwrappedAmount, _slippage, rounding = "Down") {
+        return super.toWrappedExactAmountIn(unwrappedAmount, 0n, rounding);
+    }
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount, _slippage, rounding = "Up") {
+        return super.toWrappedExactAmountOut(wrappedAmount, 0n, rounding);
+    }
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount, _slippage, rounding = "Down") {
+        return super.toUnwrappedExactAmountIn(wrappedAmount, 0n, rounding);
+    }
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount, _slippage, rounding = "Up") {
+        return super.toUnwrappedExactAmountOut(unwrappedAmount, 0n, rounding);
+    }
+    _wrap(amount) {
+        return maths_1.MathLib.mulDivDown(amount, 10n ** BigInt(this.decimals), 10n ** BigInt(this._underlyingDecimals));
+    }
+    _unwrap(amount) {
+        return maths_1.MathLib.mulDivDown(amount, 10n ** BigInt(this._underlyingDecimals), 10n ** BigInt(this.decimals));
+    }
+}
+exports.ConstantWrappedToken = ConstantWrappedToken;

package/lib/token/ExchangeRateWrappedToken.d.ts

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

package/lib/token/ExchangeRateWrappedToken.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExchangeRateWrappedToken = void 0;
+const maths_1 = require("../maths");
+const WrappedToken_1 = require("./WrappedToken");
+class ExchangeRateWrappedToken extends WrappedToken_1.WrappedToken {
+    underlying;
+    wrappedTokenExchangeRate;
+    constructor(token, underlying, wrappedTokenExchangeRate) {
+        super(token, underlying);
+        this.underlying = underlying;
+        this.wrappedTokenExchangeRate = wrappedTokenExchangeRate;
+    }
+    _wrap(amount, rounding) {
+        return maths_1.MathLib.wDiv(amount, this.wrappedTokenExchangeRate, rounding);
+    }
+    _unwrap(amount, rounding) {
+        return maths_1.MathLib.wMul(amount, this.wrappedTokenExchangeRate, rounding);
+    }
+}
+exports.ExchangeRateWrappedToken = ExchangeRateWrappedToken;

package/lib/token/Token.d.ts

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

package/lib/token/Token.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenWithPrice = exports.Token = void 0;
+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;
+        this.symbol = symbol;
+        this.name = name ?? symbol;
+    }
+}
+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;
+    }
+    /**
+     * Quotes an amount in USD (scaled by WAD) in this token.
+     * @param amount The amount of USD to quote.
+     */
+    fromUsd(amount, rounding = "Down") {
+        if (this.price == null)
+            return null;
+        return maths_1.MathLib.mulDiv(amount, 10n ** BigInt(this.decimals), this.price, rounding);
+    }
+    /**
+     * Quotes an amount of tokens in USD (scaled by WAD).
+     * @param amount The amount of tokens to quote.
+     */
+    toUsd(amount, rounding = "Down") {
+        if (this.price == null)
+            return null;
+        return maths_1.MathLib.mulDiv(amount, this.price, 10n ** BigInt(this.decimals), rounding);
+    }
+}
+exports.TokenWithPrice = TokenWithPrice;

package/lib/token/VaultToken.d.ts

@@ -0,0 +1,14 @@
+import { RoundingDirection } from "../maths";
+import { InputVaultConfig } from "../vault/VaultConfig";
+import { WrappedToken } from "./WrappedToken";
+export declare class VaultToken extends WrappedToken {
+    decimalsOffset: bigint;
+    totalAssets: bigint;
+    totalSupply: bigint;
+    constructor(config: InputVaultConfig, { totalAssets, totalSupply }: {
+        totalAssets: bigint;
+        totalSupply: bigint;
+    });
+    protected _wrap(amount: bigint, rounding: RoundingDirection): bigint;
+    protected _unwrap(amount: bigint, rounding: RoundingDirection): bigint;
+}

package/lib/token/VaultToken.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultToken = void 0;
+const VaultUtils_1 = require("../vault/VaultUtils");
+const WrappedToken_1 = require("./WrappedToken");
+class VaultToken extends WrappedToken_1.WrappedToken {
+    decimalsOffset;
+    totalAssets;
+    totalSupply;
+    constructor(config, { totalAssets, totalSupply }) {
+        super(config, config.asset);
+        this.totalAssets = totalAssets;
+        this.totalSupply = totalSupply;
+        this.decimalsOffset = config.decimalsOffset;
+    }
+    _wrap(amount, rounding) {
+        return VaultUtils_1.VaultUtils.toShares(amount, this, this, rounding);
+    }
+    _unwrap(amount, rounding) {
+        return VaultUtils_1.VaultUtils.toAssets(amount, this, this, rounding);
+    }
+}
+exports.VaultToken = VaultToken;

package/lib/token/WrappedToken.d.ts

@@ -0,0 +1,17 @@
+import { RoundingDirection } from "../maths";
+import { Address } from "../types";
+import { InputToken, Token } from "./Token";
+export declare abstract class WrappedToken extends Token {
+    readonly underlying: Address;
+    constructor(token: InputToken, underlying: Address);
+    /** The expected amount when wrapping `unwrappedAmount` */
+    toWrappedExactAmountIn(unwrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    protected abstract _wrap(amount: bigint, rounding: RoundingDirection): bigint;
+    protected abstract _unwrap(amount: bigint, rounding: RoundingDirection): bigint;
+}

package/lib/token/WrappedToken.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrappedToken = void 0;
+const maths_1 = require("../maths");
+const Token_1 = require("./Token");
+class WrappedToken extends Token_1.Token {
+    underlying;
+    constructor(token, underlying) {
+        super(token);
+        this.underlying = underlying;
+    }
+    /** The expected amount when wrapping `unwrappedAmount` */
+    toWrappedExactAmountIn(unwrappedAmount, slippage = 0n, rounding = "Down") {
+        const wrappedAmount = this._wrap(unwrappedAmount, rounding);
+        return maths_1.MathLib.wMul(wrappedAmount, maths_1.MathLib.WAD - slippage, "Down");
+    }
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount, slippage = 0n, rounding = "Up") {
+        const wAmountTarget = maths_1.MathLib.wDiv(wrappedAmount, maths_1.MathLib.WAD - slippage, rounding);
+        return this._unwrap(wAmountTarget, rounding);
+    }
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount, slippage = 0n, rounding = "Down") {
+        const unwrappedAmount = this._unwrap(wrappedAmount, rounding);
+        return maths_1.MathLib.wMul(unwrappedAmount, maths_1.MathLib.WAD - slippage, "Up");
+    }
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount, slippage = 0n, rounding = "Up") {
+        const unwrappedAmountToTarget = maths_1.MathLib.wDiv(unwrappedAmount, maths_1.MathLib.WAD - slippage, rounding);
+        return this._wrap(unwrappedAmountToTarget, rounding);
+    }
+}
+exports.WrappedToken = WrappedToken;

package/lib/token/index.d.ts

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