Skip to main content

nautilus_polymarket/execution/
order_builder.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Order builder for the Polymarket CLOB exchange.
17//!
18//! Centralizes all order construction logic:
19//! - Limit and market order building
20//! - Order validation (side, TIF, quote_quantity)
21//! - EIP-712 signing
22//! - Maker/taker amount computation
23//!
24//! Amounts are converted from human-readable decimals to on-chain base units
25//! (pUSD 10^6 / CTF shares 10^6) by truncating to `USDC_DECIMALS` (6) decimal
26//! places and extracting the mantissa as an integer.
27//!
28//! The builder produces signed [`PolymarketOrder`] structs ready for HTTP submission.
29
30use std::sync::atomic::{AtomicU64, Ordering};
31
32use nautilus_core::{UnixNanos, string::secret::SecretString, time::get_atomic_clock_realtime};
33use nautilus_model::{
34    enums::{OrderSide, OrderType, TimeInForce},
35    events::OrderDeniedReason,
36    identifiers::VenueOrderId,
37    orders::{Order, OrderAny},
38    types::Price,
39};
40use rust_decimal::Decimal;
41use ustr::Ustr;
42
43use crate::{
44    common::{
45        consts::{
46            LOT_SIZE_SCALE, POLYMARKET_NAUTILUS_BUILDER_CODE, POLYMARKET_PRICE_PRECISION,
47            USDC_DECIMALS,
48        },
49        enums::{PolymarketOrderSide, PolymarketOrderType, PolymarketSignatureType},
50    },
51    http::models::PolymarketOrder,
52    signing::eip712::{OrderSigner, OrderSigningContext, order_hash_with_context},
53};
54
55/// Zero `bytes32` used for the `metadata` field (reserved for future use).
56pub const ZERO_BYTES32: &str = "0x0000000000000000000000000000000000000000000000000000000000000000";
57
58// Matches the official Polymarket SDK's minimum accepted GTD horizon.
59const GTD_EXPIRATION_BUFFER_SECS: u64 = 180;
60
61/// Builds signed Polymarket orders for submission to the CLOB V2 exchange.
62///
63/// `last_timestamp_ms` backs a strictly-monotonic millisecond clock so that
64/// bursts of submissions landing in the same wall-clock millisecond still
65/// produce distinct `timestamp` values (the V2 per-address uniqueness field).
66#[derive(Debug)]
67pub struct PolymarketOrderBuilder {
68    order_signer: OrderSigner,
69    signer_address: String,
70    maker_address: String,
71    signature_type: PolymarketSignatureType,
72    last_timestamp_ms: AtomicU64,
73}
74
75impl PolymarketOrderBuilder {
76    /// Creates a new [`PolymarketOrderBuilder`].
77    pub fn new(
78        order_signer: OrderSigner,
79        signer_address: String,
80        maker_address: String,
81        signature_type: PolymarketSignatureType,
82    ) -> Self {
83        Self {
84            order_signer,
85            signer_address,
86            maker_address,
87            signature_type,
88            last_timestamp_ms: AtomicU64::new(0),
89        }
90    }
91
92    // Returns a strictly-monotonic millisecond timestamp: the current wall
93    // time in ms, or `last_seen + 1` if that would be larger. Thread-safe.
94    fn next_timestamp_ms(&self) -> u64 {
95        let now_ms = get_atomic_clock_realtime().get_time_ns().as_u64() / 1_000_000;
96
97        loop {
98            let prev = self.last_timestamp_ms.load(Ordering::Relaxed);
99            let candidate = prev.saturating_add(1).max(now_ms);
100
101            if self
102                .last_timestamp_ms
103                .compare_exchange_weak(prev, candidate, Ordering::Relaxed, Ordering::Relaxed)
104                .is_ok()
105            {
106                return candidate;
107            }
108        }
109    }
110
111    /// Builds and signs a limit order for submission.
112    ///
113    /// Immediate BUYs spend a cent-denominated maker budget. When `quantity * price` is not an
114    /// exact cent amount, the builder truncates that budget to cents and signs the share quantity
115    /// derived from it, rounded down to the market amount precision so the order can cross at
116    /// the limit price. The signed ratio must remain below the next supported price tick.
117    ///
118    /// `expiration` is the GTD expiry, or `None` for no expiry. It is serialized as whole Unix
119    /// seconds (`"0"` when absent), truncating subsecond precision, and excluded from the signed
120    /// hash.
121    #[expect(clippy::too_many_arguments)]
122    pub fn build_limit_order(
123        &self,
124        token_id: &str,
125        side: PolymarketOrderSide,
126        price: Decimal,
127        quantity: Decimal,
128        order_type: PolymarketOrderType,
129        expiration: Option<UnixNanos>,
130        neg_risk: bool,
131        tick_decimals: u32,
132    ) -> anyhow::Result<PolymarketOrder> {
133        self.build_limit_order_with_context(
134            token_id,
135            side,
136            price,
137            quantity,
138            order_type,
139            expiration,
140            OrderSigningContext::ctf(neg_risk),
141            tick_decimals,
142        )
143    }
144
145    #[expect(clippy::too_many_arguments)]
146    pub(crate) fn build_limit_order_with_context(
147        &self,
148        token_id: &str,
149        side: PolymarketOrderSide,
150        price: Decimal,
151        quantity: Decimal,
152        order_type: PolymarketOrderType,
153        expiration: Option<UnixNanos>,
154        context: OrderSigningContext,
155        tick_decimals: u32,
156    ) -> anyhow::Result<PolymarketOrder> {
157        let (maker_amount, taker_amount) =
158            limit_order_maker_taker_amounts(side, price, quantity, order_type, tick_decimals)
159                .map_err(anyhow::Error::msg)?;
160        self.build_and_sign(
161            token_id,
162            side,
163            maker_amount,
164            taker_amount,
165            expiration,
166            context,
167        )
168    }
169
170    /// Builds and signs a collateral-sized limit BUY for submission.
171    ///
172    /// `amount` is the pUSD collateral to spend. The signed maker amount is the collateral after
173    /// venue-required cent quantization, and the taker amount is the share quantity derived from
174    /// that exact signed amount.
175    pub(crate) fn build_limit_order_from_collateral(
176        &self,
177        token_id: &str,
178        price: Decimal,
179        amount: Decimal,
180        expiration: Option<UnixNanos>,
181        context: OrderSigningContext,
182        tick_decimals: u32,
183    ) -> anyhow::Result<PolymarketOrder> {
184        anyhow::ensure!(
185            price > Decimal::ZERO,
186            "Polymarket collateral-sized limit BUY price must be positive"
187        );
188
189        let (maker_amount, taker_amount) =
190            compute_quote_buy_maker_taker_amounts(price, amount, tick_decimals);
191        anyhow::ensure!(
192            maker_amount > Decimal::ZERO,
193            "Polymarket collateral-sized limit BUY amount {} pUSD truncates to zero at {LOT_SIZE_SCALE} decimal places",
194            amount.normalize(),
195        );
196        anyhow::ensure!(
197            taker_amount > Decimal::ZERO,
198            "Polymarket collateral-sized limit BUY derives a zero share quantity"
199        );
200        anyhow::ensure!(
201            taker_amount * price == maker_amount,
202            "Polymarket collateral-sized limit BUY amount {} pUSD cannot preserve limit price {} after venue quantization",
203            amount.normalize(),
204            price.normalize(),
205        );
206
207        self.build_and_sign(
208            token_id,
209            PolymarketOrderSide::Buy,
210            maker_amount,
211            taker_amount,
212            expiration,
213            context,
214        )
215    }
216
217    /// Builds and signs a market order for submission.
218    ///
219    /// `amount` semantics differ by side:
220    /// - BUY: `amount` is pUSD to spend
221    /// - SELL: `amount` is shares to sell
222    ///
223    /// Market orders never set an expiration.
224    pub fn build_market_order(
225        &self,
226        token_id: &str,
227        side: PolymarketOrderSide,
228        price: Decimal,
229        amount: Decimal,
230        neg_risk: bool,
231        tick_decimals: u32,
232    ) -> anyhow::Result<PolymarketOrder> {
233        self.build_market_order_with_context(
234            token_id,
235            side,
236            price,
237            amount,
238            OrderSigningContext::ctf(neg_risk),
239            tick_decimals,
240        )
241    }
242
243    pub(crate) fn build_market_order_with_context(
244        &self,
245        token_id: &str,
246        side: PolymarketOrderSide,
247        price: Decimal,
248        amount: Decimal,
249        context: OrderSigningContext,
250        tick_decimals: u32,
251    ) -> anyhow::Result<PolymarketOrder> {
252        if side == PolymarketOrderSide::Buy && amount.trunc_with_scale(LOT_SIZE_SCALE).is_zero() {
253            anyhow::bail!(
254                "Polymarket market BUY amount {} pUSD truncates to zero at {LOT_SIZE_SCALE} decimal places",
255                amount.normalize(),
256            );
257        }
258
259        let (maker_amount, taker_amount) =
260            compute_market_maker_taker_amounts(price, amount, side, tick_decimals);
261        if side == PolymarketOrderSide::Buy {
262            validate_buy_price_rounding(price, maker_amount, taker_amount)
263                .map_err(anyhow::Error::msg)?;
264        }
265        self.build_and_sign(token_id, side, maker_amount, taker_amount, None, context)
266    }
267
268    /// Computes the Polymarket order ID for a signed CLOB V2 order.
269    pub fn expected_order_id(
270        &self,
271        order: &PolymarketOrder,
272        neg_risk: bool,
273    ) -> anyhow::Result<VenueOrderId> {
274        self.expected_order_id_with_context(order, OrderSigningContext::ctf(neg_risk))
275    }
276
277    pub(crate) fn expected_order_id_with_context(
278        &self,
279        order: &PolymarketOrder,
280        context: OrderSigningContext,
281    ) -> anyhow::Result<VenueOrderId> {
282        let hash = order_hash_with_context(order, context)
283            .map_err(|e| anyhow::anyhow!("Failed to derive order hash: {e}"))?;
284        let order_id = format!("{hash:#x}");
285        Ok(VenueOrderId::from(order_id.as_str()))
286    }
287
288    /// Validates a limit order before building, returning a denial reason if invalid.
289    pub fn validate_limit_order(order: &OrderAny) -> Result<(), OrderDeniedReason> {
290        if order.is_reduce_only() {
291            return Err(validation_failed(
292                "Reduce-only orders not supported on Polymarket",
293            ));
294        }
295
296        if order.order_type() != OrderType::Limit {
297            return Err(OrderDeniedReason::UnsupportedOrderType {
298                order_type: order.order_type(),
299            });
300        }
301
302        if order.is_quote_quantity() && order.order_side() == OrderSide::Sell {
303            return Err(OrderDeniedReason::unsupported_quote_quantity());
304        }
305
306        let quantity = signed_limit_order_quantity(order.quantity().as_decimal());
307        if quantity.is_zero() {
308            let denomination = if order.is_quote_quantity() {
309                "pUSD"
310            } else {
311                "shares"
312            };
313            return Err(validation_failed(format!(
314                "Polymarket limit order amount {} {denomination} truncates to zero at {LOT_SIZE_SCALE} decimal places",
315                order.quantity(),
316            )));
317        }
318
319        let price = order
320            .price()
321            .ok_or_else(|| validation_failed("Limit orders require a price"))?;
322
323        let order_type = PolymarketOrderType::try_from(order.time_in_force())
324            .map_err(|_| OrderDeniedReason::UnsupportedTimeInForce(order.time_in_force()))?;
325
326        let side = PolymarketOrderSide::from(order.order_side());
327
328        if order.is_post_only()
329            && !matches!(order.time_in_force(), TimeInForce::Gtc | TimeInForce::Gtd)
330        {
331            return Err(OrderDeniedReason::unsupported_post_only());
332        }
333
334        if !order.is_quote_quantity()
335            && side == PolymarketOrderSide::Buy
336            && matches!(
337                order_type,
338                PolymarketOrderType::FAK | PolymarketOrderType::FOK
339            )
340        {
341            let notional = quantity * price.as_decimal();
342            if notional.trunc_with_scale(LOT_SIZE_SCALE).is_zero() {
343                return Err(validation_failed(format!(
344                    "Polymarket {order_type} BUY maker amount {} pUSD truncates to zero at {LOT_SIZE_SCALE} decimal places",
345                    notional.normalize(),
346                )));
347            }
348        }
349
350        Ok(())
351    }
352
353    pub(crate) fn validate_limit_price(
354        order: &OrderAny,
355        tick_size: Price,
356    ) -> Result<(), OrderDeniedReason> {
357        let price = order
358            .price()
359            .ok_or_else(|| validation_failed("Limit orders require a price"))?;
360        Self::validate_limit_price_value(price, tick_size)
361    }
362
363    pub(crate) fn validate_limit_price_value(
364        price: Price,
365        tick_size: Price,
366    ) -> Result<(), OrderDeniedReason> {
367        let tick = tick_size.as_decimal();
368        let price_decimal = price.as_decimal();
369
370        validate_price(price_decimal, tick, "Limit order price", &price.to_string())
371            .map_err(validation_failed)
372    }
373
374    pub(crate) fn validate_limit_expiration(
375        order: &OrderAny,
376        ts_now: UnixNanos,
377    ) -> Result<(), OrderDeniedReason> {
378        if order.time_in_force() != TimeInForce::Gtd {
379            return Ok(());
380        }
381
382        let expire_time = order
383            .expire_time()
384            .filter(|expire_time| !expire_time.is_zero())
385            .ok_or(OrderDeniedReason::MissingExpireTime)?;
386        let now_secs = ts_now.as_seconds();
387        let expire_secs = expire_time.as_seconds();
388        let minimum_expire_secs = now_secs.saturating_add(GTD_EXPIRATION_BUFFER_SECS);
389
390        if expire_secs < minimum_expire_secs {
391            return Err(validation_failed(format!(
392                "Polymarket GTD expiry must be at least {GTD_EXPIRATION_BUFFER_SECS} seconds in the future"
393            )));
394        }
395
396        Ok(())
397    }
398
399    /// Validates a market order before building, returning a denial reason if invalid.
400    pub fn validate_market_order(order: &OrderAny) -> Result<(), OrderDeniedReason> {
401        if order.is_reduce_only() {
402            return Err(validation_failed(
403                "Reduce-only orders not supported on Polymarket",
404            ));
405        }
406
407        if order.order_type() != OrderType::Market {
408            return Err(OrderDeniedReason::UnsupportedOrderType {
409                order_type: order.order_type(),
410            });
411        }
412
413        // BUY market orders must use quote_quantity (amount in pUSD)
414        // SELL market orders must NOT use quote_quantity (amount in shares)
415        match order.order_side() {
416            OrderSide::Buy => {
417                if !order.is_quote_quantity() {
418                    return Err(validation_failed(
419                        "Market BUY orders require quote_quantity=true (amount in pUSD)",
420                    ));
421                }
422            }
423            OrderSide::Sell => {
424                if order.is_quote_quantity() {
425                    return Err(OrderDeniedReason::unsupported_quote_quantity());
426                }
427            }
428        }
429
430        if PolymarketOrderType::from_market_time_in_force(order.time_in_force()).is_err() {
431            return Err(OrderDeniedReason::UnsupportedTimeInForce(
432                order.time_in_force(),
433            ));
434        }
435
436        Ok(())
437    }
438
439    pub(crate) fn normalize_market_price(
440        price: Decimal,
441        tick_size: Price,
442        tick_decimals: u32,
443    ) -> Result<Decimal, String> {
444        let tick = tick_size.as_decimal();
445        let price = price.trunc_with_scale(tick_decimals);
446
447        validate_price(
448            price,
449            tick,
450            "Derived market price",
451            &price.normalize().to_string(),
452        )?;
453
454        Ok(price)
455    }
456
457    fn build_and_sign(
458        &self,
459        token_id: &str,
460        side: PolymarketOrderSide,
461        maker_amount: Decimal,
462        taker_amount: Decimal,
463        expiration: Option<UnixNanos>,
464        context: OrderSigningContext,
465    ) -> anyhow::Result<PolymarketOrder> {
466        let salt = generate_salt();
467        let timestamp_ms = self.next_timestamp_ms();
468
469        let mut poly_order = PolymarketOrder {
470            salt,
471            maker: self.maker_address.clone(),
472            signer: self.order_signer_address(),
473            token_id: Ustr::from(token_id),
474            maker_amount,
475            taker_amount,
476            side,
477            signature_type: self.signature_type,
478            expiration: expiration.map_or(0, |time| time.as_seconds()).to_string(),
479            timestamp: timestamp_ms.to_string(),
480            metadata: ZERO_BYTES32.to_string(),
481            builder: POLYMARKET_NAUTILUS_BUILDER_CODE.to_string(),
482            signature: SecretString::default(),
483        };
484
485        let signature = self
486            .order_signer
487            .sign_order_with_context(&poly_order, context)
488            .map_err(|e| anyhow::anyhow!("EIP-712 signing failed: {e}"))?;
489        poly_order.signature = SecretString::from(signature);
490
491        Ok(poly_order)
492    }
493
494    fn order_signer_address(&self) -> String {
495        match self.signature_type {
496            PolymarketSignatureType::Poly1271 => self.maker_address.clone(),
497            _ => self.signer_address.clone(),
498        }
499    }
500}
501
502fn validation_failed(detail: impl Into<String>) -> OrderDeniedReason {
503    OrderDeniedReason::ValidationFailed {
504        detail: detail.into(),
505    }
506}
507
508fn validate_price(
509    price: Decimal,
510    tick: Decimal,
511    label: &str,
512    price_display: &str,
513) -> Result<(), String> {
514    let tick = tick.normalize();
515    let max_price = Decimal::ONE - tick;
516
517    if price < tick || price > max_price {
518        return Err(format!(
519            "{label} {price_display} outside Polymarket range [{tick}, {max_price}]"
520        ));
521    }
522
523    if price % tick != Decimal::ZERO {
524        return Err(format!(
525            "{label} {price_display} does not conform to Polymarket tick size {tick}"
526        ));
527    }
528
529    Ok(())
530}
531
532fn to_fixed_decimal(d: Decimal) -> Decimal {
533    let mantissa = d.normalize().trunc_with_scale(USDC_DECIMALS).mantissa();
534    Decimal::from(mantissa)
535}
536
537/// Returns the share quantity encoded into a signed limit order.
538pub(crate) fn signed_limit_order_quantity(quantity: Decimal) -> Decimal {
539    quantity.trunc_with_scale(LOT_SIZE_SCALE)
540}
541
542/// Returns the human share quantity [`PolymarketOrderBuilder::build_limit_order`] would sign.
543///
544/// # Errors
545///
546/// Returns an error if an immediate buy cannot derive safe signed amounts.
547pub(crate) fn posted_limit_share_quantity(
548    side: PolymarketOrderSide,
549    price: Decimal,
550    quantity: Decimal,
551    order_type: PolymarketOrderType,
552    tick_decimals: u32,
553) -> Result<Decimal, String> {
554    let (maker_amount, taker_amount) =
555        limit_order_maker_taker_amounts(side, price, quantity, order_type, tick_decimals)?;
556    Ok(signed_base_quantity(maker_amount, taker_amount, side))
557}
558
559/// Signs an immediate base-sized BUY as a cent budget plus derived shares.
560///
561/// Polymarket treats `FAK` and `FOK` as market orders: the direct maker amount is limited to
562/// two decimal places, and the computed share amount uses the market amount precision. Rounding
563/// the derived shares down allows matching at the limit, provided no higher price tick is reachable.
564fn immediate_buy_maker_taker_amounts(
565    price: Decimal,
566    quantity: Decimal,
567    order_type: PolymarketOrderType,
568    tick_decimals: u32,
569) -> Result<(Decimal, Decimal), String> {
570    let quantity = signed_limit_order_quantity(quantity);
571    let notional = quantity * price;
572    let maker_amount = notional.trunc_with_scale(LOT_SIZE_SCALE);
573    if maker_amount.is_zero() {
574        return Err(format!(
575            "Polymarket {order_type} BUY maker amount {} pUSD truncates to zero at {LOT_SIZE_SCALE} decimal places",
576            notional.normalize(),
577        ));
578    }
579
580    let (maker_amount, taker_amount) =
581        compute_quote_buy_maker_taker_amounts(price, maker_amount, tick_decimals);
582    validate_buy_price_rounding(price, maker_amount, taker_amount)?;
583
584    Ok((maker_amount, taker_amount))
585}
586
587/// Validates a BUY's signed base-unit amounts against the next supported price tick.
588fn validate_buy_price_rounding(
589    price: Decimal,
590    maker_amount: Decimal,
591    taker_amount: Decimal,
592) -> Result<(), String> {
593    if maker_amount <= Decimal::ZERO || taker_amount <= Decimal::ZERO {
594        return Err("Polymarket BUY requires positive signed maker and taker amounts".to_string());
595    }
596
597    // Use the finest supported tick even when cached instrument metadata has a coarser tick,
598    // so a tick-size refinement cannot let the order match above the requested limit.
599    let next_price = price + Decimal::new(1, u32::from(POLYMARKET_PRICE_PRECISION));
600    if maker_amount >= taker_amount * next_price {
601        return Err(format!(
602            "Polymarket BUY signed amounts can match above limit price {} after venue quantization",
603            price.normalize(),
604        ));
605    }
606
607    Ok(())
608}
609
610/// Builds the maker/taker amounts for a Polymarket CLOB limit order.
611///
612/// The CLOB enforces precision constraints on both amounts:
613/// - Direct amounts (quantity passed through): max `LOT_SIZE_SCALE` (2) decimal places
614/// - Computed amounts (quantity * price): max `tick_decimals + LOT_SIZE_SCALE` decimal places
615///
616/// For BUY: paying pUSD (maker, computed) to receive CTF shares (taker, direct)
617/// For SELL: paying CTF shares (maker, direct) to receive pUSD (taker, computed)
618pub fn compute_maker_taker_amounts(
619    price: Decimal,
620    quantity: Decimal,
621    side: PolymarketOrderSide,
622    tick_decimals: u32,
623) -> (Decimal, Decimal) {
624    let precision = tick_decimals + LOT_SIZE_SCALE;
625    let qty = signed_limit_order_quantity(quantity);
626
627    match side {
628        PolymarketOrderSide::Buy => {
629            let maker_amount = to_fixed_decimal((qty * price).trunc_with_scale(precision));
630            let taker_amount = to_fixed_decimal(qty);
631            (maker_amount, taker_amount)
632        }
633        PolymarketOrderSide::Sell => {
634            let maker_amount = to_fixed_decimal(qty);
635            let taker_amount = to_fixed_decimal((qty * price).trunc_with_scale(precision));
636            (maker_amount, taker_amount)
637        }
638    }
639}
640
641fn limit_order_maker_taker_amounts(
642    side: PolymarketOrderSide,
643    price: Decimal,
644    quantity: Decimal,
645    order_type: PolymarketOrderType,
646    tick_decimals: u32,
647) -> Result<(Decimal, Decimal), String> {
648    if side == PolymarketOrderSide::Buy
649        && matches!(
650            order_type,
651            PolymarketOrderType::FAK | PolymarketOrderType::FOK
652        )
653    {
654        immediate_buy_maker_taker_amounts(price, quantity, order_type, tick_decimals)
655    } else {
656        Ok(compute_maker_taker_amounts(
657            price,
658            quantity,
659            side,
660            tick_decimals,
661        ))
662    }
663}
664
665pub(super) fn signed_base_quantity(
666    maker_amount: Decimal,
667    taker_amount: Decimal,
668    side: PolymarketOrderSide,
669) -> Decimal {
670    let share_scale = Decimal::from(1_000_000u32);
671    match side {
672        PolymarketOrderSide::Buy => taker_amount / share_scale,
673        PolymarketOrderSide::Sell => maker_amount / share_scale,
674    }
675}
676
677/// Builds maker/taker amounts for a Polymarket market order.
678///
679/// Same precision constraints as limit orders. The direct amount is truncated to
680/// `LOT_SIZE_SCALE` decimal places before conversion (market order amounts like
681/// position sizes from fills may have more decimal places than the CLOB allows).
682///
683/// Unlike limit orders where quantity always means shares, market order semantics differ by side:
684/// - BUY: `amount` is pUSD to spend, compute shares received
685/// - SELL: `amount` is shares to sell, compute pUSD received
686pub fn compute_market_maker_taker_amounts(
687    price: Decimal,
688    amount: Decimal,
689    side: PolymarketOrderSide,
690    tick_decimals: u32,
691) -> (Decimal, Decimal) {
692    match side {
693        PolymarketOrderSide::Buy => {
694            compute_quote_buy_maker_taker_amounts(price, amount, tick_decimals)
695        }
696        PolymarketOrderSide::Sell => {
697            compute_maker_taker_amounts(price, amount, side, tick_decimals)
698        }
699    }
700}
701
702fn compute_quote_buy_maker_taker_amounts(
703    price: Decimal,
704    amount: Decimal,
705    tick_decimals: u32,
706) -> (Decimal, Decimal) {
707    let precision = tick_decimals + LOT_SIZE_SCALE;
708    let maker_amount = amount.trunc_with_scale(LOT_SIZE_SCALE);
709    let taker_amount = (maker_amount / price).trunc_with_scale(precision);
710    (
711        to_fixed_decimal(maker_amount),
712        to_fixed_decimal(taker_amount),
713    )
714}
715
716/// Generates a random salt for order construction.
717///
718/// UUID v4 always produces 16 bytes, so converting the 8-byte slice cannot panic.
719#[allow(
720    clippy::missing_panics_doc,
721    reason = "a UUID always contains enough bytes for the 8-byte slice"
722)]
723pub fn generate_salt() -> u64 {
724    let bytes = uuid::Uuid::new_v4().into_bytes();
725    u64::from_le_bytes(bytes[..8].try_into().unwrap()) & ((1u64 << 53) - 1)
726}
727
728#[cfg(test)]
729mod tests {
730    use nautilus_core::UUID4;
731    use nautilus_model::{
732        enums::{OrderSide, OrderType, TimeInForce},
733        identifiers::{ClientOrderId, InstrumentId, StrategyId, TraderId},
734        orders::{LimitOrder, MarketOrder, OrderAny},
735        types::{Price, Quantity},
736    };
737    use rstest::rstest;
738    use rust_decimal::Decimal;
739    use rust_decimal_macros::dec;
740
741    use super::*;
742    use crate::{
743        common::{credential::EvmPrivateKey, enums::PolymarketOrderSide},
744        execution::parse::adjust_market_buy_amount,
745        signing::eip712::OrderSigner,
746    };
747
748    fn make_limit(
749        reduce_only: bool,
750        quote_quantity: bool,
751        post_only: bool,
752        tif: TimeInForce,
753    ) -> OrderAny {
754        make_limit_at_price(
755            reduce_only,
756            quote_quantity,
757            post_only,
758            tif,
759            Price::from("0.50"),
760        )
761    }
762
763    fn make_limit_at_price(
764        reduce_only: bool,
765        quote_quantity: bool,
766        post_only: bool,
767        tif: TimeInForce,
768        price: Price,
769    ) -> OrderAny {
770        make_limit_with_quantity(
771            OrderSide::Buy,
772            Quantity::from("10"),
773            reduce_only,
774            quote_quantity,
775            post_only,
776            tif,
777            price,
778        )
779    }
780
781    fn make_limit_with_quantity(
782        side: OrderSide,
783        quantity: Quantity,
784        reduce_only: bool,
785        quote_quantity: bool,
786        post_only: bool,
787        tif: TimeInForce,
788        price: Price,
789    ) -> OrderAny {
790        let expire_time = if tif == TimeInForce::Gtd {
791            Some(UnixNanos::from(2_000_000_000_000_000_000u64))
792        } else {
793            None
794        };
795        OrderAny::Limit(LimitOrder::new(
796            TraderId::from("TESTER-001"),
797            StrategyId::from("S-001"),
798            InstrumentId::from("TEST.POLYMARKET"),
799            ClientOrderId::from("O-001"),
800            side,
801            quantity,
802            price,
803            tif,
804            expire_time,
805            post_only,
806            reduce_only,
807            quote_quantity,
808            None,
809            None,
810            None,
811            None,
812            None,
813            None,
814            None,
815            None,
816            None,
817            None,
818            None,
819            UUID4::new(),
820            UnixNanos::default(),
821        ))
822    }
823
824    fn with_expire_time(mut order: OrderAny, expire_time: Option<UnixNanos>) -> OrderAny {
825        let OrderAny::Limit(limit) = &mut order else {
826            unreachable!("test order is limit")
827        };
828        limit.expire_time = expire_time;
829        order
830    }
831
832    fn make_market(side: OrderSide, quote_quantity: bool) -> OrderAny {
833        OrderAny::Market(MarketOrder::new(
834            TraderId::from("TESTER-001"),
835            StrategyId::from("S-001"),
836            InstrumentId::from("TEST.POLYMARKET"),
837            ClientOrderId::from("O-001"),
838            side,
839            Quantity::from("10"),
840            TimeInForce::Ioc,
841            UUID4::new(),
842            UnixNanos::default(),
843            false,
844            quote_quantity,
845            None,
846            None,
847            None,
848            None,
849            None,
850            None,
851            None,
852            None,
853        ))
854    }
855
856    #[rstest]
857    fn test_validate_limit_order_valid() {
858        let order = make_limit(false, false, false, TimeInForce::Gtc);
859        assert!(PolymarketOrderBuilder::validate_limit_order(&order).is_ok());
860    }
861
862    #[rstest]
863    #[case("0.000", "0.001", "0.001", "0.999")]
864    #[case("1.000", "0.001", "0.001", "0.999")]
865    #[case("0.0000", "0.0001", "0.0001", "0.9999")]
866    #[case("1.0000", "0.0001", "0.0001", "0.9999")]
867    fn test_validate_limit_order_price_out_of_range_denied(
868        #[case] price: &str,
869        #[case] tick_size: &str,
870        #[case] min_price: &str,
871        #[case] max_price: &str,
872    ) {
873        let order = make_limit_at_price(false, false, false, TimeInForce::Gtc, Price::from(price));
874        let err = PolymarketOrderBuilder::validate_limit_price(&order, Price::from(tick_size))
875            .unwrap_err();
876        assert_eq!(
877            err,
878            OrderDeniedReason::ValidationFailed {
879                detail: format!(
880                    "Limit order price {price} outside Polymarket range [{min_price}, {max_price}]"
881                ),
882            }
883        );
884    }
885
886    #[rstest]
887    #[case("0.001", "0.001")]
888    #[case("0.999", "0.001")]
889    #[case("0.0001", "0.0001")]
890    #[case("0.9999", "0.0001")]
891    #[case("0.005", "0.005")]
892    #[case("0.995", "0.005")]
893    #[case("0.0025", "0.0025")]
894    #[case("0.9975", "0.0025")]
895    fn test_validate_limit_order_price_boundary_allowed(
896        #[case] price: &str,
897        #[case] tick_size: &str,
898    ) {
899        let order = make_limit_at_price(false, false, false, TimeInForce::Gtc, Price::from(price));
900        assert!(
901            PolymarketOrderBuilder::validate_limit_price(&order, Price::from(tick_size)).is_ok()
902        );
903    }
904
905    #[rstest]
906    #[case("0.505", "0.005")]
907    #[case("0.5025", "0.0025")]
908    fn test_validate_limit_order_price_aligned_allowed(
909        #[case] price: &str,
910        #[case] tick_size: &str,
911    ) {
912        let order = make_limit_at_price(false, false, false, TimeInForce::Gtc, Price::from(price));
913        assert!(
914            PolymarketOrderBuilder::validate_limit_price(&order, Price::from(tick_size)).is_ok()
915        );
916    }
917
918    #[rstest]
919    #[case("0.501", "0.005")]
920    #[case("0.501", "0.0025")]
921    fn test_validate_limit_order_price_misaligned_denied(
922        #[case] price: &str,
923        #[case] tick_size: &str,
924    ) {
925        let order = make_limit_at_price(false, false, false, TimeInForce::Gtc, Price::from(price));
926        let error = PolymarketOrderBuilder::validate_limit_price(&order, Price::from(tick_size))
927            .unwrap_err();
928        assert_eq!(
929            error,
930            OrderDeniedReason::ValidationFailed {
931                detail: format!(
932                    "Limit order price {price} does not conform to Polymarket tick size {tick_size}"
933                ),
934            }
935        );
936    }
937
938    #[rstest]
939    #[case::half_cent("0.5059", "0.005", 3, dec!(0.505))]
940    #[case::half_cent_p4("0.5059", "0.0050", 3, dec!(0.505))]
941    #[case::quarter_cent("0.50259", "0.0025", 4, dec!(0.5025))]
942    fn test_normalize_market_price(
943        #[case] price: &str,
944        #[case] tick_size: &str,
945        #[case] tick_decimals: u32,
946        #[case] expected: Decimal,
947    ) {
948        let normalized = PolymarketOrderBuilder::normalize_market_price(
949            price.parse::<Decimal>().unwrap(),
950            Price::from(tick_size),
951            tick_decimals,
952        )
953        .unwrap();
954
955        assert_eq!(normalized, expected);
956    }
957
958    #[rstest]
959    #[case::below_range(
960        "0.0049",
961        "0.005",
962        "Derived market price 0.004 outside Polymarket range [0.005, 0.995]"
963    )]
964    #[case::above_range(
965        "1.0000",
966        "0.0025",
967        "Derived market price 1 outside Polymarket range [0.0025, 0.9975]"
968    )]
969    #[case::off_half_cent(
970        "0.5019",
971        "0.005",
972        "Derived market price 0.501 does not conform to Polymarket tick size 0.005"
973    )]
974    #[case::off_quarter_cent(
975        "0.50129",
976        "0.0025",
977        "Derived market price 0.5012 does not conform to Polymarket tick size 0.0025"
978    )]
979    fn test_normalize_market_price_denied(
980        #[case] price: &str,
981        #[case] tick_size: &str,
982        #[case] expected: &str,
983    ) {
984        let tick_size = Price::from(tick_size);
985        let error = PolymarketOrderBuilder::normalize_market_price(
986            price.parse().unwrap(),
987            tick_size,
988            u32::from(tick_size.precision),
989        )
990        .unwrap_err();
991
992        assert_eq!(error, expected);
993    }
994
995    #[rstest]
996    #[case::below(
997        1_700_000_179_999_999_999,
998        Some("Polymarket GTD expiry must be at least 180 seconds in the future")
999    )]
1000    #[case::equal(1_700_000_180_000_000_000, None)]
1001    #[case::above(1_700_000_181_000_000_000, None)]
1002    fn test_validate_limit_expiration_boundary(
1003        #[case] expire_ns: u64,
1004        #[case] expected_error: Option<&str>,
1005    ) {
1006        let order = with_expire_time(
1007            make_limit(false, false, false, TimeInForce::Gtd),
1008            Some(UnixNanos::from(expire_ns)),
1009        );
1010        let ts_now = UnixNanos::from(1_700_000_000_900_000_000u64);
1011
1012        let result = PolymarketOrderBuilder::validate_limit_expiration(&order, ts_now);
1013
1014        assert_eq!(
1015            result.err().map(|reason| reason.to_string()),
1016            expected_error.map(|detail| OrderDeniedReason::ValidationFailed {
1017                detail: detail.to_string(),
1018            }
1019            .to_string())
1020        );
1021    }
1022
1023    #[rstest]
1024    #[case::missing(None)]
1025    #[case::zero(Some(UnixNanos::default()))]
1026    fn test_validate_limit_expiration_requires_non_zero_expiry(
1027        #[case] expire_time: Option<UnixNanos>,
1028    ) {
1029        let order = with_expire_time(
1030            make_limit(false, false, false, TimeInForce::Gtd),
1031            expire_time,
1032        );
1033
1034        let error = PolymarketOrderBuilder::validate_limit_expiration(
1035            &order,
1036            UnixNanos::from(1_700_000_000_900_000_000u64),
1037        )
1038        .unwrap_err();
1039
1040        assert_eq!(error, OrderDeniedReason::MissingExpireTime);
1041    }
1042
1043    #[rstest]
1044    fn test_validate_limit_order_reduce_only_denied() {
1045        let order = make_limit(true, false, false, TimeInForce::Gtc);
1046        let err = PolymarketOrderBuilder::validate_limit_order(&order).unwrap_err();
1047        assert!(err.to_string().contains("Reduce-only"));
1048    }
1049
1050    #[rstest]
1051    fn test_validate_limit_order_quote_quantity_buy_allowed() {
1052        let order = make_limit(false, true, false, TimeInForce::Gtc);
1053        assert!(PolymarketOrderBuilder::validate_limit_order(&order).is_ok());
1054    }
1055
1056    #[rstest]
1057    fn test_validate_limit_order_quote_quantity_sell_denied() {
1058        let order = make_limit_with_quantity(
1059            OrderSide::Sell,
1060            Quantity::from("10"),
1061            false,
1062            true,
1063            false,
1064            TimeInForce::Gtc,
1065            Price::from("0.50"),
1066        );
1067        let err = PolymarketOrderBuilder::validate_limit_order(&order).unwrap_err();
1068        assert_eq!(err, OrderDeniedReason::unsupported_quote_quantity());
1069    }
1070
1071    #[rstest]
1072    #[case::base(false, "shares")]
1073    #[case::collateral(true, "pUSD")]
1074    fn test_validate_limit_order_denies_quantity_below_signing_minimum(
1075        #[case] quote_quantity: bool,
1076        #[case] denomination: &str,
1077    ) {
1078        let order = make_limit_with_quantity(
1079            OrderSide::Buy,
1080            Quantity::from("0.009"),
1081            false,
1082            quote_quantity,
1083            false,
1084            TimeInForce::Gtc,
1085            Price::from("0.50"),
1086        );
1087
1088        let err = PolymarketOrderBuilder::validate_limit_order(&order).unwrap_err();
1089
1090        assert_eq!(
1091            err,
1092            validation_failed(format!(
1093                "Polymarket limit order amount 0.009 {denomination} truncates to zero at 2 decimal places"
1094            ))
1095        );
1096    }
1097
1098    #[rstest]
1099    fn test_validate_limit_order_post_only_ioc_denied() {
1100        let order = make_limit(false, false, true, TimeInForce::Ioc);
1101        let err = PolymarketOrderBuilder::validate_limit_order(&order).unwrap_err();
1102        assert_eq!(err, OrderDeniedReason::unsupported_post_only());
1103    }
1104
1105    #[rstest]
1106    fn test_validate_limit_order_post_only_gtc_allowed() {
1107        let order = make_limit(false, false, true, TimeInForce::Gtc);
1108        assert!(PolymarketOrderBuilder::validate_limit_order(&order).is_ok());
1109    }
1110
1111    #[rstest]
1112    fn test_validate_market_order_buy_with_quote_qty() {
1113        let order = make_market(OrderSide::Buy, true);
1114        assert!(PolymarketOrderBuilder::validate_market_order(&order).is_ok());
1115    }
1116
1117    #[rstest]
1118    fn test_validate_market_order_buy_without_quote_qty_denied() {
1119        let order = make_market(OrderSide::Buy, false);
1120        let err = PolymarketOrderBuilder::validate_market_order(&order).unwrap_err();
1121        assert!(err.to_string().contains("quote_quantity=true"));
1122    }
1123
1124    #[rstest]
1125    fn test_validate_market_order_sell_without_quote_qty() {
1126        let order = make_market(OrderSide::Sell, false);
1127        assert!(PolymarketOrderBuilder::validate_market_order(&order).is_ok());
1128    }
1129
1130    #[rstest]
1131    fn test_validate_market_order_sell_with_quote_qty_denied() {
1132        let order = make_market(OrderSide::Sell, true);
1133        let err = PolymarketOrderBuilder::validate_market_order(&order).unwrap_err();
1134        assert_eq!(err, OrderDeniedReason::unsupported_quote_quantity());
1135    }
1136
1137    #[rstest]
1138    fn test_validate_market_order_wrong_type_denied() {
1139        // Passing a limit order to validate_market_order should fail with type mismatch
1140        let limit = make_limit(false, false, false, TimeInForce::Gtc);
1141        let err = PolymarketOrderBuilder::validate_market_order(&limit).unwrap_err();
1142        assert_eq!(
1143            err,
1144            OrderDeniedReason::UnsupportedOrderType {
1145                order_type: OrderType::Limit,
1146            }
1147        );
1148    }
1149
1150    fn make_test_builder() -> PolymarketOrderBuilder {
1151        let pk = EvmPrivateKey::new(
1152            "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
1153        )
1154        .unwrap();
1155        let signer = OrderSigner::new(&pk).unwrap();
1156        let addr = format!("{:#x}", signer.address());
1157        PolymarketOrderBuilder::new(signer, addr.clone(), addr, PolymarketSignatureType::Eoa)
1158    }
1159
1160    #[rstest]
1161    fn test_next_timestamp_ms_is_strictly_monotonic() {
1162        let builder = make_test_builder();
1163        let mut prev = builder.next_timestamp_ms();
1164        for _ in 0..1_000 {
1165            let next = builder.next_timestamp_ms();
1166            assert!(
1167                next > prev,
1168                "timestamp not strictly monotonic: {prev} >= {next}"
1169            );
1170            prev = next;
1171        }
1172    }
1173
1174    #[rstest]
1175    fn test_build_orders_produce_unique_timestamps() {
1176        let builder = make_test_builder();
1177        let mut timestamps = ahash::AHashSet::new();
1178
1179        for _ in 0..50 {
1180            let order = builder
1181                .build_limit_order(
1182                    "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1183                    PolymarketOrderSide::Buy,
1184                    dec!(0.50),
1185                    dec!(10),
1186                    PolymarketOrderType::GTC,
1187                    None,
1188                    false,
1189                    2,
1190                )
1191                .unwrap();
1192            assert!(
1193                timestamps.insert(order.timestamp.clone()),
1194                "duplicate timestamp {} in burst",
1195                order.timestamp,
1196            );
1197        }
1198    }
1199
1200    #[rstest]
1201    fn test_built_order_carries_nautilus_builder_code() {
1202        let builder = make_test_builder();
1203        let order = builder
1204            .build_limit_order(
1205                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1206                PolymarketOrderSide::Buy,
1207                dec!(0.50),
1208                dec!(10),
1209                PolymarketOrderType::GTC,
1210                None,
1211                false,
1212                2,
1213            )
1214            .unwrap();
1215        assert_eq!(order.builder, POLYMARKET_NAUTILUS_BUILDER_CODE);
1216    }
1217
1218    #[rstest]
1219    fn test_poly_1271_order_uses_deposit_wallet_as_signer() {
1220        let pk = EvmPrivateKey::new(
1221            "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
1222        )
1223        .unwrap();
1224        let signer = OrderSigner::new(&pk).unwrap();
1225        let signer_address = format!("{:#x}", signer.address());
1226        let deposit_wallet = "0x1111111111111111111111111111111111111111".to_string();
1227        let builder = PolymarketOrderBuilder::new(
1228            signer,
1229            signer_address,
1230            deposit_wallet.clone(),
1231            PolymarketSignatureType::Poly1271,
1232        );
1233
1234        let order = builder
1235            .build_limit_order(
1236                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1237                PolymarketOrderSide::Buy,
1238                dec!(0.50),
1239                dec!(10),
1240                PolymarketOrderType::GTC,
1241                None,
1242                false,
1243                2,
1244            )
1245            .unwrap();
1246
1247        assert_eq!(order.maker, deposit_wallet);
1248        assert_eq!(order.signer, deposit_wallet);
1249        assert_eq!(order.signature_type, PolymarketSignatureType::Poly1271);
1250        assert_eq!(order.signature.expose_secret().len(), 636);
1251    }
1252
1253    #[rstest]
1254    #[case::none(None, "0")]
1255    #[case::zero(Some(UnixNanos::from(0u64)), "0")]
1256    #[case::one_second(Some(UnixNanos::from_seconds(1)), "1")]
1257    #[case::subsecond_truncates(Some(UnixNanos::from(1_500_000_000u64)), "1")]
1258    #[case::typical(Some(UnixNanos::from_seconds(1_735_689_600)), "1735689600")]
1259    #[case::maximum(Some(UnixNanos::from(u64::MAX)), "18446744073")]
1260    fn test_build_limit_order_expiration(
1261        #[values("v1", "v2")] version: &str,
1262        #[case] expiration: Option<UnixNanos>,
1263        #[case] expected: &str,
1264    ) {
1265        let builder = make_test_builder();
1266        let context = OrderSigningContext::new(Some(version), false).unwrap();
1267        let token_id =
1268            "71321045679252212594626385532706912750332728571942532289631379312455583992563";
1269        let order = builder
1270            .build_limit_order_with_context(
1271                token_id,
1272                PolymarketOrderSide::Buy,
1273                dec!(0.50),
1274                dec!(10),
1275                PolymarketOrderType::GTD,
1276                expiration,
1277                context,
1278                2,
1279            )
1280            .unwrap();
1281        let collateral_order = builder
1282            .build_limit_order_from_collateral(
1283                token_id,
1284                dec!(0.50),
1285                dec!(5),
1286                expiration,
1287                context,
1288                2,
1289            )
1290            .unwrap();
1291
1292        assert_eq!(order.expiration, expected);
1293        assert_eq!(collateral_order.expiration, expected);
1294    }
1295
1296    #[rstest]
1297    fn test_build_limit_order_amount_matrix(
1298        #[values(1, 2, 3, 4)] tick_decimals: u32,
1299        #[values(PolymarketOrderSide::Buy, PolymarketOrderSide::Sell)] side: PolymarketOrderSide,
1300        #[values(
1301            PolymarketOrderType::GTC,
1302            PolymarketOrderType::GTD,
1303            PolymarketOrderType::FAK,
1304            PolymarketOrderType::FOK
1305        )]
1306        order_type: PolymarketOrderType,
1307    ) {
1308        let (price, quantity, notional) = match tick_decimals {
1309            1 => (dec!(0.5), dec!(10), dec!(5_000_000)),
1310            2 => (dec!(0.56), dec!(10), dec!(5_600_000)),
1311            3 => (dec!(0.961), dec!(10), dec!(9_610_000)),
1312            4 => (dec!(0.9612), dec!(25), dec!(24_030_000)),
1313            _ => unreachable!(),
1314        };
1315        let quantity_amount = to_fixed_decimal(quantity);
1316
1317        let expiration = if order_type == PolymarketOrderType::GTD {
1318            Some(UnixNanos::from_seconds(1_735_689_600))
1319        } else {
1320            None
1321        };
1322        let builder = make_test_builder();
1323
1324        let order = builder
1325            .build_limit_order(
1326                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1327                side,
1328                price,
1329                quantity,
1330                order_type,
1331                expiration,
1332                false,
1333                tick_decimals,
1334            )
1335            .unwrap();
1336
1337        let expected = match side {
1338            PolymarketOrderSide::Buy => (notional, quantity_amount),
1339            PolymarketOrderSide::Sell => (quantity_amount, notional),
1340        };
1341        assert_eq!((order.maker_amount, order.taker_amount), expected);
1342    }
1343
1344    #[rstest]
1345    #[case::cent_tick(dec!(0.56), dec!(10.089), 2, dec!(10_080_000), dec!(18_000_000))]
1346    #[case::half_cent_tick(
1347        dec!(0.505),
1348        dec!(10.109),
1349        3,
1350        dec!(10_100_000),
1351        dec!(20_000_000)
1352    )]
1353    #[case::quarter_cent_tick(
1354        dec!(0.5025),
1355        dec!(10.059),
1356        4,
1357        dec!(10_050_000),
1358        dec!(20_000_000)
1359    )]
1360    #[case::minimum_order_size(dec!(0.99), dec!(4.959), 2, dec!(4_950_000), dec!(5_000_000))]
1361    fn test_build_collateral_limit_buy_amounts(
1362        #[case] price: Decimal,
1363        #[case] amount: Decimal,
1364        #[case] tick_decimals: u32,
1365        #[case] expected_maker: Decimal,
1366        #[case] expected_taker: Decimal,
1367    ) {
1368        let builder = make_test_builder();
1369
1370        let order = builder
1371            .build_limit_order_from_collateral(
1372                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1373                price,
1374                amount,
1375                None,
1376                OrderSigningContext::ctf(false),
1377                tick_decimals,
1378            )
1379            .unwrap();
1380
1381        assert_eq!(order.side, PolymarketOrderSide::Buy);
1382        assert_eq!(order.maker_amount, expected_maker);
1383        assert_eq!(order.taker_amount, expected_taker);
1384    }
1385
1386    #[rstest]
1387    #[case::zero_after_quantization(dec!(0.50), dec!(0.009), 2, "amount 0.009 pUSD truncates to zero")]
1388    #[case::zero_price(dec!(0), dec!(1), 2, "price must be positive")]
1389    #[case::inexact_signed_price(
1390        dec!(0.989),
1391        dec!(5),
1392        3,
1393        "amount 5 pUSD cannot preserve limit price 0.989 after venue quantization"
1394    )]
1395    fn test_build_collateral_limit_buy_denies_invalid_amounts(
1396        #[case] price: Decimal,
1397        #[case] amount: Decimal,
1398        #[case] tick_decimals: u32,
1399        #[case] expected_error: &str,
1400    ) {
1401        let builder = make_test_builder();
1402
1403        let error = builder
1404            .build_limit_order_from_collateral(
1405                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1406                price,
1407                amount,
1408                None,
1409                OrderSigningContext::ctf(false),
1410                tick_decimals,
1411            )
1412            .unwrap_err();
1413
1414        assert!(
1415            error.to_string().contains(expected_error),
1416            "unexpected error: {error}"
1417        );
1418    }
1419
1420    #[rstest]
1421    #[case::tick_tenth(1, dec!(0.5), dec!(1.01), dec!(500_000), dec!(1_000_000))]
1422    #[case::tick_hundredth(2, dec!(0.56), dec!(1.01), dec!(560_000), dec!(1_000_000))]
1423    #[case::tick_thousandth(3, dec!(0.961), dec!(5), dec!(4_800_000), dec!(4_994_790))]
1424    #[case::tick_ten_thousandth(4, dec!(0.9612), dec!(5), dec!(4_800_000), dec!(4_993_757))]
1425    #[case::live_aggressive(3, dec!(0.227), dec!(5), dec!(1_130_000), dec!(4_977_970))]
1426    #[case::paris(3, dec!(0.999), dec!(75.82), dec!(75_740_000), dec!(75_815_810))]
1427    #[case::half_cent(3, dec!(0.335), dec!(5), dec!(1_670_000), dec!(4_985_070))]
1428    #[case::quarter_cent(4, dec!(0.4325), dec!(7), dec!(3_020_000), dec!(6_982_658))]
1429    fn test_build_limit_order_quantizes_immediate_buy_to_cent_budget(
1430        #[case] tick_decimals: u32,
1431        #[case] price: Decimal,
1432        #[case] quantity: Decimal,
1433        #[case] expected_maker: Decimal,
1434        #[case] expected_taker: Decimal,
1435        #[values(PolymarketOrderType::FAK, PolymarketOrderType::FOK)]
1436        order_type: PolymarketOrderType,
1437    ) {
1438        let builder = make_test_builder();
1439
1440        let order = builder
1441            .build_limit_order(
1442                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1443                PolymarketOrderSide::Buy,
1444                price,
1445                quantity,
1446                order_type,
1447                None,
1448                false,
1449                tick_decimals,
1450            )
1451            .unwrap();
1452
1453        assert_eq!(order.maker_amount, expected_maker);
1454        assert_eq!(order.taker_amount, expected_taker);
1455        assert!(order.maker_amount >= price * order.taker_amount);
1456        assert!(order.maker_amount < (price + dec!(0.0001)) * order.taker_amount);
1457        assert!(order.maker_amount <= to_fixed_decimal(quantity * price));
1458        assert!(order.taker_amount <= to_fixed_decimal(signed_limit_order_quantity(quantity)));
1459        assert_eq!(
1460            posted_limit_share_quantity(
1461                PolymarketOrderSide::Buy,
1462                price,
1463                quantity,
1464                order_type,
1465                tick_decimals,
1466            )
1467            .unwrap(),
1468            signed_base_quantity(
1469                order.maker_amount,
1470                order.taker_amount,
1471                PolymarketOrderSide::Buy
1472            ),
1473        );
1474    }
1475
1476    #[rstest]
1477    fn test_validate_immediate_buy_denies_zero_cent_budget() {
1478        let order = make_limit_with_quantity(
1479            OrderSide::Buy,
1480            Quantity::from("0.01"),
1481            false,
1482            false,
1483            false,
1484            TimeInForce::Fok,
1485            Price::from("0.01"),
1486        );
1487
1488        let err = PolymarketOrderBuilder::validate_limit_order(&order).unwrap_err();
1489
1490        assert_eq!(
1491            err,
1492            validation_failed(
1493                "Polymarket FOK BUY maker amount 0.0001 pUSD truncates to zero at 2 decimal places"
1494            )
1495        );
1496    }
1497
1498    #[rstest]
1499    #[case::gtc_buy(PolymarketOrderSide::Buy, PolymarketOrderType::GTC, dec!(0.40), dec!(10), 2, dec!(10))]
1500    #[case::gtc_sell(PolymarketOrderSide::Sell, PolymarketOrderType::GTC, dec!(0.40), dec!(10), 2, dec!(10))]
1501    #[case::truncated(PolymarketOrderSide::Buy, PolymarketOrderType::GTC, dec!(0.50), dec!(5.009), 2, dec!(5))]
1502    #[case::immediate_thousandth(
1503        PolymarketOrderSide::Buy,
1504        PolymarketOrderType::FAK,
1505        dec!(0.961),
1506        dec!(5),
1507        3,
1508        dec!(4.99479)
1509    )]
1510    #[case::immediate_live(
1511        PolymarketOrderSide::Buy,
1512        PolymarketOrderType::FOK,
1513        dec!(0.227),
1514        dec!(5),
1515        3,
1516        dec!(4.977970)
1517    )]
1518    fn test_posted_limit_share_quantity_matches_signed_amounts(
1519        #[case] side: PolymarketOrderSide,
1520        #[case] order_type: PolymarketOrderType,
1521        #[case] price: Decimal,
1522        #[case] quantity: Decimal,
1523        #[case] tick_decimals: u32,
1524        #[case] expected: Decimal,
1525    ) {
1526        let shares = posted_limit_share_quantity(side, price, quantity, order_type, tick_decimals)
1527            .expect("share quantity is representable");
1528
1529        assert_eq!(shares, expected);
1530    }
1531
1532    #[rstest]
1533    fn test_posted_limit_share_quantity_rejects_zero_immediate_buy_budget() {
1534        let error = posted_limit_share_quantity(
1535            PolymarketOrderSide::Buy,
1536            dec!(0.01),
1537            dec!(0.01),
1538            PolymarketOrderType::FAK,
1539            2,
1540        )
1541        .expect_err("cent budget truncates to zero");
1542
1543        assert_eq!(
1544            error,
1545            "Polymarket FAK BUY maker amount 0.0001 pUSD truncates to zero at 2 decimal places"
1546        );
1547    }
1548
1549    #[rstest]
1550    #[case::gtc_buy(
1551        PolymarketOrderType::GTC,
1552        PolymarketOrderSide::Buy,
1553        dec!(4_805_000),
1554        dec!(5_000_000),
1555    )]
1556    #[case::gtd_buy(
1557        PolymarketOrderType::GTD,
1558        PolymarketOrderSide::Buy,
1559        dec!(4_805_000),
1560        dec!(5_000_000),
1561    )]
1562    #[case::fak_sell(
1563        PolymarketOrderType::FAK,
1564        PolymarketOrderSide::Sell,
1565        dec!(5_000_000),
1566        dec!(4_805_000),
1567    )]
1568    #[case::fok_sell(
1569        PolymarketOrderType::FOK,
1570        PolymarketOrderSide::Sell,
1571        dec!(5_000_000),
1572        dec!(4_805_000),
1573    )]
1574    fn test_build_limit_order_preserves_unaffected_fractional_cent_amounts(
1575        #[case] order_type: PolymarketOrderType,
1576        #[case] side: PolymarketOrderSide,
1577        #[case] expected_maker: Decimal,
1578        #[case] expected_taker: Decimal,
1579    ) {
1580        let builder = make_test_builder();
1581
1582        let order = builder
1583            .build_limit_order(
1584                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1585                side,
1586                dec!(0.961),
1587                dec!(5),
1588                order_type,
1589                None,
1590                false,
1591                3,
1592            )
1593            .unwrap();
1594
1595        assert_eq!(order.maker_amount, expected_maker);
1596        assert_eq!(order.taker_amount, expected_taker);
1597    }
1598
1599    #[rstest]
1600    fn test_validate_limit_order_gtd_with_expire_accepted() {
1601        // LimitOrder::new enforces GTD + expire_time upstream, so validate_limit_order
1602        // only needs to accept the valid case and let the lower layer reject mismatched
1603        // orders. Locking this behavior prevents a future regression where our
1604        // validator rejects GTD outright (which would break V2 GTD flows, as the V2
1605        // wire body carries expiration unsigned).
1606        let order = make_limit(false, false, false, TimeInForce::Gtd);
1607        assert!(PolymarketOrderBuilder::validate_limit_order(&order).is_ok());
1608    }
1609
1610    #[rstest]
1611    fn test_build_market_buy_order_wire_shape() {
1612        // Market BUY: `amount` is quote pUSD, so maker_amount = quote spend
1613        // and taker_amount = computed shares.
1614        let builder = make_test_builder();
1615        let order = builder
1616            .build_market_order(
1617                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1618                PolymarketOrderSide::Buy,
1619                dec!(0.50),
1620                dec!(10),
1621                false,
1622                2,
1623            )
1624            .unwrap();
1625
1626        assert_eq!(order.expiration, "0");
1627        assert_eq!(order.builder, POLYMARKET_NAUTILUS_BUILDER_CODE);
1628        assert_eq!(order.metadata, ZERO_BYTES32);
1629        assert_eq!(order.side, PolymarketOrderSide::Buy);
1630        assert!(!order.timestamp.is_empty());
1631        assert!(!order.signature.expose_secret().is_empty());
1632        // Wire amounts are micro-pUSD / micro-share mantissas (10^6 scale).
1633        // Quote-denominated BUY: 10 pUSD spend -> 20 shares at price 0.50.
1634        assert_eq!(order.maker_amount, dec!(10_000_000));
1635        assert_eq!(order.taker_amount, dec!(20_000_000));
1636    }
1637
1638    #[rstest]
1639    fn test_build_market_buy_order_rejects_fee_adjusted_amount_below_lot_size() {
1640        let builder = make_test_builder();
1641        let adjusted = adjust_market_buy_amount(
1642            dec!(10),
1643            dec!(0.009),
1644            dec!(0.5),
1645            dec!(0.04),
1646            dec!(1),
1647            dec!(0),
1648        )
1649        .unwrap();
1650        assert_eq!(adjusted, dec!(0.008823));
1651
1652        let err = builder
1653            .build_market_order(
1654                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1655                PolymarketOrderSide::Buy,
1656                dec!(0.5),
1657                adjusted,
1658                false,
1659                2,
1660            )
1661            .unwrap_err();
1662
1663        assert_eq!(
1664            err.to_string(),
1665            "Polymarket market BUY amount 0.008823 pUSD truncates to zero at 2 decimal places",
1666        );
1667        assert_eq!(builder.last_timestamp_ms.load(Ordering::Relaxed), 0);
1668    }
1669
1670    #[rstest]
1671    #[case::below_next_tick(dec!(700_099), dec!(1_000_000), true)]
1672    #[case::at_next_tick(dec!(700_100), dec!(1_000_000), false)]
1673    #[case::above_next_tick(dec!(700_101), dec!(1_000_000), false)]
1674    #[case::zero_shares(dec!(700_000), dec!(0), false)]
1675    #[case::zero_budget(dec!(0), dec!(1_000_000), false)]
1676    fn test_validate_buy_price_rounding(
1677        #[case] maker: Decimal,
1678        #[case] taker: Decimal,
1679        #[case] accepted: bool,
1680    ) {
1681        assert_eq!(
1682            validate_buy_price_rounding(dec!(0.7), maker, taker).is_ok(),
1683            accepted
1684        );
1685    }
1686
1687    #[rstest]
1688    #[case::paris(dec!(0.999), dec!(75.74), 3, dec!(75_815_810))]
1689    #[case::tenth(dec!(0.7), dec!(5), 1, dec!(7_142_000))]
1690    #[case::cent(dec!(0.07), dec!(1), 2, dec!(14_285_700))]
1691    #[case::half_cent(dec!(0.335), dec!(1.5), 3, dec!(4_477_610))]
1692    #[case::quarter_cent(dec!(0.4325), dec!(3), 4, dec!(6_936_416))]
1693    #[case::ten_thousandth(dec!(0.4275), dec!(100), 4, dec!(233_918_128))]
1694    fn test_build_market_buy_rounding_preserves_limit_tick(
1695        #[case] price: Decimal,
1696        #[case] amount: Decimal,
1697        #[case] tick_decimals: u32,
1698        #[case] expected_taker: Decimal,
1699    ) {
1700        let order = make_test_builder()
1701            .build_market_order(
1702                "1",
1703                PolymarketOrderSide::Buy,
1704                price,
1705                amount,
1706                false,
1707                tick_decimals,
1708            )
1709            .unwrap();
1710
1711        assert_eq!(order.maker_amount, to_fixed_decimal(amount));
1712        assert_eq!(order.taker_amount, expected_taker);
1713        assert!(order.maker_amount >= price * order.taker_amount);
1714        assert!(order.maker_amount < (price + dec!(0.0001)) * order.taker_amount);
1715    }
1716
1717    #[rstest]
1718    fn test_build_market_buy_rejects_rounding_across_finer_tick() {
1719        let builder = make_test_builder();
1720
1721        let error = builder
1722            .build_market_order("1", PolymarketOrderSide::Buy, dec!(0.7), dec!(1), false, 1)
1723            .unwrap_err();
1724
1725        assert!(error.to_string().contains("can match above limit price"));
1726        assert_eq!(builder.last_timestamp_ms.load(Ordering::Relaxed), 0);
1727    }
1728
1729    #[rstest]
1730    fn test_build_immediate_buy_rejects_rounding_across_finer_tick(
1731        #[values(PolymarketOrderType::FAK, PolymarketOrderType::FOK)]
1732        order_type: PolymarketOrderType,
1733    ) {
1734        let builder = make_test_builder();
1735
1736        // The coarse tick permits three share decimals, but 0.7 can refine to 0.0001,
1737        // 1 / 1.428 is above 0.7001 even though it is below the cached next tick of 0.8.
1738        let error = builder
1739            .build_limit_order(
1740                "1",
1741                PolymarketOrderSide::Buy,
1742                dec!(0.7),
1743                dec!(1.43),
1744                order_type,
1745                None,
1746                false,
1747                1,
1748            )
1749            .unwrap_err();
1750
1751        assert!(error.to_string().contains("can match above limit price"));
1752        assert!(
1753            posted_limit_share_quantity(
1754                PolymarketOrderSide::Buy,
1755                dec!(0.7),
1756                dec!(1.43),
1757                order_type,
1758                1,
1759            )
1760            .is_err()
1761        );
1762        assert_eq!(builder.last_timestamp_ms.load(Ordering::Relaxed), 0);
1763    }
1764
1765    #[rstest]
1766    fn test_build_market_sell_order_wire_shape() {
1767        // Market SELL: `amount` is shares, so maker_amount = shares
1768        // and taker_amount = computed pUSD proceeds.
1769        let builder = make_test_builder();
1770        let order = builder
1771            .build_market_order(
1772                "71321045679252212594626385532706912750332728571942532289631379312455583992563",
1773                PolymarketOrderSide::Sell,
1774                dec!(0.50),
1775                dec!(20),
1776                false,
1777                2,
1778            )
1779            .unwrap();
1780
1781        assert_eq!(order.expiration, "0");
1782        assert_eq!(order.side, PolymarketOrderSide::Sell);
1783        assert_eq!(order.maker_amount, dec!(20_000_000));
1784        assert_eq!(order.taker_amount, dec!(10_000_000));
1785        assert!(!order.signature.expose_secret().is_empty());
1786    }
1787
1788    #[rstest]
1789    fn test_generate_salt_uniqueness() {
1790        let s1 = generate_salt();
1791        let s2 = generate_salt();
1792        assert_ne!(s1, s2);
1793    }
1794
1795    #[rstest]
1796    fn test_generate_salt_within_53_bits() {
1797        for _ in 0..100 {
1798            let s = generate_salt();
1799            assert!(s < (1u64 << 53));
1800        }
1801    }
1802
1803    // Limit order amount tests
1804    // qty truncated to LOT_SIZE_SCALE=2 first, then computed side truncated to precision
1805    #[rstest]
1806    #[case(dec!(0.50), dec!(100), PolymarketOrderSide::Buy, 2, dec!(50_000_000), dec!(100_000_000))]
1807    #[case(dec!(0.50), dec!(100), PolymarketOrderSide::Sell, 2, dec!(100_000_000), dec!(50_000_000))]
1808    #[case(dec!(0.75), dec!(200), PolymarketOrderSide::Buy, 2, dec!(150_000_000), dec!(200_000_000))]
1809    // qty=23.456 → trunc(2)=23.45, maker=(23.45*0.567).trunc(5)=13.29615→13_296_150
1810    #[case(dec!(0.567), dec!(23.456), PolymarketOrderSide::Buy, 3, dec!(13_296_150), dec!(23_450_000))]
1811    #[case(dec!(0.55), dec!(10), PolymarketOrderSide::Buy, 1, dec!(5_500_000), dec!(10_000_000))]
1812    fn test_compute_maker_taker_amounts(
1813        #[case] price: Decimal,
1814        #[case] quantity: Decimal,
1815        #[case] side: PolymarketOrderSide,
1816        #[case] tick_decimals: u32,
1817        #[case] expected_maker: Decimal,
1818        #[case] expected_taker: Decimal,
1819    ) {
1820        let (maker, taker) = compute_maker_taker_amounts(price, quantity, side, tick_decimals);
1821        assert_eq!(maker, expected_maker);
1822        assert_eq!(taker, expected_taker);
1823    }
1824
1825    // SDK parity vectors lifted from `polymarket-rs-clob-client-v2`'s
1826    // `tests/order.rs::lifecycle::limit::{buy,sell}::should_succeed_*`. They
1827    // pin (price, size, tick_size) to specific signed maker/taker amounts;
1828    // any drift in our truncation or scale logic is caught against the
1829    // reference SDK directly. Covers all four documented tick sizes on both
1830    // sides plus a handful of decimal-accuracy edge cases.
1831    #[rstest]
1832    // tick=0.1 (decimals=1)
1833    #[case::buy_tick_tenth(
1834        dec!(0.5), dec!(21.04), PolymarketOrderSide::Buy, 1,
1835        dec!(10_520_000), dec!(21_040_000),
1836    )]
1837    #[case::sell_tick_tenth(
1838        dec!(0.5), dec!(21.04), PolymarketOrderSide::Sell, 1,
1839        dec!(21_040_000), dec!(10_520_000),
1840    )]
1841    // tick=0.01 (decimals=2)
1842    #[case::buy_tick_hundredth(
1843        dec!(0.56), dec!(21.04), PolymarketOrderSide::Buy, 2,
1844        dec!(11_782_400), dec!(21_040_000),
1845    )]
1846    #[case::sell_tick_hundredth(
1847        dec!(0.56), dec!(21.04), PolymarketOrderSide::Sell, 2,
1848        dec!(21_040_000), dec!(11_782_400),
1849    )]
1850    #[case::buy_decimal_accuracy_24(
1851        dec!(0.24), dec!(15), PolymarketOrderSide::Buy, 2,
1852        dec!(3_600_000), dec!(15_000_000),
1853    )]
1854    #[case::buy_decimal_accuracy_82(
1855        dec!(0.82), dec!(101), PolymarketOrderSide::Buy, 2,
1856        dec!(82_820_000), dec!(101_000_000),
1857    )]
1858    #[case::buy_decimal_accuracy_18233(
1859        dec!(0.58), dec!(18233.33), PolymarketOrderSide::Buy, 2,
1860        dec!(10_575_331_400), dec!(18_233_330_000),
1861    )]
1862    // tick=0.001 (decimals=3)
1863    #[case::buy_tick_thousandth(
1864        dec!(0.056), dec!(21.04), PolymarketOrderSide::Buy, 3,
1865        dec!(1_178_240), dec!(21_040_000),
1866    )]
1867    #[case::sell_tick_thousandth(
1868        dec!(0.056), dec!(21.04), PolymarketOrderSide::Sell, 3,
1869        dec!(21_040_000), dec!(1_178_240),
1870    )]
1871    // tick=0.0001 (decimals=4)
1872    #[case::buy_tick_ten_thousandth(
1873        dec!(0.0056), dec!(21.04), PolymarketOrderSide::Buy, 4,
1874        dec!(117_824), dec!(21_040_000),
1875    )]
1876    #[case::sell_tick_ten_thousandth(
1877        dec!(0.0056), dec!(21.04), PolymarketOrderSide::Sell, 4,
1878        dec!(21_040_000), dec!(117_824),
1879    )]
1880    fn test_compute_maker_taker_amounts_sdk_parity(
1881        #[case] price: Decimal,
1882        #[case] quantity: Decimal,
1883        #[case] side: PolymarketOrderSide,
1884        #[case] tick_decimals: u32,
1885        #[case] expected_maker: Decimal,
1886        #[case] expected_taker: Decimal,
1887    ) {
1888        let (maker, taker) = compute_maker_taker_amounts(price, quantity, side, tick_decimals);
1889        assert_eq!(maker, expected_maker);
1890        assert_eq!(taker, expected_taker);
1891    }
1892
1893    // Market order amount tests
1894    // amount truncated to LOT_SIZE_SCALE=2 first, then computed side truncated to precision
1895    #[rstest]
1896    #[case(dec!(0.50), dec!(50), PolymarketOrderSide::Buy, 2, dec!(50_000_000), dec!(100_000_000))]
1897    #[case(dec!(0.50), dec!(100), PolymarketOrderSide::Sell, 2, dec!(100_000_000), dec!(50_000_000))]
1898    #[case(dec!(0.75), dec!(150), PolymarketOrderSide::Buy, 2, dec!(150_000_000), dec!(200_000_000))]
1899    #[case(dec!(0.96), dec!(5.208), PolymarketOrderSide::Sell, 2, dec!(5_200_000), dec!(4_992_000))]
1900    // amt=23.696681 → trunc(2)=23.69, taker=(23.69*0.211).trunc(5)=4.99859→4_998_590
1901    #[case(dec!(0.211), dec!(23.696681), PolymarketOrderSide::Sell, 3, dec!(23_690_000), dec!(4_998_590))]
1902    // Captured 5 pUSD BUY at 0.66 signs 7.5757 shares; the venue filled 7.575758
1903    #[case(dec!(0.66), dec!(5), PolymarketOrderSide::Buy, 2, dec!(5_000_000), dec!(7_575_700))]
1904    fn test_compute_market_maker_taker_amounts(
1905        #[case] price: Decimal,
1906        #[case] amount: Decimal,
1907        #[case] side: PolymarketOrderSide,
1908        #[case] tick_decimals: u32,
1909        #[case] expected_maker: Decimal,
1910        #[case] expected_taker: Decimal,
1911    ) {
1912        let (maker, taker) = compute_market_maker_taker_amounts(price, amount, side, tick_decimals);
1913        assert_eq!(maker, expected_maker);
1914        assert_eq!(taker, expected_taker);
1915    }
1916
1917    #[rstest]
1918    fn test_compute_maker_taker_qty_truncated_to_lot_size() {
1919        // qty=23.456 → trunc(2)=23.45, tick_decimals=3 → precision=5
1920        // BUY: maker=(23.45*0.567).trunc(5)=13.29615→13_296_150, taker=23.45→23_450_000
1921        let (maker, taker) =
1922            compute_maker_taker_amounts(dec!(0.567), dec!(23.456), PolymarketOrderSide::Buy, 3);
1923        assert_eq!(maker, dec!(13_296_150));
1924        assert_eq!(taker, dec!(23_450_000));
1925    }
1926
1927    #[rstest]
1928    fn test_compute_maker_taker_zero_amounts() {
1929        let (maker, taker) =
1930            compute_maker_taker_amounts(dec!(0.50), dec!(0), PolymarketOrderSide::Buy, 2);
1931        assert_eq!(maker, dec!(0));
1932        assert_eq!(taker, dec!(0));
1933    }
1934
1935    #[rstest]
1936    fn test_compute_maker_taker_tick_decimals_1() {
1937        let (maker, taker) =
1938            compute_maker_taker_amounts(dec!(0.3), dec!(50), PolymarketOrderSide::Buy, 1);
1939        assert_eq!(maker, dec!(15_000_000));
1940        assert_eq!(taker, dec!(50_000_000));
1941    }
1942
1943    #[rstest]
1944    fn test_compute_maker_taker_tick_decimals_3_sell() {
1945        // qty=15.123 → trunc(2)=15.12
1946        // SELL: maker=15.12→15_120_000, taker=(15.12*0.789).trunc(5)=11.92968→11_929_680
1947        let (maker, taker) =
1948            compute_maker_taker_amounts(dec!(0.789), dec!(15.123), PolymarketOrderSide::Sell, 3);
1949        assert_eq!(maker, dec!(15_120_000));
1950        assert_eq!(taker, dec!(11_929_680));
1951    }
1952
1953    #[rstest]
1954    fn test_compute_market_maker_taker_zero_amount() {
1955        let (maker, taker) =
1956            compute_market_maker_taker_amounts(dec!(0.50), dec!(0), PolymarketOrderSide::Buy, 2);
1957        assert_eq!(maker, dec!(0));
1958        assert_eq!(taker, dec!(0));
1959    }
1960
1961    #[rstest]
1962    fn test_compute_market_sell_position_close() {
1963        // Reproduces the live bug: position=23.696681 shares, price=0.211, tick_decimals=3
1964        // Without truncation: maker=23_696_681 (6 decimals) → rejected by CLOB
1965        // With truncation: amt=23.69 → maker=23_690_000 (2 decimals) → accepted
1966        let (maker, taker) = compute_market_maker_taker_amounts(
1967            dec!(0.211),
1968            dec!(23.696681),
1969            PolymarketOrderSide::Sell,
1970            3,
1971        );
1972        assert_eq!(maker, dec!(23_690_000));
1973        // 23.69 * 0.211 = 4.99859, trunc(5) = 4.99859
1974        assert_eq!(taker, dec!(4_998_590));
1975        // Verify maker has max 2 decimal precision: 23_690_000 / 1_000_000 = 23.69
1976        assert_eq!(maker % dec!(10_000), dec!(0));
1977        // Verify taker has max 5 decimal precision: 4_998_590 / 1_000_000 = 4.99859
1978        assert_eq!(taker % dec!(10), dec!(0));
1979    }
1980
1981    #[rstest]
1982    fn test_to_fixed_decimal_basic() {
1983        assert_eq!(to_fixed_decimal(dec!(13.29955)), dec!(13_299_550));
1984        assert_eq!(to_fixed_decimal(dec!(100)), dec!(100_000_000));
1985        assert_eq!(to_fixed_decimal(dec!(0)), dec!(0));
1986    }
1987}