@morpho-org/midnight-sdk 0.1.0

package/lib/esm/math/TakeAmountsLib.js

@@ -0,0 +1,196 @@
+import { assertNonNegative, DivisionByZeroError, MathLib, } from "@morpho-org/morpho-ts";
+import { PriceGreaterThanOneError, SettlementFeeExceedsPriceError, } from "../errors.js";
+import { TickLib } from "./TickLib.js";
+/**
+ * TypeScript port of Midnight `TakeAmountsLib`.
+ *
+ * @example
+ * ```ts
+ * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof TakeAmountsLib.toUnits);
+ * ```
+ */
+export 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);
+        assertNonNegative("settlementFee", settlementFee);
+        const offerPrice = TickLib.tickToPrice(params.offer.tick);
+        if (params.offer.buy && offerPrice < settlementFee) {
+            throw new 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);
+        assertNonNegative("targetBuyerAssets", targetBuyerAssets);
+        const { buyerPrice } = prices({ offer: params.offer, settlementFee });
+        if (buyerPrice === 0n)
+            throw new DivisionByZeroError("buyerPrice");
+        if (buyerPrice > MathLib.WAD)
+            throw new PriceGreaterThanOneError(buyerPrice);
+        return MathLib.mulDiv(targetBuyerAssets, 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);
+        assertNonNegative("targetSellerAssets", targetSellerAssets);
+        const { sellerPrice } = prices({ offer: params.offer, settlementFee });
+        if (sellerPrice === 0n)
+            throw new DivisionByZeroError("sellerPrice");
+        return MathLib.mulDiv(targetSellerAssets, 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);
+        assertNonNegative("assets", assets);
+        assertNonNegative("price", price);
+        if (price === 0n)
+            throw new DivisionByZeroError("price");
+        return MathLib.mulDiv(assets, 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.tickToPrice(params.tick),
+            rounding: params.rounding,
+        });
+    }
+    TakeAmountsLib.toUnitsAtTick = toUnitsAtTick;
+})(TakeAmountsLib || (TakeAmountsLib = {}));

package/lib/esm/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/esm/math/TickLib.js

@@ -0,0 +1,269 @@
+import { assertNonNegative, DivisionByZeroError, MathLib, } from "@morpho-org/morpho-ts";
+import { DEFAULT_TICK_SPACING, MAX_TICK, PRICE_ROUNDING_STEP, } from "../constants.js";
+import { InvalidTickSpacingError, PriceGreaterThanOneError, TickOutOfRangeError, } from "../errors.js";
+/**
+ * TypeScript port of Midnight `TickLib`.
+ *
+ * @example
+ * ```ts
+ * import { TickLib } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(TickLib.tickToPrice(6744n));
+ * ```
+ */
+export 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);
+        assertNonNegative("tick", tickValue);
+        if (tickValue > MAX_TICK)
+            throw new TickOutOfRangeError(tickValue, 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 * MathLib.WAD);
+        const thirdTerm = (secondTerm * r) / (3n * MathLib.WAD);
+        const expR = 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 * (MAX_TICK / 2n - tickValue);
+        const rawPrice = TickLib.divHalfDownUnchecked(1000000000000000000000000000000000000n, MathLib.WAD + TickLib.wExp(exponent));
+        return (TickLib.divHalfDownUnchecked(rawPrice, PRICE_ROUNDING_STEP) * 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 = DEFAULT_TICK_SPACING) {
+        const priceValue = BigInt(price);
+        const spacingValue = BigInt(spacing);
+        assertNonNegative("price", priceValue);
+        if (priceValue > MathLib.WAD)
+            throw new PriceGreaterThanOneError(priceValue);
+        if (spacingValue <= 0n || MAX_TICK % spacingValue !== 0n) {
+            throw new InvalidTickSpacingError(spacingValue);
+        }
+        let low = 0n;
+        let high = 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 = 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);
+        assertNonNegative("rate", rateValue);
+        return MathLib.mulDiv(MathLib.WAD, MathLib.WAD, 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 DivisionByZeroError("price");
+        return MathLib.mulDiv(MathLib.WAD, MathLib.WAD, price, "Up") - 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 = DEFAULT_TICK_SPACING) {
+        const tickValue = TickLib.assertTickInRange(tick);
+        const spacingValue = BigInt(spacing);
+        if (spacingValue <= 0n || MAX_TICK % spacingValue !== 0n) {
+            throw new InvalidTickSpacingError(spacingValue);
+        }
+        if (tickValue % spacingValue !== 0n) {
+            throw new InvalidTickSpacingError(tickValue, spacingValue);
+        }
+        return tickValue;
+    }
+    TickLib.assertTickAlignedToSpacing = assertTickAlignedToSpacing;
+})(TickLib || (TickLib = {}));

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

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

package/lib/esm/math/index.js

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