@mysten/deepbook-v3 2.6.4 → 2.8.0

package/dist/predict/queue.mjs

@@ -0,0 +1,774 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { PredictInputError } from "./errors.mjs";
+import { U64_MAX } from "./units.mjs";
+import { FLOAT_SCALING, MAX_QUANTITY_LOTS, POSITION_LOT_SIZE, decodeOrderRange } from "./cost.mjs";
+
+//#region src/predict/queue.ts
+var queue_exports = /* @__PURE__ */ __exportAll({
+	DEADLINE_EXPIRY_MARGIN_MS: () => DEADLINE_EXPIRY_MARGIN_MS,
+	DELAYED_EXECUTION_VERSION: () => DELAYED_EXECUTION_VERSION,
+	ORDER_FLOW_PACKAGE_VERSION: () => ORDER_FLOW_PACKAGE_VERSION,
+	ORDER_KIND: () => ORDER_KIND,
+	ORDER_STATUS: () => ORDER_STATUS,
+	PREDICT_PACKAGE_VERSION: () => PREDICT_PACKAGE_VERSION,
+	PYTH_CHANNEL: () => PYTH_CHANNEL,
+	REFUND_REASON: () => REFUND_REASON,
+	REFUND_REASONS: () => REFUND_REASONS,
+	REFUND_REQUEST_GRACE_MS: () => REFUND_REQUEST_GRACE_MS,
+	SETTLE_PHASE: () => SETTLE_PHASE,
+	budgetMintLimits: () => budgetMintLimits,
+	cashNeedBudget: () => cashNeedBudget,
+	cashNeedExactQuantity: () => cashNeedExactQuantity,
+	cashNeedSell: () => cashNeedSell,
+	channelTickMs: () => channelTickMs,
+	exactMintLimits: () => exactMintLimits,
+	feeCovered: () => feeCovered,
+	isMintKind: () => isMintKind,
+	isSellKind: () => isSellKind,
+	maxMintNow: () => maxMintNow,
+	mintBudget: () => mintBudget,
+	mintCashNeed: () => mintCashNeed,
+	orderCutoffMs: () => orderCutoffMs,
+	orderKindName: () => orderKindName,
+	orderStatusName: () => orderStatusName,
+	orderView: () => orderView,
+	policyFromBcs: () => policyFromBcs,
+	previewTiming: () => previewTiming,
+	reduceOrderEvents: () => reduceOrderEvents,
+	refundReason: () => refundReason,
+	sellCashCheck: () => sellCashCheck,
+	sellLimits: () => sellLimits,
+	slippageBand: () => slippageBand
+});
+/**
+* Predict's `constants::current_version` from the upgrade that added delayed execution. Enqueue
+* works once `ProtocolConfig.version_watermark` reaches it (Predict's admission aborts
+* `ECutoverNotReached` until then). The retired immediate trades (`mint_exact_*`, `redeem_live`)
+* always abort in that package, and the older packages they still run in are retired by the same
+* bump. The same on both networks: it is the code's version constant, not the on-chain package
+* version (Mainnet v4, Testnet v5).
+*/
+const DELAYED_EXECUTION_VERSION = 4n;
+/**
+* Predict's `constants::current_version` of the package these bindings were generated from. Every
+* version-gated Predict call checks `chk_version`, which aborts `EPackageVersionDisabled` once
+* `ProtocolConfig.version_watermark` is above it, so a higher watermark retires the Predict code
+* this SDK calls. Bump it with Predict when regenerating.
+*/
+const PREDICT_PACKAGE_VERSION = 4n;
+/**
+* `desk::current_version` of the order-flow package these bindings were generated from. The desk's
+* version floor retires older companion code, so a floor above it means the package this SDK calls
+* aborts `EPackageVersionDisabled`. Bump it with the companion when regenerating.
+*/
+const ORDER_FLOW_PACKAGE_VERSION = 1n;
+/** `queue::phase_*`: what `settle_step` returns, the phase the next call runs. */
+const SETTLE_PHASE = Object.freeze({
+	DRAIN: 0,
+	PAY: 1,
+	DONE: 2
+});
+/** `order_queue::status_*`. Never renumbered on chain; unknown codes still decode. */
+const ORDER_STATUS = Object.freeze({
+	PENDING: 0,
+	COMMITTED: 1,
+	OPEN: 2,
+	REFUNDED: 3,
+	CLOSED: 4,
+	REFUND_DUE: 5
+});
+/** `order_queue::kind_*`. `REDEEM_LIVE` is reserved and never used by v4. */
+const ORDER_KIND = Object.freeze({
+	EXACT_QUANTITY: 0,
+	EXACT_AMOUNT: 1,
+	EXACT_COST: 2,
+	REDEEM_LIVE: 3,
+	REDEEM_OPEN: 4
+});
+/** `order_queue::reason_*`. `0` in a record's result means filled. */
+const REFUND_REASON = Object.freeze({
+	LIMITS: 1,
+	ADMISSION: 2,
+	NO_PRICE: 3,
+	MISSING_NODE: 4,
+	DEADLINE: 5,
+	FREEZE: 6,
+	ADMIN: 7,
+	NO_CASH: 8,
+	RECIPIENT_DENIED: 9
+});
+/** The Pyth Lazer channels the queue prices on (`delayed_execution_config`). */
+const PYTH_CHANNEL = Object.freeze({
+	FIXED_RATE_50MS: 2,
+	FIXED_RATE_200MS: 3
+});
+/** Predict's `constants::deadline_expiry_margin_ms`: every deadline is at least this long before expiry. */
+const DEADLINE_EXPIRY_MARGIN_MS = 5000n;
+/**
+* How long after an order's deadline the app waits before offering "Refund my order". Keepers
+* refund overdue orders on their own, so the button only matters when they are all down.
+*/
+const REFUND_REQUEST_GRACE_MS = 5000n;
+const STATUS_NAMES = [
+	"pending",
+	"committed",
+	"open",
+	"refunded",
+	"closed",
+	"refund-due"
+];
+const KIND_NAMES = [
+	"exact-quantity",
+	"exact-amount",
+	"exact-cost",
+	"redeem-live",
+	"redeem-open"
+];
+/** A status code's name, or `'unknown'` for a code this SDK version predates. */
+function orderStatusName(code) {
+	return STATUS_NAMES[code] ?? "unknown";
+}
+/** A kind code's name, or `'unknown'` for a code this SDK version predates. */
+function orderKindName(code) {
+	return KIND_NAMES[code] ?? "unknown";
+}
+/** Whether a kind code is a queued mint (exact quantity, exact amount or exact cost). */
+function isMintKind(kind) {
+	return kind === ORDER_KIND.EXACT_QUANTITY || kind === ORDER_KIND.EXACT_AMOUNT || kind === ORDER_KIND.EXACT_COST;
+}
+/** Whether a kind code is a queued sell. */
+function isSellKind(kind) {
+	return kind === ORDER_KIND.REDEEM_OPEN || kind === ORDER_KIND.REDEEM_LIVE;
+}
+/** Every reason code v4 defines, with its text and fee treatment. */
+const REFUND_REASONS = Object.freeze({
+	1: {
+		code: 1,
+		key: "limits",
+		text: "Your price limits weren't met at the fill price. Refunded, the order fee is kept.",
+		feeKept: true,
+		live: true
+	},
+	2: {
+		code: 2,
+		key: "admission",
+		text: "The market couldn't accept the order at the fill price. Refunded, the order fee is kept.",
+		feeKept: true,
+		live: true
+	},
+	3: {
+		code: 3,
+		key: "no-price",
+		text: "No price arrived for the order. Refunded in full.",
+		feeKept: false,
+		live: false
+	},
+	4: {
+		code: 4,
+		key: "missing-node",
+		text: "The market couldn't place the order. Refunded in full.",
+		feeKept: false,
+		live: true
+	},
+	5: {
+		code: 5,
+		key: "deadline",
+		text: "The order wasn't priced before its deadline. Refunded in full.",
+		feeKept: false,
+		live: true
+	},
+	6: {
+		code: 6,
+		key: "freeze",
+		text: "The protocol was frozen. Refunded in full.",
+		feeKept: false,
+		live: false
+	},
+	7: {
+		code: 7,
+		key: "admin",
+		text: "Refunded in full by an admin.",
+		feeKept: false,
+		live: true
+	},
+	8: {
+		code: 8,
+		key: "no-cash",
+		text: "The market couldn't pay right now. Refunded in full.",
+		feeKept: false,
+		live: true
+	},
+	9: {
+		code: 9,
+		key: "recipient-denied",
+		text: "The account's receive address can't take USDC right now (it is on USDC's deny list, or USDC is paused). Refunded in full, and the refund waits in the order until it can be claimed.",
+		feeKept: false,
+		live: true
+	}
+});
+/** A reason code's meaning. Unknown codes map to `key: 'unknown'` rather than throwing. */
+function refundReason(code) {
+	return REFUND_REASONS[code] ?? {
+		code,
+		key: "unknown",
+		text: `Refunded (code ${code}).`,
+		feeKept: null,
+		live: false
+	};
+}
+/** Map the generated policy layout to {@link DelayedExecutionPolicy}. */
+function policyFromBcs(p) {
+	return {
+		delayMs: p.delay_ms,
+		stallTimeoutMs: p.stall_timeout_ms,
+		stuckThresholdMs: p.stuck_threshold_ms,
+		gapWaitMs: p.gap_wait_ms,
+		pythPriceBufferMs: p.pyth_price_buffer_ms,
+		pythChannel: p.pyth_channel,
+		sviMaxAgeMs: p.svi_max_age_ms,
+		mintCapacity: p.mint_capacity,
+		sellCapacity: p.sell_capacity,
+		perAccountCap: p.per_account_cap,
+		orderFee: p.order_fee,
+		minSellQuantity: p.min_sell_quantity,
+		settleRefundBatch: p.settle_refund_batch,
+		settlePayoutBatch: p.settle_payout_batch
+	};
+}
+/** `delayed_execution_config::channel_tick_ms`: 50 ms for channel 2, 200 ms for channel 3. */
+function channelTickMs(channel) {
+	if (channel === PYTH_CHANNEL.FIXED_RATE_50MS) return 50n;
+	if (channel === PYTH_CHANNEL.FIXED_RATE_200MS) return 200n;
+	throw new PredictInputError(`unsupported Pyth Lazer channel ${channel}`);
+}
+function assertUint(value, name, max$1 = U64_MAX) {
+	if (typeof value !== "bigint" || value < 0n || value > max$1) throw new PredictInputError(`${name} must be a bigint in [0, ${max$1}], got ${String(value)}`);
+}
+function mulDivUp(x, y, denominator) {
+	if (denominator === 0n) throw new PredictInputError("division by zero (EInputZero)");
+	return (x * y + denominator - 1n) / denominator;
+}
+function plusOne(need) {
+	if (need >= U64_MAX) throw new PredictInputError("cash need overflows u64");
+	return need + 1n;
+}
+/** Exact-quantity mint cash need: `⌈quantity · (1 − p_min)⌉ + 1`. */
+function cashNeedExactQuantity(quantity, minEntryProbability) {
+	assertUint(quantity, "quantity");
+	assertUint(minEntryProbability, "minEntryProbability", FLOAT_SCALING);
+	return plusOne(mulDivUp(quantity, FLOAT_SCALING - minEntryProbability, FLOAT_SCALING));
+}
+/**
+* Budget mint cash need: `⌈(budget + 1) · (1 / p_min − 1)⌉ + 1`, rounded as Move rounds it (one
+* `mul_div_up` of `(budget + 1) · (1e9 − p_min) / p_min`). Exact-amount mints pass
+* `min(max_premium, budget)`. `p_min = 0` throws, as the Move division aborts.
+*/
+function cashNeedBudget(budget, minEntryProbability) {
+	assertUint(budget, "budget", U64_MAX - 1n);
+	assertUint(minEntryProbability, "minEntryProbability", FLOAT_SCALING);
+	return plusOne(mulDivUp(budget + 1n, FLOAT_SCALING - minEntryProbability, minEntryProbability));
+}
+/** Sell cash need: `⌈close_quantity · (1 − λ)⌉ + 1`. */
+function cashNeedSell(closeQuantity, backingBufferLambda) {
+	assertUint(closeQuantity, "closeQuantity");
+	assertUint(backingBufferLambda, "backingBufferLambda", FLOAT_SCALING);
+	return plusOne(mulDivUp(closeQuantity, FLOAT_SCALING - backingBufferLambda, FLOAT_SCALING));
+}
+/**
+* Whether the account can pay the order fee: a mint needs `available > fee` (it escrows a budget
+* on top), a sell needs `available ≥ fee` (it escrows only the fee). `available` is
+* `account::balance<USDC>`, unsettled accumulator funds included.
+*/
+function feeCovered(side, availableRaw, orderFeeRaw) {
+	return side === "mint" ? availableRaw > orderFeeRaw : availableRaw >= orderFeeRaw;
+}
+/**
+* The budget a queued mint escrows: `min(max_cost, available − fee)`, and for exact quantity also
+* at most the quantity. `null` when the balance doesn't cover the fee. Enqueue debits the budget
+* plus the order fee, and the unspent budget comes back at the fill.
+*/
+function mintBudget(inputs) {
+	if (!feeCovered("mint", inputs.availableRaw, inputs.orderFeeRaw)) return null;
+	const budget = min(inputs.maxCostRaw, inputs.availableRaw - inputs.orderFeeRaw);
+	if (inputs.kind !== ORDER_KIND.EXACT_QUANTITY) return budget;
+	if (inputs.quantityRaw == null) throw new PredictInputError("quantityRaw is required for an exact-quantity budget");
+	return min(budget, inputs.quantityRaw);
+}
+/** A queued mint's cash need, picking the formula the contract picks for its kind. */
+function mintCashNeed(inputs) {
+	const p = inputs.minEntryProbability;
+	switch (inputs.kind) {
+		case ORDER_KIND.EXACT_QUANTITY:
+			if (inputs.quantityRaw == null) throw new PredictInputError("quantityRaw is required");
+			return cashNeedExactQuantity(inputs.quantityRaw, p);
+		case ORDER_KIND.EXACT_AMOUNT:
+			if (inputs.maxPremiumRaw == null) throw new PredictInputError("maxPremiumRaw is required");
+			return cashNeedBudget(min(inputs.maxPremiumRaw, inputs.budgetRaw), p);
+		case ORDER_KIND.EXACT_COST: return cashNeedBudget(inputs.budgetRaw, p);
+		default: throw new PredictInputError(`kind ${inputs.kind} is not a mint`);
+	}
+}
+/**
+* A sell's cash need against the market's spare cash. Sells are never refused for market cash at
+* placement: the keeper funds the market before τ, and a sell the market still can't cover at the
+* fill is refunded in full (reason 8). `short` flags that risk, and the sell builder can add
+* `rebalance_expiry_cash` after the enqueue to fund the market at once.
+*/
+function sellCashCheck(closeQuantityRaw, spareCashRaw, backingBufferLambda) {
+	const needRaw = cashNeedSell(closeQuantityRaw, backingBufferLambda);
+	return {
+		needRaw,
+		short: needRaw > spareCashRaw
+	};
+}
+/**
+* The largest queued mint a market's spare cash admits now ("Max right now"). Predict's admission
+* refuses a mint whose cash need is above spare cash (`EInsufficientMarketCash`). For exact quantity this
+* is the largest lot multiple `q` with `cashNeedExactQuantity(q) ≤ S`; for a budget it is the
+* largest `b` with `cashNeedBudget(b) ≤ S`, where `S` is spare cash less the headroom.
+*
+* It is a snapshot: fills lower spare cash, and the keeper's rebalance after each enqueue raises
+* it. Other waiting orders don't count against a mint. For exact quantity this caps only the
+* cash side: size the balance side with `cost.mintCostForBudget` at `available − fee`. A budget
+* mint with `p_min = 0` can't be placed at all (the cash need divides by `p_min`), so it reads 0.
+*/
+function maxMintNow(inputs) {
+	const p = inputs.minEntryProbability;
+	assertUint(p, "minEntryProbability", FLOAT_SCALING);
+	assertUint(inputs.spareCashRaw, "spareCashRaw");
+	const headroom = inputs.headroomBps ?? 100n;
+	if (headroom < 0n || headroom > 10000n) throw new PredictInputError(`headroomBps must be in [0, 10000], got ${headroom}`);
+	const spare = inputs.spareCashRaw - inputs.spareCashRaw * headroom / 10000n;
+	const asOfMs = inputs.asOfMs ?? null;
+	let cashLimitRaw;
+	let balanceLimitRaw = null;
+	if (inputs.shape === "exact-quantity") {
+		const lot = inputs.lotSize ?? POSITION_LOT_SIZE;
+		if (p >= FLOAT_SCALING) cashLimitRaw = null;
+		else if (spare < 2n) cashLimitRaw = 0n;
+		else {
+			const cap = MAX_QUANTITY_LOTS * lot;
+			let q = min((spare - 1n) * FLOAT_SCALING / (FLOAT_SCALING - p), cap);
+			q -= q % lot;
+			while (q > 0n && cashNeedExactQuantity(q, p) > spare) q -= lot;
+			cashLimitRaw = q;
+		}
+	} else {
+		if (p === 0n) cashLimitRaw = 0n;
+		else if (p >= FLOAT_SCALING) cashLimitRaw = null;
+		else if (spare < 2n) cashLimitRaw = 0n;
+		else {
+			let b = (spare - 1n) * p / (FLOAT_SCALING - p) - 1n;
+			while (b > 0n && cashNeedBudget(b, p) > spare) b -= 1n;
+			cashLimitRaw = b > 0n ? b : 0n;
+		}
+		if (inputs.availableRaw != null) {
+			const fee = inputs.orderFeeRaw ?? 0n;
+			balanceLimitRaw = inputs.availableRaw > fee ? inputs.availableRaw - fee : 0n;
+		}
+	}
+	if (cashLimitRaw == null && balanceLimitRaw == null) return {
+		cashLimitRaw,
+		balanceLimitRaw,
+		maxRaw: null,
+		limitedBy: "none",
+		asOfMs
+	};
+	if (balanceLimitRaw == null || cashLimitRaw != null && cashLimitRaw <= balanceLimitRaw) return {
+		cashLimitRaw,
+		balanceLimitRaw,
+		maxRaw: cashLimitRaw,
+		limitedBy: "cash",
+		asOfMs
+	};
+	return {
+		cashLimitRaw,
+		balanceLimitRaw,
+		maxRaw: balanceLimitRaw,
+		limitedBy: "balance",
+		asOfMs
+	};
+}
+/**
+* `expiry − max(no_trade_window_ms, stall_timeout_ms + 5_000)`, saturating at 0: enqueue requires
+* the order's τ below it.
+*/
+function orderCutoffMs(expiryMs, policy, noTradeWindowMs) {
+	const margin = max(noTradeWindowMs, policy.stallTimeoutMs + DEADLINE_EXPIRY_MARGIN_MS);
+	return expiryMs > margin ? expiryMs - margin : 0n;
+}
+/**
+* Preview `order_queue::plan_timing`: τ is the policy channel's last tick at or before
+* `now + delay`, never below the last τ, and pushed past the last committed τ. Display only:
+* the contract uses the consensus timestamp, which can differ from the local clock.
+*/
+function previewTiming(inputs) {
+	const { policy, heads } = inputs;
+	const tickMs = channelTickMs(policy.pythChannel);
+	const rounded = (inputs.nowMs + policy.delayMs) / tickMs * tickMs;
+	let tauMs = max(rounded, heads.lastTauMs);
+	if (inputs.lastChannel != null && heads.nextId > 0n && inputs.lastChannel !== policy.pythChannel) tauMs = max(rounded, nextTickAfter(heads.lastTauMs, tickMs));
+	if (tauMs <= heads.lastCommittedTauMs) tauMs = nextTickAfter(heads.lastCommittedTauMs, tickMs);
+	const deadlineMs = min(tauMs + policy.stallTimeoutMs, inputs.expiryMs);
+	const cutoffMs = orderCutoffMs(inputs.expiryMs, policy, inputs.noTradeWindowMs);
+	return {
+		tauMs,
+		deadlineMs,
+		cutoffMs,
+		tickMs,
+		beforeCutoff: tauMs < cutoffMs
+	};
+}
+function nextTickAfter(timeMs, tickMs) {
+	return (timeMs / tickMs + 1n) * tickMs;
+}
+/**
+* A heuristic band for a queued order's price limits: `Δp ≈ k · φ(Φ⁻¹(p)) · √(h / T)`, the
+* probability move of a digital under Brownian motion over the horizon `h` (delay + tick +
+* resolve + signing), scaled by the time `T` left. Use `maxProbability = p + Δp` on exact-quantity
+* mints and `minProbability = p − Δp` on sells, and size cost caps at the shifted probability.
+* A sizing aid pending product sign-off, not a contract rule.
+*/
+function slippageBand(inputs) {
+	const p = inputs.probability;
+	if (!(p > 0 && p < 1)) throw new PredictInputError(`probability must be in (0, 1), got ${p}`);
+	const horizonMs = inputs.delayMs + inputs.tickMs + (inputs.resolveMs ?? 500) + (inputs.signingMs ?? 500);
+	const k = inputs.k ?? 2;
+	const delta = inputs.timeToExpiryMs <= horizonMs ? 1 : Math.min(1, k * normalPdf(inverseNormalCdf(p)) * Math.sqrt(horizonMs / inputs.timeToExpiryMs));
+	return {
+		horizonMs,
+		deltaProbability: delta,
+		maxProbability: Math.min(1, p + delta),
+		minProbability: Math.max(0, p - delta)
+	};
+}
+const COST_ROUNDING_SLACK = 10n;
+function pricePerContract(inputs) {
+	const subsidy = inputs.feeIncentiveSubsidyRaw ?? 0n;
+	assertUint(inputs.quoteCostRaw, "quoteCostRaw");
+	assertUint(inputs.quoteQuantityRaw, "quoteQuantityRaw");
+	assertUint(inputs.slippageRaw, "slippageRaw", FLOAT_SCALING);
+	assertUint(subsidy, "feeIncentiveSubsidyRaw");
+	if (inputs.quoteQuantityRaw === 0n) throw new PredictInputError("the quote buys no payout, so it sizes no limits");
+	return {
+		nowRaw: mulDivUp(inputs.quoteCostRaw, FLOAT_SCALING, inputs.quoteQuantityRaw),
+		worstRaw: mulDivUp(inputs.quoteCostRaw + subsidy, FLOAT_SCALING, inputs.quoteQuantityRaw) + inputs.slippageRaw
+	};
+}
+/**
+* Limits for a queued all-in budget mint (`enqueueMintCost`): the payout floor at the worst price.
+* The fill buys what `budgetRaw` buys at τ and refunds the order when that is below
+* `minQuantityRaw`, so the order fills while the all-in price per $1 of payout stays within
+* `slippageRaw` of the quote.
+*/
+function budgetMintLimits(inputs) {
+	assertUint(inputs.budgetRaw, "budgetRaw");
+	const price = pricePerContract(inputs);
+	const lot = inputs.lotSize ?? POSITION_LOT_SIZE;
+	return {
+		minQuantityRaw: (inputs.budgetRaw > COST_ROUNDING_SLACK ? inputs.budgetRaw - COST_ROUNDING_SLACK : 0n) * FLOAT_SCALING / price.worstRaw / lot * lot,
+		pricePerContract: price
+	};
+}
+/**
+* Limits for a queued exact-quantity mint (`enqueueMint`): the entry-probability cap and the
+* all-in cost cap at the worst price. The cost cap never exceeds the quantity, since a contract
+* never costs more than it pays.
+*/
+function exactMintLimits(inputs) {
+	assertUint(inputs.entryProbabilityRaw, "entryProbabilityRaw", FLOAT_SCALING);
+	const price = pricePerContract(inputs);
+	const maxCostRaw = mulDivUp(inputs.quoteQuantityRaw, price.worstRaw, FLOAT_SCALING);
+	const maxProbabilityRaw = inputs.entryProbabilityRaw + inputs.slippageRaw;
+	return {
+		maxCostRaw: min(maxCostRaw, inputs.quoteQuantityRaw),
+		maxProbabilityRaw: min(maxProbabilityRaw, FLOAT_SCALING),
+		pricePerContract: price
+	};
+}
+/**
+* Limits for a queued early sell (`enqueueSell`): the close-probability floor and the proceeds
+* floor at the worst price. `proceedsRaw` is the quote's proceeds before the order fee, as
+* `minProceeds` is.
+*/
+function sellLimits(inputs) {
+	assertUint(inputs.proceedsRaw, "proceedsRaw");
+	assertUint(inputs.closeQuantityRaw, "closeQuantityRaw");
+	assertUint(inputs.probabilityRaw, "probabilityRaw", FLOAT_SCALING);
+	assertUint(inputs.slippageRaw, "slippageRaw", FLOAT_SCALING);
+	const give = mulDivUp(inputs.closeQuantityRaw, inputs.slippageRaw, FLOAT_SCALING);
+	return {
+		minProceedsRaw: inputs.proceedsRaw > give ? inputs.proceedsRaw - give : 0n,
+		minProbabilityRaw: inputs.probabilityRaw > inputs.slippageRaw ? inputs.probabilityRaw - inputs.slippageRaw : 0n
+	};
+}
+function normalPdf(x) {
+	return Math.exp(-.5 * x * x) / Math.sqrt(2 * Math.PI);
+}
+function inverseNormalCdf(p) {
+	const a = [
+		-39.69683028665376,
+		220.9460984245205,
+		-275.9285104469687,
+		138.357751867269,
+		-30.66479806614716,
+		2.506628277459239
+	];
+	const b = [
+		-54.47609879822406,
+		161.5858368580409,
+		-155.6989798598866,
+		66.80131188771972,
+		-13.28068155288572
+	];
+	const c = [
+		-.007784894002430293,
+		-.3223964580411365,
+		-2.400758277161838,
+		-2.549732539343734,
+		4.374664141464968,
+		2.938163982698783
+	];
+	const d = [
+		.007784695709041462,
+		.3224671290700398,
+		2.445134137142996,
+		3.754408661907416
+	];
+	const low = .02425;
+	if (p < low) {
+		const q$1 = Math.sqrt(-2 * Math.log(p));
+		return (((((c[0] * q$1 + c[1]) * q$1 + c[2]) * q$1 + c[3]) * q$1 + c[4]) * q$1 + c[5]) / ((((d[0] * q$1 + d[1]) * q$1 + d[2]) * q$1 + d[3]) * q$1 + 1);
+	}
+	if (p > 1 - low) {
+		const q$1 = Math.sqrt(-2 * Math.log(1 - p));
+		return -((((((c[0] * q$1 + c[1]) * q$1 + c[2]) * q$1 + c[3]) * q$1 + c[4]) * q$1 + c[5]) / ((((d[0] * q$1 + d[1]) * q$1 + d[2]) * q$1 + d[3]) * q$1 + 1));
+	}
+	const q = p - .5;
+	const r = q * q;
+	return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+}
+function heldPosition(p, lotSize) {
+	return p.order_id === 0n ? null : {
+		orderId: p.order_id,
+		rootId: p.root_id,
+		openedAtMs: p.opened_at_ms,
+		quantityRaw: decodeOrderRange(p.order_id, lotSize).quantity
+	};
+}
+/**
+* Map a queue record to its display state. `nowMs` drives the refund flags. A record is sellable
+* while it is Open, holds a position, and `nowMs` is before the cutoff (`opts.cutoffMs`, or the
+* record's own placement cutoff when omitted). Unknown status or kind codes map to `unknown`.
+* `opts.lotSize` is the config's position lot (default 10,000, Predict's), which decodes a held
+* position's quantity.
+*/
+function orderView(record, nowMs, opts = {}) {
+	const kind = record.kind;
+	const base = {
+		status: record.status,
+		kind,
+		kindName: orderKindName(kind),
+		side: isMintKind(kind) ? "mint" : isSellKind(kind) ? "sell" : "unknown"
+	};
+	if (base.side === "unknown") return {
+		...base,
+		state: "unknown"
+	};
+	const { tau_ms: tauMs, deadline_ms: deadlineMs } = record.timing;
+	const canRequestRefund = nowMs >= deadlineMs + REFUND_REQUEST_GRACE_MS;
+	const position = heldPosition(record.position, opts.lotSize);
+	const cutoffMs = opts.cutoffMs ?? record.timing.cutoff_ms;
+	const sellable = position != null && nowMs < cutoffMs;
+	const result = record.result;
+	const parkedRaw = record.funds;
+	switch (record.status) {
+		case ORDER_STATUS.PENDING: return {
+			...base,
+			state: "placed",
+			tauMs,
+			deadlineMs,
+			awaitingPrice: nowMs >= tauMs,
+			autoRefundByMs: deadlineMs,
+			canRequestRefund
+		};
+		case ORDER_STATUS.COMMITTED: return {
+			...base,
+			state: "priced",
+			tauMs,
+			tickMs: record.price.tick_ms,
+			priceRaw: record.price.spot,
+			deadlineMs,
+			msToDeadline: deadlineMs > nowMs ? deadlineMs - nowMs : 0n,
+			autoRefundByMs: deadlineMs,
+			canRequestRefund
+		};
+		case ORDER_STATUS.REFUND_DUE: return {
+			...base,
+			state: "refunding",
+			reason: refundReason(result.reason),
+			deadlineMs,
+			canRequestRefund
+		};
+		case ORDER_STATUS.OPEN:
+			if (base.side === "sell" && result.reason > 0) return {
+				...base,
+				state: "refunded",
+				reason: refundReason(result.reason),
+				finishedAtMs: result.finished_at_ms,
+				positionBackAsOpenRecord: true,
+				position,
+				sellable,
+				parkedRaw
+			};
+			return {
+				...base,
+				state: "filled",
+				quantityRaw: result.quantity,
+				amountRaw: result.amount,
+				finishedAtMs: result.finished_at_ms,
+				position,
+				sellable,
+				parkedRaw
+			};
+		case ORDER_STATUS.REFUNDED: return {
+			...base,
+			state: "refunded",
+			reason: refundReason(result.reason),
+			finishedAtMs: result.finished_at_ms,
+			positionBackAsOpenRecord: false,
+			position: null,
+			sellable: false,
+			parkedRaw
+		};
+		case ORDER_STATUS.CLOSED:
+			if (base.side === "sell" && result.reason === 0 && result.quantity > 0n) return {
+				...base,
+				state: "filled",
+				quantityRaw: result.quantity,
+				amountRaw: result.amount,
+				finishedAtMs: result.finished_at_ms,
+				position: null,
+				sellable: false,
+				parkedRaw
+			};
+			return {
+				...base,
+				state: "closed",
+				quantityRaw: result.quantity,
+				amountRaw: result.amount,
+				finishedAtMs: result.finished_at_ms,
+				parkedRaw
+			};
+		default: return {
+			...base,
+			state: "unknown"
+		};
+	}
+}
+/**
+* Fold decoded queue events (in chain order) into per-record states, keyed `marketId:recordId`.
+* The app shows Placed from the enqueue's own effects, Priced at the cohort commit, and switches to
+* Filled or Refunded on `QueuedOrderFilled` / `QueuedOrderRefunded`. Events for records that never
+* appeared enqueued still create an entry, so a partial event window works.
+*/
+function reduceOrderEvents(events, into = /* @__PURE__ */ new Map()) {
+	const entry = (marketId, recordId) => {
+		const key = `${marketId}:${recordId}`;
+		let s = into.get(key);
+		if (!s) {
+			s = {
+				marketId,
+				recordId,
+				state: "placed",
+				kind: null,
+				tauMs: null,
+				deadlineMs: null,
+				price: null,
+				tickMs: null,
+				reason: null,
+				position: null,
+				sourceRecordId: null,
+				payoutRaw: null,
+				payoutSkipped: false,
+				parkedRaw: 0n
+			};
+			into.set(key, s);
+		}
+		return s;
+	};
+	for (const e of events) switch (e.type) {
+		case "enqueued": {
+			const s = entry(e.marketId, e.recordId);
+			s.kind = e.kind;
+			s.tauMs = e.timing.tauMs;
+			s.deadlineMs = e.timing.deadlineMs;
+			s.position = e.position;
+			s.sourceRecordId = e.sourceRecordId;
+			if (e.sourceRecordId != null) {
+				const source = entry(e.marketId, e.sourceRecordId);
+				source.state = "closed";
+				source.position = null;
+			}
+			break;
+		}
+		case "cohort-committed":
+			for (const s of into.values()) if (s.marketId === e.marketId && s.state === "placed" && s.recordId >= e.firstRecordId && s.recordId <= e.lastRecordId) {
+				s.state = "priced";
+				s.price = e.price;
+				s.tickMs = e.tickMs;
+			}
+			break;
+		case "filled": {
+			const s = entry(e.marketId, e.recordId);
+			s.state = "filled";
+			s.kind = e.kind;
+			s.tickMs = e.tickMs;
+			s.position = e.position;
+			break;
+		}
+		case "refunded": {
+			const s = entry(e.marketId, e.recordId);
+			s.state = "refunded";
+			s.kind = e.kind;
+			s.reason = e.reason;
+			if (!e.positionReturned) s.position = null;
+			break;
+		}
+		case "open-record-settled": {
+			const s = entry(e.marketId, e.recordId);
+			s.state = "settled";
+			s.payoutRaw = e.raw.payout;
+			s.payoutSkipped = false;
+			s.position = null;
+			break;
+		}
+		case "open-record-payout-skipped": {
+			const s = entry(e.marketId, e.recordId);
+			s.payoutSkipped = true;
+			break;
+		}
+		case "record-funds-parked": {
+			const s = entry(e.marketId, e.recordId);
+			s.parkedRaw += e.raw.amount;
+			break;
+		}
+		case "record-funds-claimed": {
+			const s = entry(e.marketId, e.recordId);
+			s.parkedRaw = 0n;
+			break;
+		}
+		default: break;
+	}
+	return into;
+}
+function min(a, b) {
+	return a < b ? a : b;
+}
+function max(a, b) {
+	return a > b ? a : b;
+}
+
+//#endregion
+export { DELAYED_EXECUTION_VERSION, ORDER_FLOW_PACKAGE_VERSION, ORDER_KIND, ORDER_STATUS, PREDICT_PACKAGE_VERSION, budgetMintLimits, cashNeedSell, channelTickMs, exactMintLimits, feeCovered, isMintKind, isSellKind, maxMintNow, mintBudget, mintCashNeed, orderKindName, orderView, policyFromBcs, previewTiming, queue_exports, refundReason, sellLimits, slippageBand };
+//# sourceMappingURL=queue.mjs.map