@morpho-org/midnight-sdk 0.1.0

package/lib/cjs/math/TakeAmountsLib.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TakeAmountsLib = void 0;
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const errors_js_1 = require("../errors.js");
+const TickLib_js_1 = require("./TickLib.js");
+/**
+ * TypeScript port of Midnight `TakeAmountsLib`.
+ *
+ * @example
+ * ```ts
+ * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof TakeAmountsLib.toUnits);
+ * ```
+ */
+var TakeAmountsLib;
+(function (TakeAmountsLib) {
+    /**
+     * Computes buyer and seller prices for an offer and settlement fee.
+     *
+     * @param params.offer.buy - Whether the maker buys loan assets.
+     * @param params.offer.tick - Offer tick used to compute the base price.
+     * @param params.settlementFee - WAD-scaled settlement fee for the market and time to maturity.
+     * @returns Buyer and seller prices.
+     * @throws {NegativeValueError} when `settlementFee` or the offer tick is negative.
+     * @throws {TickOutOfRangeError} when the offer tick exceeds `MAX_TICK`.
+     * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+     * @example
+     * ```ts
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = {
+     *   buy: true,
+     *   tick: 5_820n,
+     * };
+     *
+     * const prices = TakeAmountsLib.prices({ offer, settlementFee: 1_000000000000n });
+     * console.log(prices.buyerPrice);
+     * ```
+     */
+    function prices(params) {
+        const settlementFee = BigInt(params.settlementFee);
+        (0, morpho_ts_1.assertNonNegative)("settlementFee", settlementFee);
+        const offerPrice = TickLib_js_1.TickLib.tickToPrice(params.offer.tick);
+        if (params.offer.buy && offerPrice < settlementFee) {
+            throw new errors_js_1.SettlementFeeExceedsPriceError(settlementFee, offerPrice);
+        }
+        const sellerPrice = params.offer.buy
+            ? offerPrice - settlementFee
+            : offerPrice;
+        const buyerPrice = sellerPrice + settlementFee;
+        return { buyerPrice, sellerPrice };
+    }
+    TakeAmountsLib.prices = prices;
+    /**
+     * Converts a target buyer-asset amount into units for an offer.
+     *
+     * `settlementFee` must be the fee for the offer market's current time to maturity.
+     *
+     * @param params.offer.buy - Whether the maker buys loan assets.
+     * @param params.offer.tick - Offer tick used to compute the buyer price.
+     * @param params.targetBuyerAssets - Target buyer-side asset amount.
+     * @param params.settlementFee - WAD-scaled settlement fee for the market and time to maturity.
+     * @returns Units that round-trip to the target buyer assets where reachable.
+     * @throws {NegativeValueError} when `targetBuyerAssets`, `settlementFee`, or the offer tick is negative.
+     * @throws {DivisionByZeroError} when the computed buyer price is zero.
+     * @throws {PriceGreaterThanOneError} when buyer price is above WAD.
+     * @throws {TickOutOfRangeError} when the offer tick exceeds `MAX_TICK`.
+     * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+     * @example
+     * ```ts
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = {
+     *   buy: true,
+     *   tick: 5_820n,
+     * };
+     *
+     * const units = TakeAmountsLib.buyerAssetsToUnits({
+     *   offer,
+     *   targetBuyerAssets: 100n,
+     *   settlementFee: 0n,
+     * });
+     * console.log(units);
+     * ```
+     */
+    function buyerAssetsToUnits(params) {
+        const settlementFee = BigInt(params.settlementFee);
+        const targetBuyerAssets = BigInt(params.targetBuyerAssets);
+        (0, morpho_ts_1.assertNonNegative)("targetBuyerAssets", targetBuyerAssets);
+        const { buyerPrice } = prices({ offer: params.offer, settlementFee });
+        if (buyerPrice === 0n)
+            throw new morpho_ts_1.DivisionByZeroError("buyerPrice");
+        if (buyerPrice > morpho_ts_1.MathLib.WAD)
+            throw new errors_js_1.PriceGreaterThanOneError(buyerPrice);
+        return morpho_ts_1.MathLib.mulDiv(targetBuyerAssets, morpho_ts_1.MathLib.WAD, buyerPrice, params.offer.buy ? "Up" : "Down");
+    }
+    TakeAmountsLib.buyerAssetsToUnits = buyerAssetsToUnits;
+    /**
+     * Converts a target seller-asset amount into units for an offer.
+     *
+     * `settlementFee` must be the fee for the offer market's current time to maturity.
+     *
+     * @param params.offer.buy - Whether the maker buys loan assets.
+     * @param params.offer.tick - Offer tick used to compute the seller price.
+     * @param params.targetSellerAssets - Target seller-side asset amount.
+     * @param params.settlementFee - WAD-scaled settlement fee for the market and time to maturity.
+     * @returns Units that round-trip to the target seller assets where reachable.
+     * @throws {NegativeValueError} when `targetSellerAssets`, `settlementFee`, or the offer tick is negative.
+     * @throws {DivisionByZeroError} when the computed seller price is zero.
+     * @throws {TickOutOfRangeError} when the offer tick exceeds `MAX_TICK`.
+     * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+     * @example
+     * ```ts
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = {
+     *   buy: false,
+     *   tick: 5_820n,
+     * };
+     *
+     * const units = TakeAmountsLib.sellerAssetsToUnits({
+     *   offer,
+     *   targetSellerAssets: 100n,
+     *   settlementFee: 0n,
+     * });
+     * console.log(units);
+     * ```
+     */
+    function sellerAssetsToUnits(params) {
+        const settlementFee = BigInt(params.settlementFee);
+        const targetSellerAssets = BigInt(params.targetSellerAssets);
+        (0, morpho_ts_1.assertNonNegative)("targetSellerAssets", targetSellerAssets);
+        const { sellerPrice } = prices({ offer: params.offer, settlementFee });
+        if (sellerPrice === 0n)
+            throw new morpho_ts_1.DivisionByZeroError("sellerPrice");
+        return morpho_ts_1.MathLib.mulDiv(targetSellerAssets, morpho_ts_1.MathLib.WAD, sellerPrice, params.offer.buy ? "Up" : "Down");
+    }
+    TakeAmountsLib.sellerAssetsToUnits = sellerAssetsToUnits;
+    /**
+     * Converts assets to units at a WAD price.
+     *
+     * This is an SDK-only generic conversion convenience.
+     *
+     * @param params.assets - Asset amount to convert.
+     * @param params.price - WAD-scaled price used for the conversion.
+     * @param params.rounding - Rounding direction applied by the fixed-point conversion.
+     * @returns Units.
+     * @throws {NegativeValueError} when `assets` or `price` is negative.
+     * @throws {DivisionByZeroError} when price is zero.
+     * @example
+     * ```ts
+     * import { MathLib } from "@morpho-org/morpho-ts";
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const units = TakeAmountsLib.toUnits({ assets: 100n, price: MathLib.WAD, rounding: "Down" });
+     * console.log(units);
+     * ```
+     */
+    function toUnits(params) {
+        const assets = BigInt(params.assets);
+        const price = BigInt(params.price);
+        (0, morpho_ts_1.assertNonNegative)("assets", assets);
+        (0, morpho_ts_1.assertNonNegative)("price", price);
+        if (price === 0n)
+            throw new morpho_ts_1.DivisionByZeroError("price");
+        return morpho_ts_1.MathLib.mulDiv(assets, morpho_ts_1.MathLib.WAD, price, params.rounding);
+    }
+    TakeAmountsLib.toUnits = toUnits;
+    /**
+     * Converts assets to units at a tick price.
+     *
+     * This is an SDK-only tick-priced conversion convenience.
+     *
+     * @param params.assets - Asset amount to convert.
+     * @param params.tick - Offer tick whose price is used for the conversion.
+     * @param params.rounding - Rounding direction applied by the fixed-point conversion.
+     * @returns Units.
+     * @throws {NegativeValueError} when `assets` or `tick` is negative.
+     * @throws {DivisionByZeroError} when the tick price is zero.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @example
+     * ```ts
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const units = TakeAmountsLib.toUnitsAtTick({ assets: 100n, tick: 6744n, rounding: "Down" });
+     * console.log(units);
+     * ```
+     */
+    function toUnitsAtTick(params) {
+        return toUnits({
+            assets: params.assets,
+            price: TickLib_js_1.TickLib.tickToPrice(params.tick),
+            rounding: params.rounding,
+        });
+    }
+    TakeAmountsLib.toUnitsAtTick = toUnitsAtTick;
+})(TakeAmountsLib || (exports.TakeAmountsLib = TakeAmountsLib = {}));

package/lib/cjs/math/TickLib.d.ts

@@ -0,0 +1,200 @@
+import { type BigIntish } from "@morpho-org/morpho-ts";
+/**
+ * TypeScript port of Midnight `TickLib`.
+ *
+ * @example
+ * ```ts
+ * import { TickLib } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(TickLib.tickToPrice(6744n));
+ * ```
+ */
+export declare namespace TickLib {
+    /**
+     * WAD-scaled natural log of one plus Midnight's tick delta.
+     *
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * console.log(TickLib.LN_ONE_PLUS_DELTA);
+     * ```
+     */
+    const LN_ONE_PLUS_DELTA = 4987541511039073n;
+    /**
+     * WAD-scaled natural log of two.
+     *
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * console.log(TickLib.LN_2);
+     * ```
+     */
+    const LN_2 = 693147180559945309n;
+    /**
+     * Exponent offset used by the Midnight exponential approximation.
+     *
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * console.log(TickLib.EXP_OFFSET);
+     * ```
+     */
+    const EXP_OFFSET = 322611214989459870n;
+    /**
+     * Divides with half-down rounding without validating the denominator.
+     *
+     * @param x - Dividend.
+     * @param d - Divisor.
+     * @returns Quotient rounded half down.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const value = TickLib.divHalfDownUnchecked(5n, 2n);
+     * console.log(value);
+     * ```
+     */
+    const divHalfDownUnchecked: (x: bigint, d: bigint) => bigint;
+    /**
+     * Asserts that a tick is non-negative and within Midnight's deployed range.
+     *
+     * @param tick - Tick to validate.
+     * @returns Tick as a bigint.
+     * @throws {NegativeValueError} when `tick` is negative.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const tick = TickLib.assertTickInRange(100n);
+     * console.log(tick);
+     * ```
+     */
+    const assertTickInRange: (tick: BigIntish) => bigint;
+    /**
+     * Computes the WAD-scaled exponential approximation used by Midnight ticks.
+     *
+     * @param x - WAD-scaled exponent.
+     * @returns WAD-scaled exponential value.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const value = TickLib.wExp(0n);
+     * console.log(value);
+     * ```
+     */
+    const wExp: (x: bigint) => bigint;
+    /**
+     * Converts a Midnight tick into a WAD price.
+     *
+     * @param tick - Tick in the deployed range.
+     * @returns WAD price rounded to `PRICE_ROUNDING_STEP`.
+     * @throws {NegativeValueError} when `tick` is negative.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const price = TickLib.tickToPrice(6744n);
+     * console.log(price);
+     * ```
+     */
+    function tickToPrice(tick: BigIntish): bigint;
+    /**
+     * Converts a WAD price into the lowest spacing-aligned tick whose price is at least the input.
+     *
+     * @param price - WAD price.
+     * @param spacing - Tick spacing; defaults to `DEFAULT_TICK_SPACING`.
+     * @returns Lowest aligned tick with price greater than or equal to `price`.
+     * @throws {NegativeValueError} when `price` is negative.
+     * @throws {PriceGreaterThanOneError} when price is above WAD.
+     * @throws {InvalidTickSpacingError} when spacing is invalid.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const tick = TickLib.priceToTick(500000000000000000n);
+     * console.log(tick);
+     * ```
+     */
+    function priceToTick(price: BigIntish, spacing?: BigIntish): bigint;
+    /**
+     * Snaps a WAD price to the price of the lowest spacing-aligned tick at or above it.
+     *
+     * This is an SDK-only convenience around `priceToTick` and `tickToPrice`.
+     *
+     * @param price - WAD price.
+     * @param spacing - Tick spacing.
+     * @returns Snapped WAD price.
+     * @throws {NegativeValueError} when `price` is negative.
+     * @throws {PriceGreaterThanOneError} when price is above WAD.
+     * @throws {InvalidTickSpacingError} when spacing is invalid.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const price = TickLib.snapPriceToTick(500000000000000000n, 4n);
+     * console.log(price);
+     * ```
+     */
+    function snapPriceToTick(price: BigIntish, spacing?: BigIntish): bigint;
+    /**
+     * Converts a WAD fixed rate into a WAD zero-coupon price.
+     *
+     * This is an SDK-only rate conversion convenience.
+     *
+     * @param rate - WAD fixed rate.
+     * @returns WAD price rounded down.
+     * @throws {NegativeValueError} when `rate` is negative.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const price = TickLib.rateToPrice(50000000000000000n);
+     * console.log(price);
+     * ```
+     */
+    function rateToPrice(rate: BigIntish): bigint;
+    /**
+     * Converts a Midnight tick into a WAD fixed rate.
+     *
+     * This is an SDK-only rate conversion convenience.
+     *
+     * @param tick - Midnight tick.
+     * @returns WAD fixed rate rounded up.
+     * @throws {NegativeValueError} when `tick` is negative.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @throws {DivisionByZeroError} when the tick price is zero.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const rate = TickLib.tickToRate(6744n);
+     * console.log(rate);
+     * ```
+     */
+    function tickToRate(tick: BigIntish): bigint;
+    /**
+     * Asserts that a tick is aligned to the provided spacing.
+     *
+     * This is an SDK-only tick-domain assertion.
+     *
+     * @param tick - Tick to validate.
+     * @param spacing - Market tick spacing.
+     * @returns Tick as a bigint.
+     * @throws {NegativeValueError} when `tick` is negative.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @throws {InvalidTickSpacingError} when spacing is invalid or the tick is not aligned.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * TickLib.assertTickAlignedToSpacing(100n, 4n);
+     * ```
+     */
+    function assertTickAlignedToSpacing(tick: BigIntish, spacing?: BigIntish): bigint;
+}

package/lib/cjs/math/TickLib.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TickLib = void 0;
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const constants_js_1 = require("../constants.js");
+const errors_js_1 = require("../errors.js");
+/**
+ * TypeScript port of Midnight `TickLib`.
+ *
+ * @example
+ * ```ts
+ * import { TickLib } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(TickLib.tickToPrice(6744n));
+ * ```
+ */
+var TickLib;
+(function (TickLib) {
+    /**
+     * WAD-scaled natural log of one plus Midnight's tick delta.
+     *
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * console.log(TickLib.LN_ONE_PLUS_DELTA);
+     * ```
+     */
+    TickLib.LN_ONE_PLUS_DELTA = 4987541511039073n;
+    /**
+     * WAD-scaled natural log of two.
+     *
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * console.log(TickLib.LN_2);
+     * ```
+     */
+    TickLib.LN_2 = 693147180559945309n;
+    /**
+     * Exponent offset used by the Midnight exponential approximation.
+     *
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * console.log(TickLib.EXP_OFFSET);
+     * ```
+     */
+    TickLib.EXP_OFFSET = 322611214989459870n;
+    /**
+     * Divides with half-down rounding without validating the denominator.
+     *
+     * @param x - Dividend.
+     * @param d - Divisor.
+     * @returns Quotient rounded half down.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const value = TickLib.divHalfDownUnchecked(5n, 2n);
+     * console.log(value);
+     * ```
+     */
+    TickLib.divHalfDownUnchecked = (x, d) => (x + (d - 1n) / 2n) / d;
+    /**
+     * Asserts that a tick is non-negative and within Midnight's deployed range.
+     *
+     * @param tick - Tick to validate.
+     * @returns Tick as a bigint.
+     * @throws {NegativeValueError} when `tick` is negative.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const tick = TickLib.assertTickInRange(100n);
+     * console.log(tick);
+     * ```
+     */
+    TickLib.assertTickInRange = (tick) => {
+        const tickValue = BigInt(tick);
+        (0, morpho_ts_1.assertNonNegative)("tick", tickValue);
+        if (tickValue > constants_js_1.MAX_TICK)
+            throw new errors_js_1.TickOutOfRangeError(tickValue, constants_js_1.MAX_TICK);
+        return tickValue;
+    };
+    /**
+     * Computes the WAD-scaled exponential approximation used by Midnight ticks.
+     *
+     * @param x - WAD-scaled exponent.
+     * @returns WAD-scaled exponential value.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const value = TickLib.wExp(0n);
+     * console.log(value);
+     * ```
+     */
+    TickLib.wExp = (x) => {
+        if (x < 0n)
+            return 1000000000000000000000000000000000000n / TickLib.wExp(-x);
+        const q = (x + TickLib.EXP_OFFSET) / TickLib.LN_2;
+        const r = x - q * TickLib.LN_2;
+        const secondTerm = (r * r) / (2n * morpho_ts_1.MathLib.WAD);
+        const thirdTerm = (secondTerm * r) / (3n * morpho_ts_1.MathLib.WAD);
+        const expR = morpho_ts_1.MathLib.WAD + r + secondTerm + thirdTerm;
+        return expR << q;
+    };
+    /**
+     * Converts a Midnight tick into a WAD price.
+     *
+     * @param tick - Tick in the deployed range.
+     * @returns WAD price rounded to `PRICE_ROUNDING_STEP`.
+     * @throws {NegativeValueError} when `tick` is negative.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const price = TickLib.tickToPrice(6744n);
+     * console.log(price);
+     * ```
+     */
+    function tickToPrice(tick) {
+        const tickValue = TickLib.assertTickInRange(tick);
+        const exponent = TickLib.LN_ONE_PLUS_DELTA * (constants_js_1.MAX_TICK / 2n - tickValue);
+        const rawPrice = TickLib.divHalfDownUnchecked(1000000000000000000000000000000000000n, morpho_ts_1.MathLib.WAD + TickLib.wExp(exponent));
+        return (TickLib.divHalfDownUnchecked(rawPrice, constants_js_1.PRICE_ROUNDING_STEP) * constants_js_1.PRICE_ROUNDING_STEP);
+    }
+    TickLib.tickToPrice = tickToPrice;
+    /**
+     * Converts a WAD price into the lowest spacing-aligned tick whose price is at least the input.
+     *
+     * @param price - WAD price.
+     * @param spacing - Tick spacing; defaults to `DEFAULT_TICK_SPACING`.
+     * @returns Lowest aligned tick with price greater than or equal to `price`.
+     * @throws {NegativeValueError} when `price` is negative.
+     * @throws {PriceGreaterThanOneError} when price is above WAD.
+     * @throws {InvalidTickSpacingError} when spacing is invalid.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const tick = TickLib.priceToTick(500000000000000000n);
+     * console.log(tick);
+     * ```
+     */
+    function priceToTick(price, spacing = constants_js_1.DEFAULT_TICK_SPACING) {
+        const priceValue = BigInt(price);
+        const spacingValue = BigInt(spacing);
+        (0, morpho_ts_1.assertNonNegative)("price", priceValue);
+        if (priceValue > morpho_ts_1.MathLib.WAD)
+            throw new errors_js_1.PriceGreaterThanOneError(priceValue);
+        if (spacingValue <= 0n || constants_js_1.MAX_TICK % spacingValue !== 0n) {
+            throw new errors_js_1.InvalidTickSpacingError(spacingValue);
+        }
+        let low = 0n;
+        let high = constants_js_1.MAX_TICK;
+        while (low !== high) {
+            const mid = (low + high) / 2n;
+            if (tickToPrice(mid) < priceValue)
+                low = mid + 1n;
+            else
+                high = mid;
+        }
+        return ((low + spacingValue - 1n) / spacingValue) * spacingValue;
+    }
+    TickLib.priceToTick = priceToTick;
+    /**
+     * Snaps a WAD price to the price of the lowest spacing-aligned tick at or above it.
+     *
+     * This is an SDK-only convenience around `priceToTick` and `tickToPrice`.
+     *
+     * @param price - WAD price.
+     * @param spacing - Tick spacing.
+     * @returns Snapped WAD price.
+     * @throws {NegativeValueError} when `price` is negative.
+     * @throws {PriceGreaterThanOneError} when price is above WAD.
+     * @throws {InvalidTickSpacingError} when spacing is invalid.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const price = TickLib.snapPriceToTick(500000000000000000n, 4n);
+     * console.log(price);
+     * ```
+     */
+    function snapPriceToTick(price, spacing = constants_js_1.DEFAULT_TICK_SPACING) {
+        return tickToPrice(priceToTick(price, spacing));
+    }
+    TickLib.snapPriceToTick = snapPriceToTick;
+    /**
+     * Converts a WAD fixed rate into a WAD zero-coupon price.
+     *
+     * This is an SDK-only rate conversion convenience.
+     *
+     * @param rate - WAD fixed rate.
+     * @returns WAD price rounded down.
+     * @throws {NegativeValueError} when `rate` is negative.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const price = TickLib.rateToPrice(50000000000000000n);
+     * console.log(price);
+     * ```
+     */
+    function rateToPrice(rate) {
+        const rateValue = BigInt(rate);
+        (0, morpho_ts_1.assertNonNegative)("rate", rateValue);
+        return morpho_ts_1.MathLib.mulDiv(morpho_ts_1.MathLib.WAD, morpho_ts_1.MathLib.WAD, morpho_ts_1.MathLib.WAD + rateValue, "Down");
+    }
+    TickLib.rateToPrice = rateToPrice;
+    /**
+     * Converts a Midnight tick into a WAD fixed rate.
+     *
+     * This is an SDK-only rate conversion convenience.
+     *
+     * @param tick - Midnight tick.
+     * @returns WAD fixed rate rounded up.
+     * @throws {NegativeValueError} when `tick` is negative.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @throws {DivisionByZeroError} when the tick price is zero.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * const rate = TickLib.tickToRate(6744n);
+     * console.log(rate);
+     * ```
+     */
+    function tickToRate(tick) {
+        const price = tickToPrice(tick);
+        if (price === 0n)
+            throw new morpho_ts_1.DivisionByZeroError("price");
+        return morpho_ts_1.MathLib.mulDiv(morpho_ts_1.MathLib.WAD, morpho_ts_1.MathLib.WAD, price, "Up") - morpho_ts_1.MathLib.WAD;
+    }
+    TickLib.tickToRate = tickToRate;
+    /**
+     * Asserts that a tick is aligned to the provided spacing.
+     *
+     * This is an SDK-only tick-domain assertion.
+     *
+     * @param tick - Tick to validate.
+     * @param spacing - Market tick spacing.
+     * @returns Tick as a bigint.
+     * @throws {NegativeValueError} when `tick` is negative.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @throws {InvalidTickSpacingError} when spacing is invalid or the tick is not aligned.
+     * @example
+     * ```ts
+     * import { TickLib } from "@morpho-org/midnight-sdk";
+     *
+     * TickLib.assertTickAlignedToSpacing(100n, 4n);
+     * ```
+     */
+    function assertTickAlignedToSpacing(tick, spacing = constants_js_1.DEFAULT_TICK_SPACING) {
+        const tickValue = TickLib.assertTickInRange(tick);
+        const spacingValue = BigInt(spacing);
+        if (spacingValue <= 0n || constants_js_1.MAX_TICK % spacingValue !== 0n) {
+            throw new errors_js_1.InvalidTickSpacingError(spacingValue);
+        }
+        if (tickValue % spacingValue !== 0n) {
+            throw new errors_js_1.InvalidTickSpacingError(tickValue, spacingValue);
+        }
+        return tickValue;
+    }
+    TickLib.assertTickAlignedToSpacing = assertTickAlignedToSpacing;
+})(TickLib || (exports.TickLib = TickLib = {}));

package/lib/cjs/math/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ConsumableUnitsLib.js";
+export * from "./TakeAmountsLib.js";
+export * from "./TickLib.js";

package/lib/cjs/math/index.js

@@ -0,0 +1,19 @@
+"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("./ConsumableUnitsLib.js"), exports);
+__exportStar(require("./TakeAmountsLib.js"), exports);
+__exportStar(require("./TickLib.js"), exports);