@mysten/deepbook-v3 2.5.0 → 2.6.0

package/dist/predict/cost.mjs

@@ -0,0 +1,555 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { PredictInputError } from "./errors.mjs";
+import { U64_MAX, fromRaw, usdcToRaw } from "./units.mjs";
+import { POS_INF_TICK } from "./ticks.mjs";
+import { upProbability } from "./pricing.mjs";
+
+//#region src/predict/cost.ts
+var cost_exports = /* @__PURE__ */ __exportAll({
+	BUILDER_FEE_MULTIPLIER: () => BUILDER_FEE_MULTIPLIER,
+	FEE_INCENTIVE_SUBSIDY_RATE: () => FEE_INCENTIVE_SUBSIDY_RATE,
+	FLOAT_SCALING: () => FLOAT_SCALING,
+	MAX_BUILDER_FEE_RATE: () => MAX_BUILDER_FEE_RATE,
+	MAX_QUANTITY_LOTS: () => MAX_QUANTITY_LOTS,
+	MIN_PREMIUM: () => MIN_PREMIUM,
+	POSITION_LOT_SIZE: () => POSITION_LOT_SIZE,
+	POS_INF_TICK: () => POS_INF_TICK,
+	SHIPPED_FEE_POLICY: () => SHIPPED_FEE_POLICY,
+	bernoulliFeeRate: () => bernoulliFeeRate,
+	boundaryProbabilities: () => boundaryProbabilities,
+	builderFee: () => builderFee,
+	closeInventoryImpact: () => closeInventoryImpact,
+	congestionPenaltyRate: () => congestionPenaltyRate,
+	decodeOrderRange: () => decodeOrderRange,
+	expiryFeeMultiplier: () => expiryFeeMultiplier,
+	feeIncentiveSubsidy: () => feeIncentiveSubsidy,
+	inventoryImpactPotential: () => inventoryImpactPotential,
+	mintCost: () => mintCost,
+	mintCostForBudget: () => mintCostForBudget,
+	mintInventoryImpact: () => mintInventoryImpact,
+	orderStrikes: () => orderStrikes,
+	rangeProbability: () => rangeProbability,
+	redeemLiveProceeds: () => redeemLiveProceeds,
+	sqrtDown: () => sqrtDown,
+	tradingFee: () => tradingFee
+});
+/** `math::float_scaling` — 1e9 is 1.0 for every rate and probability here. */
+const FLOAT_SCALING = 1000000000n;
+/** `constants::position_lot_size` — quantity is an integer number of these. */
+const POSITION_LOT_SIZE = 10000n;
+/** `constants::min_premium` — a mint below this premium aborts `EPremiumBelowMinimum`. */
+const MIN_PREMIUM = 1000000n;
+/** `constants::builder_fee_multiplier` — the builder's cut of the trading fee (10%). */
+const BUILDER_FEE_MULTIPLIER = 100000000n;
+/** `constants::max_builder_fee_rate` — cap on the builder fee as a share of quantity (0.5%). */
+const MAX_BUILDER_FEE_RATE = 5000000n;
+/** `constants::fee_incentive_subsidy_rate` — sponsor share of a trader's mint fee (20%). */
+const FEE_INCENTIVE_SUBSIDY_RATE = 200000000n;
+/** `order::max_quantity_lots` — the order ID's 32-bit lot field. */
+const MAX_QUANTITY_LOTS = (1n << 32n) - 1n;
+const mulDown = (x, y) => x * y / FLOAT_SCALING;
+const divDown = (x, y) => x * FLOAT_SCALING / y;
+const mulDivDown = (x, y, denominator) => x * y / denominator;
+const min = (a, b) => a < b ? a : b;
+const max = (a, b) => a > b ? a : b;
+function assertUint(value, name, maximum = U64_MAX, minimum = 0n) {
+	if (typeof value !== "bigint" || value < minimum || value > maximum) throw new PredictInputError(`${name} must be an integer in [${minimum}, ${maximum}], got ${value}`);
+}
+function sqrtInitialGuess(x) {
+	let bits = 0n;
+	let val = x;
+	if (val >= 1n << 64n) {
+		val >>= 64n;
+		bits += 64n;
+	}
+	if (val >= 1n << 32n) {
+		val >>= 32n;
+		bits += 32n;
+	}
+	if (val >= 1n << 16n) {
+		val >>= 16n;
+		bits += 16n;
+	}
+	if (val >= 1n << 8n) {
+		val >>= 8n;
+		bits += 8n;
+	}
+	if (val >= 1n << 4n) {
+		val >>= 4n;
+		bits += 4n;
+	}
+	if (val >= 1n << 2n) {
+		val >>= 2n;
+		bits += 2n;
+	}
+	if (val >= 1n << 1n) bits += 1n;
+	return 1n << (bits + 1n) / 2n;
+}
+function sqrtU128Down(x) {
+	if (x === 0n) return 0n;
+	if (x < 4n) return 1n;
+	let g = sqrtInitialGuess(x);
+	for (let i = 0; i < 7; i++) g = (g + x / g) / 2n;
+	if (g > x / g) g -= 1n;
+	return g;
+}
+/** `math::sqrt_down` — square root of a 1e9-scaled value, 1e9-scaled, rounded down. */
+function sqrtDown(x) {
+	assertUint(x, "sqrt input");
+	return sqrtU128Down(x * FLOAT_SCALING);
+}
+/**
+* The shipped template (`config_constants` defaults): 10% Bernoulli fee, a 2.2% per-leg floor,
+* a one-day ramp window that is inert at a 1.0 multiplier, a 1%–99% entry band, and inventory
+* impact disabled. A market that was created under these values charges exactly this; one
+* created after an admin change does not, which is why the per-market snapshot is the real
+* answer. Verify against the deployment's `MarketCreated` before pricing money on it.
+*/
+const SHIPPED_FEE_POLICY = Object.freeze({
+	baseFee: 100000000n,
+	minFee: 22000000n,
+	expiryFeeWindowMs: 86400000n,
+	expiryFeeMaxMultiplier: FLOAT_SCALING,
+	minEntryProbability: 10000000n,
+	maxEntryProbability: 990000000n,
+	inventoryImpactMaxRate: 0n,
+	inventoryImpactScale: 0n,
+	backingBufferLambda: 310000000n
+});
+function assertFeePolicy(policy) {
+	assertUint(policy.baseFee, "baseFee", FLOAT_SCALING);
+	assertUint(policy.minFee, "minFee", FLOAT_SCALING);
+	assertUint(policy.expiryFeeWindowMs, "expiryFeeWindowMs", U64_MAX, 1n);
+	assertUint(policy.expiryFeeMaxMultiplier, "expiryFeeMaxMultiplier", 10n * FLOAT_SCALING, FLOAT_SCALING);
+	assertUint(policy.minEntryProbability, "minEntryProbability", FLOAT_SCALING);
+	assertUint(policy.maxEntryProbability, "maxEntryProbability", FLOAT_SCALING);
+	if (policy.minEntryProbability >= policy.maxEntryProbability) throw new PredictInputError("minEntryProbability must be below maxEntryProbability");
+	assertUint(policy.inventoryImpactMaxRate, "inventoryImpactMaxRate", FLOAT_SCALING);
+	assertUint(policy.backingBufferLambda, "backingBufferLambda", FLOAT_SCALING);
+	assertUint(policy.inventoryImpactScale, "inventoryImpactScale", U64_MAX, policy.inventoryImpactMaxRate === 0n ? 0n : 1n);
+}
+function assertBoundaries(boundaries) {
+	if (boundaries.lowerUp !== null) assertUint(boundaries.lowerUp, "lowerUp", FLOAT_SCALING);
+	if (boundaries.higherUp !== null) assertUint(boundaries.higherUp, "higherUp", FLOAT_SCALING);
+}
+function assertBook(book) {
+	assertUint(book.totalPayout, "totalPayout");
+	assertUint(book.maxPayout, "maxPayout", book.totalPayout);
+	assertUint(book.rangeMaxPayout, "rangeMaxPayout", book.maxPayout);
+}
+function assertCostInputs(inputs) {
+	assertFeePolicy(inputs.fees);
+	assertUint(inputs.penaltyRate ?? 0n, "penaltyRate", FLOAT_SCALING);
+	assertUint(inputs.lotSize ?? POSITION_LOT_SIZE, "lotSize", U64_MAX / MAX_QUANTITY_LOTS, 1n);
+	if (inputs.fees.inventoryImpactMaxRate > 0n && !inputs.book) throw new PredictInputError("book is required when inventory impact is enabled");
+	if (inputs.book) assertBook(inputs.book);
+}
+/** `strike_exposure_config::raw_bernoulli_fee_rate` — `base_fee · sqrt(p·(1−p))`, the fee rate
+* before the `min_fee` floor and the expiry ramp. Zero at the certain ends. */
+function bernoulliFeeRate(baseFee, probability) {
+	assertUint(baseFee, "baseFee", FLOAT_SCALING);
+	assertUint(probability, "probability (EInvalidFeeProbability)", FLOAT_SCALING);
+	if (probability === 0n || probability === FLOAT_SCALING) return 0n;
+	return mulDown(baseFee, sqrtDown(mulDown(probability, FLOAT_SCALING - probability)));
+}
+/** `strike_exposure_config::expiry_fee_multiplier` — 1.0 outside the window, rising linearly
+* to `expiry_fee_max_multiplier` at expiry. */
+function expiryFeeMultiplier(policy, timeToExpiryMs) {
+	assertFeePolicy(policy);
+	assertUint(timeToExpiryMs, "timeToExpiryMs");
+	if (timeToExpiryMs >= policy.expiryFeeWindowMs) return FLOAT_SCALING;
+	return FLOAT_SCALING + mulDivDown(policy.expiryFeeMaxMultiplier - FLOAT_SCALING, policy.expiryFeeWindowMs - timeToExpiryMs, policy.expiryFeeWindowMs);
+}
+function legTradingFee(policy, probability, quantity, timeToExpiryMs) {
+	return mulDown(mulDown(max(bernoulliFeeRate(policy.baseFee, probability), policy.minFee), expiryFeeMultiplier(policy, timeToExpiryMs)), quantity);
+}
+/**
+* `strike_exposure_config::trading_fee` — the fee for a whole range, charged PER FINITE
+* BOUNDARY with each leg floored and ramped independently. A binary order has one finite
+* boundary and pays one leg; a two-sided range pays two, so it is not the same fee as the
+* range's own probability would suggest.
+*/
+function tradingFee(policy, boundaries, quantity, timeToExpiryMs) {
+	assertFeePolicy(policy);
+	assertBoundaries(boundaries);
+	assertUint(quantity, "quantity");
+	assertUint(timeToExpiryMs, "timeToExpiryMs");
+	return (boundaries.lowerUp === null ? 0n : legTradingFee(policy, boundaries.lowerUp, quantity, timeToExpiryMs)) + (boundaries.higherUp === null ? 0n : legTradingFee(policy, boundaries.higherUp, quantity, timeToExpiryMs));
+}
+/** `expiry_market::builder_fee_amount` — an account carrying a builder code pays the builder a
+* multiple of its trading fee, capped as a share of quantity. */
+function builderFee(fee, quantity, hasBuilderCode) {
+	assertUint(fee, "fee");
+	assertUint(quantity, "quantity");
+	if (!hasBuilderCode) return 0n;
+	return min(mulDown(fee, BUILDER_FEE_MULTIPLIER), mulDown(quantity, MAX_BUILDER_FEE_RATE));
+}
+/** `expiry_market::fee_incentive_subsidy_amount` — a sponsor pays part of the trader's MINT
+* fee, bounded by the expiry's remaining sponsored balance. Mints only; redeems pay in full. */
+function feeIncentiveSubsidy(fee, feeIncentiveBalance) {
+	assertUint(fee, "fee");
+	assertUint(feeIncentiveBalance, "feeIncentiveBalance");
+	return min(mulDown(fee, FEE_INCENTIVE_SUBSIDY_RATE), feeIncentiveBalance);
+}
+/**
+* `ewma::penalty_fee`'s firing test, as a per-unit RATE: `penalty_rate` when the transaction's
+* gas price is a high outlier against the market's pre-trade EWMA, else zero. It is a rate and
+* not an amount because the surcharge is `rate · quantity`, and a budget search has to reprice
+* it at every candidate quantity. `gasPrice` is the raw reference gas price (not 1e9-scaled),
+* as `tx_context::gas_price` reports it.
+*/
+function congestionPenaltyRate(policy, state, gasPrice) {
+	assertUint(policy.penaltyRate, "penaltyRate", FLOAT_SCALING);
+	assertUint(policy.zScoreThreshold, "zScoreThreshold");
+	assertUint(state.mean, "mean");
+	assertUint(state.variance, "variance");
+	assertUint(gasPrice, "gasPrice", U64_MAX / FLOAT_SCALING);
+	if (!policy.enabled || state.variance === 0n) return 0n;
+	const scaled = gasPrice * FLOAT_SCALING;
+	if (scaled <= state.mean) return 0n;
+	if (divDown(scaled - state.mean, sqrtDown(state.variance)) <= policy.zScoreThreshold) return 0n;
+	return policy.penaltyRate;
+}
+function payoutLiability(policy, maxPayout, totalPayout) {
+	return maxPayout + mulDown(policy.backingBufferLambda, totalPayout - maxPayout);
+}
+/**
+* `strike_exposure::inventory_impact_potential_for_liability` — the book-level potential
+* `phi(L)`: marginal rate rising linearly to `inventory_impact_max_rate` over the scale `B`,
+* flat at the cap above it. Trades are charged the DIFFERENCE of two evaluations, which is
+* what makes inventory cycles telescope to zero.
+*/
+function inventoryImpactPotential(policy, liability) {
+	assertFeePolicy(policy);
+	assertUint(liability, "liability");
+	if (policy.inventoryImpactMaxRate === 0n || liability === 0n) return 0n;
+	const scale = policy.inventoryImpactScale;
+	const capped = min(liability, scale);
+	const utilization = mulDivDown(capped, FLOAT_SCALING, scale);
+	const potentialAtCapped = mulDown(mulDown(policy.inventoryImpactMaxRate, utilization), capped) / 2n;
+	if (liability <= scale) return potentialAtCapped;
+	return potentialAtCapped + mulDown(policy.inventoryImpactMaxRate, liability - scale);
+}
+/** `strike_exposure::mint_range_inventory_impact` — the charge a mint of `quantity` over a
+* range pays: the exact rise in the book potential. Zero at the shipped rate of `0n`. */
+function mintInventoryImpact(policy, book, quantity) {
+	assertFeePolicy(policy);
+	assertBook(book);
+	assertUint(quantity, "quantity", U64_MAX - book.totalPayout);
+	if (policy.inventoryImpactMaxRate === 0n || quantity === 0n) return 0n;
+	const before = payoutLiability(policy, book.maxPayout, book.totalPayout);
+	return inventoryImpactPotential(policy, payoutLiability(policy, max(book.maxPayout, book.rangeMaxPayout + quantity), book.totalPayout + quantity)) - inventoryImpactPotential(policy, before);
+}
+/** `strike_exposure::live_close_inventory_impact` — the rebate a live close of `payout`
+* receives: the exact fall in the same potential. Zero at the shipped rate of `0n`. */
+function closeInventoryImpact(policy, book, payout) {
+	assertFeePolicy(policy);
+	assertBook(book);
+	assertUint(book.complementMaxPayout, "complementMaxPayout", book.maxPayout);
+	if (max(book.rangeMaxPayout, book.complementMaxPayout) !== book.maxPayout) throw new PredictInputError("maxPayout must equal the larger range or complement payout");
+	assertUint(payout, "close payout", book.rangeMaxPayout);
+	if (policy.inventoryImpactMaxRate === 0n || payout === 0n) return 0n;
+	const before = payoutLiability(policy, book.maxPayout, book.totalPayout);
+	const after = payoutLiability(policy, max(book.rangeMaxPayout - payout, book.complementMaxPayout), book.totalPayout - payout);
+	return inventoryImpactPotential(policy, before) - inventoryImpactPotential(policy, after);
+}
+/** `pricing::probability` — the range's own probability, `up(lower) − up(higher)` with the
+* chain's saturating subtraction and its infinite-boundary defaults. */
+function rangeProbability(boundaries) {
+	assertBoundaries(boundaries);
+	const lower = boundaries.lowerUp ?? FLOAT_SCALING;
+	const higher = boundaries.higherUp ?? 0n;
+	return lower > higher ? lower - higher : 0n;
+}
+function toRawProbability(p) {
+	if (!Number.isFinite(p)) throw new PredictInputError(`probability is not finite: ${p}`);
+	const raw = BigInt(Math.round(p * Number(FLOAT_SCALING)));
+	return raw < 0n ? 0n : raw > FLOAT_SCALING ? FLOAT_SCALING : raw;
+}
+/** Price a range's two boundaries with the local float pricer. `lower`/`upper` are strikes in
+* USD; pass `null` for an infinite side (`{ lower: strike, upper: null }` is an UP order,
+* `{ lower: null, upper: strike }` a DOWN order). Carries the pricer's ~1e-4 approximation. */
+function boundaryProbabilities(pricer, lower, upper) {
+	return {
+		lowerUp: lower === null ? null : toRawProbability(upProbability(pricer, lower)),
+		higherUp: upper === null ? null : toRawProbability(upProbability(pricer, upper))
+	};
+}
+function resolveBoundaries(source) {
+	let boundaries;
+	let exact;
+	if ("pricer" in source) {
+		const { lower, upper } = source;
+		if (lower !== null && upper !== null && lower >= upper) throw new PredictInputError(`lower strike ${lower} must be below ${upper} (EInvalidRange)`);
+		boundaries = boundaryProbabilities(source.pricer, lower, upper);
+		exact = false;
+	} else {
+		boundaries = source;
+		exact = true;
+	}
+	assertBoundaries(boundaries);
+	if (boundaries.lowerUp === null && boundaries.higherUp === null) throw new PredictInputError("a range cannot be infinite on both sides (EInvalidRange)");
+	return {
+		boundaries,
+		exact
+	};
+}
+function rawAmount(value) {
+	const raw = typeof value === "bigint" ? value : usdcToRaw(value);
+	assertUint(raw, "amount");
+	return raw;
+}
+function rawMs(value) {
+	if (typeof value === "number" && !Number.isSafeInteger(value)) throw new PredictInputError(`timestamp must be a safe integer in milliseconds, got ${value}`);
+	const raw = typeof value === "bigint" ? value : BigInt(value);
+	assertUint(raw, "timestamp");
+	return raw;
+}
+function assertProbabilityPolicy(policy, probability) {
+	if (probability < policy.minEntryProbability || probability > policy.maxEntryProbability) throw new PredictInputError(`entry probability ${probability} outside the market's [${policy.minEntryProbability}, ${policy.maxEntryProbability}] admission band (EEntryProbabilityOutOfBounds)`);
+}
+function assertRangeMintPolicy(policy, boundaries) {
+	if (boundaries.lowerUp !== null) assertProbabilityPolicy(policy, boundaries.lowerUp);
+	if (boundaries.higherUp !== null) assertProbabilityPolicy(policy, FLOAT_SCALING - boundaries.higherUp);
+	assertProbabilityPolicy(policy, rangeProbability(boundaries));
+}
+function assertValidQuantity(quantity, lotSize) {
+	if (quantity <= 0n || quantity % lotSize !== 0n || quantity / lotSize > MAX_QUANTITY_LOTS) throw new PredictInputError(`quantity ${quantity} must be a positive multiple of the ${lotSize} lot size, at most ${MAX_QUANTITY_LOTS} lots (EInvalidQuantity)`);
+}
+function timeToExpiry(expiryMs, nowMs) {
+	if (nowMs >= expiryMs) throw new PredictInputError(`market expired at ${expiryMs}; a live trade at ${nowMs} aborts (ELivePricingExpired)`);
+	return expiryMs - nowMs;
+}
+function mintQuoteAt(inputs, boundaries, quantity, timeToExpiryMs) {
+	const premium = mulDown(rangeProbability(boundaries), quantity);
+	const fee = tradingFee(inputs.fees, boundaries, quantity, timeToExpiryMs);
+	const subsidy = feeIncentiveSubsidy(fee, rawAmount(inputs.feeIncentiveBalance ?? 0n));
+	const builder = builderFee(fee, quantity, inputs.builderCode ?? false);
+	const penalty = mulDown(inputs.penaltyRate ?? 0n, quantity);
+	const impact = inputs.book ? mintInventoryImpact(inputs.fees, inputs.book, quantity) : 0n;
+	return {
+		premium,
+		fee,
+		subsidy,
+		builder,
+		penalty,
+		impact,
+		cost: premium + (fee - subsidy) + builder + penalty + impact
+	};
+}
+function mintCostFrom(inputs, boundaries, exact, quantity, timeToExpiryMs) {
+	const q = mintQuoteAt(inputs, boundaries, quantity, timeToExpiryMs);
+	const probability = rangeProbability(boundaries);
+	return {
+		quantity: fromRaw(quantity, 6),
+		entryProbability: fromRaw(probability, 9),
+		premium: fromRaw(q.premium, 6),
+		fees: {
+			trading: fromRaw(q.fee, 6),
+			subsidy: fromRaw(q.subsidy, 6),
+			builder: fromRaw(q.builder, 6),
+			penalty: fromRaw(q.penalty, 6),
+			impact: fromRaw(q.impact, 6)
+		},
+		cost: fromRaw(q.cost, 6),
+		costPerContract: quantity === 0n ? 0 : Number(q.cost) / Number(quantity),
+		payoutMultiple: Number(quantity) / Number(q.cost),
+		raw: {
+			quantity,
+			entryProbability: probability,
+			premium: q.premium,
+			tradingFee: q.fee,
+			subsidy: q.subsidy,
+			builderFee: q.builder,
+			penaltyFee: q.penalty,
+			impactCharge: q.impact,
+			cost: q.cost
+		},
+		exactProbabilities: exact
+	};
+}
+/**
+* All-in cost of minting an exact payout quantity — the `mint_exact_quantity` shape, priced
+* entirely client-side. Mirrors `compute_mint_quote`, including its admission checks: the
+* entry-probability band on each finite leg and on the range, the `min_premium` floor, the lot
+* grid, and the `all_in_cost <= quantity` bound (a contract may never cost more than it can
+* pay out). Each violation throws the `PredictInputError` naming the abort the chain would
+* have raised.
+*/
+function mintCost(inputs) {
+	assertCostInputs(inputs);
+	const { boundaries, exact } = resolveBoundaries(inputs.probabilities);
+	const lotSize = inputs.lotSize ?? POSITION_LOT_SIZE;
+	const quantity = rawAmount(inputs.quantity);
+	const ttl = timeToExpiry(rawMs(inputs.expiryMs), rawMs(inputs.nowMs ?? Date.now()));
+	assertRangeMintPolicy(inputs.fees, boundaries);
+	const premium = mulDown(rangeProbability(boundaries), quantity);
+	if (premium < MIN_PREMIUM) throw new PredictInputError(`premium ${premium} is below the ${MIN_PREMIUM} minimum (EPremiumBelowMinimum)`);
+	assertValidQuantity(quantity, lotSize);
+	const quote = mintCostFrom(inputs, boundaries, exact, quantity, ttl);
+	if (quote.raw.cost > quantity) throw new PredictInputError(`all-in cost ${quote.raw.cost} exceeds the maximum payout ${quantity} (EMintCostAboveMaxPayout)`);
+	return quote;
+}
+/**
+* A fill whose ALL-IN cost fits a budget — `expiry_market::mint_exact_cost` computed
+* client-side, with the same lot search over the same cost function, so the answer is the
+* quantity that entrypoint would size and the cost it would debit.
+*
+* Without it a "spend exactly $X" flow has to guess: every fee is charged ON TOP of the
+* premium, so the caller subtracts an estimated fee load, pads it against an abort, and
+* systematically underspends. Here the whole search runs locally; submit the all-in budget
+* through `tx.mintCost` on deployments carrying `mint_exact_cost`.
+*
+* Sizing also respects the fill's maximum payout and the 32-bit lot cap; either can leave
+* substantial budget unspent. When only the budget binds, one more lot would exceed it.
+* If the budget fill exceeds its maximum payout, the contract's step-down is best effort:
+* rounding can make it miss a larger admissible fill, including one meeting `minQuantity`.
+* The chain caps the budget at the account balance first ({@link MintBudgetInputs.accountBalance}).
+*/
+function mintCostForBudget(inputs) {
+	assertCostInputs(inputs);
+	const { boundaries, exact } = resolveBoundaries(inputs.probabilities);
+	const lotSize = inputs.lotSize ?? POSITION_LOT_SIZE;
+	const ttl = timeToExpiry(rawMs(inputs.expiryMs), rawMs(inputs.nowMs ?? Date.now()));
+	const minQuantity = inputs.minQuantity === void 0 ? lotSize : rawAmount(inputs.minQuantity);
+	const requestedBudget = rawAmount(inputs.budget);
+	let budget = requestedBudget;
+	if (inputs.accountBalance !== void 0) budget = min(budget, rawAmount(inputs.accountBalance));
+	assertRangeMintPolicy(inputs.fees, boundaries);
+	const probability = rangeProbability(boundaries);
+	let lo = 0n;
+	let hi = MAX_QUANTITY_LOTS;
+	while (lo < hi) {
+		const mid = (lo + hi + 1n) / 2n;
+		if (mulDown(probability, mid * lotSize) <= budget) lo = mid;
+		else hi = mid - 1n;
+	}
+	const allInCostAt = (quantity$1) => mintQuoteAt(inputs, boundaries, quantity$1, ttl).cost;
+	hi = lo;
+	lo = 0n;
+	while (lo < hi) {
+		const mid = (lo + hi + 1n) / 2n;
+		if (allInCostAt(mid * lotSize) <= budget) lo = mid;
+		else hi = mid - 1n;
+	}
+	const budgetLots = lo;
+	const budgetQuantity = budgetLots * lotSize;
+	let lots = budgetLots;
+	if (budgetLots > 0n && allInCostAt(budgetQuantity) > budgetQuantity) {
+		let stepLo = 0n;
+		let stepHi = budgetLots - 1n;
+		while (stepLo < stepHi) {
+			const mid = (stepLo + stepHi + 1n) / 2n;
+			const candidate = mid * lotSize;
+			if (allInCostAt(candidate) <= candidate) stepLo = mid;
+			else stepHi = mid - 1n;
+		}
+		lots = stepLo === 0n ? budgetLots : stepLo;
+	}
+	const quantity = lots * lotSize;
+	if (quantity < minQuantity) throw new PredictInputError(`budget ${budget} sizes ${quantity}, below the ${minQuantity} minimum (EMintQuantityBelowMin)`);
+	const premium = mulDown(probability, quantity);
+	if (premium < MIN_PREMIUM) throw new PredictInputError(`budget ${budget} sizes a premium of ${premium}, below the ${MIN_PREMIUM} minimum (EPremiumBelowMinimum)`);
+	assertValidQuantity(quantity, lotSize);
+	const quote = mintCostFrom(inputs, boundaries, exact, quantity, ttl);
+	if (quote.raw.cost > quantity) throw new PredictInputError(`sized fill inside budget ${budget} costs more than it can pay out: ${quote.raw.cost} exceeds ${quantity} (EMintCostAboveMaxPayout)`);
+	return {
+		...quote,
+		budget: fromRaw(requestedBudget, 6),
+		effectiveBudget: fromRaw(budget, 6),
+		unspentBudget: fromRaw(requestedBudget - quote.raw.cost, 6),
+		raw: {
+			...quote.raw,
+			budget: requestedBudget,
+			effectiveBudget: budget,
+			unspentBudget: requestedBudget - quote.raw.cost
+		}
+	};
+}
+/**
+* Net proceeds of closing a live position — `expiry_market::redeem_live`'s payment
+* decomposition, client-side. The mirror of {@link mintCost}: the same per-boundary trading
+* fee and builder fee, the same congestion surcharge, and the inventory-impact term as a
+* REBATE rather than a charge. There is no sponsor subsidy on a close (incentives subsidise
+* mints only), and each deduction is clamped at the payout remaining after the ones before it,
+* exactly as the contract clamps them, so a close can never cost more than it releases.
+*
+* Use this for a local UI preview from a supplied snapshot. `read.quoteRedeem` simulates
+* the actual close and remains the pre-trade check for ownership, remaining position size,
+* live-market gates and current fees. `proceeds` is what `min_proceeds` is compared against
+* on the real call; this preview does not guarantee execution at that amount.
+*/
+function redeemLiveProceeds(inputs) {
+	assertCostInputs(inputs);
+	const { boundaries, exact } = resolveBoundaries(inputs.probabilities);
+	const lotSize = inputs.lotSize ?? POSITION_LOT_SIZE;
+	const quantity = rawAmount(inputs.closeQuantity);
+	const ttl = timeToExpiry(rawMs(inputs.expiryMs), rawMs(inputs.nowMs ?? Date.now()));
+	assertValidQuantity(quantity, lotSize);
+	const positionQuantity = inputs.positionQuantity === void 0 ? null : rawAmount(inputs.positionQuantity);
+	if (positionQuantity !== null) {
+		assertValidQuantity(positionQuantity, lotSize);
+		if (quantity > positionQuantity) throw new PredictInputError("closeQuantity exceeds positionQuantity");
+	}
+	const remainingQuantity = positionQuantity === null ? null : positionQuantity - quantity;
+	const probability = rangeProbability(boundaries);
+	const gross = mulDown(probability, quantity);
+	const fee = min(tradingFee(inputs.fees, boundaries, quantity, ttl), gross);
+	const builder = min(builderFee(fee, quantity, inputs.builderCode ?? false), gross - fee);
+	const penalty = min(mulDown(inputs.penaltyRate ?? 0n, quantity), gross - fee - builder);
+	const rebate = inputs.book ? closeInventoryImpact(inputs.fees, inputs.book, quantity) : 0n;
+	const proceeds = gross + rebate - fee - builder - penalty;
+	return {
+		proceeds: fromRaw(proceeds, 6),
+		gross: fromRaw(gross, 6),
+		fees: {
+			trading: fromRaw(fee, 6),
+			builder: fromRaw(builder, 6),
+			penalty: fromRaw(penalty, 6),
+			impactRebate: fromRaw(rebate, 6)
+		},
+		quantityClosed: fromRaw(quantity, 6),
+		remainingQuantity: remainingQuantity === null ? null : fromRaw(remainingQuantity, 6),
+		proceedsPerContract: Number(proceeds) / Number(quantity),
+		probability: fromRaw(probability, 9),
+		raw: {
+			proceeds,
+			gross,
+			tradingFee: fee,
+			builderFee: builder,
+			penaltyFee: penalty,
+			impactRebate: rebate,
+			quantityClosed: quantity,
+			remainingQuantity,
+			probability
+		},
+		exactProbabilities: exact
+	};
+}
+const QUANTITY_LOTS_OFFSET = 100n;
+const LOWER_TICK_OFFSET = 70n;
+const HIGHER_TICK_OFFSET = 40n;
+const TICK_MASK = POS_INF_TICK;
+const U32_MASK = (1n << 32n) - 1n;
+/** Decode an order ID's range and quantity — the TypeScript mirror of `order::lower_tick` /
+* `higher_tick` / `quantity`. */
+function decodeOrderRange(orderId, lotSize = POSITION_LOT_SIZE) {
+	return {
+		lowerTick: orderId >> LOWER_TICK_OFFSET & TICK_MASK,
+		higherTick: orderId >> HIGHER_TICK_OFFSET & TICK_MASK,
+		quantity: (orderId >> QUANTITY_LOTS_OFFSET & U32_MASK) * lotSize
+	};
+}
+/** The strikes an {@link OrderRange} prices against, in USD, with `null` for each infinite
+* side — the shape {@link boundaryProbabilities} takes. `tickSize` is the market's raw tick
+* size (`ActiveMarket.tickSize` in USD, or the raw value from the deployment). */
+function orderStrikes(range, tickSizeRaw) {
+	return {
+		lower: range.lowerTick === 0n ? null : fromRaw(range.lowerTick * tickSizeRaw, 9),
+		upper: range.higherTick === POS_INF_TICK ? null : fromRaw(range.higherTick * tickSizeRaw, 9)
+	};
+}
+
+//#endregion
+export { cost_exports };
+//# sourceMappingURL=cost.mjs.map