1use 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
55pub const ZERO_BYTES32: &str = "0x0000000000000000000000000000000000000000000000000000000000000000";
57
58const GTD_EXPIRATION_BUFFER_SECS: u64 = 180;
60
61#[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 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 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 #[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 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 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 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 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 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 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
537pub(crate) fn signed_limit_order_quantity(quantity: Decimal) -> Decimal {
539 quantity.trunc_with_scale(LOT_SIZE_SCALE)
540}
541
542pub(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
559fn 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
587fn 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 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
610pub 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
677pub 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#[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 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 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 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 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 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 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 #[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 #[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 #[rstest]
1832 #[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 #[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 #[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 #[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 #[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 #[case(dec!(0.211), dec!(23.696681), PolymarketOrderSide::Sell, 3, dec!(23_690_000), dec!(4_998_590))]
1902 #[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 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 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 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 assert_eq!(taker, dec!(4_998_590));
1975 assert_eq!(maker % dec!(10_000), dec!(0));
1977 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}