1use std::str::FromStr;
31
32use alloy::{
33 signers::{SignerSync, local::PrivateKeySigner},
34 sol_types::{SolStruct, SolValue, eip712_domain},
35};
36use alloy_primitives::{Address, B256, Bytes, FixedBytes, U256, address, keccak256};
37#[cfg(test)]
38use nautilus_core::string::secret::SecretString;
39use rust_decimal::Decimal;
40
41use crate::{
42 common::{
43 consts::MARKET_VERSION_V2,
44 credential::EvmPrivateKey,
45 enums::{PolymarketOrderSide, PolymarketSignatureType, PolymarketSignerType},
46 parse::validate_data_market_version,
47 },
48 http::{
49 error::{Error, Result},
50 models::PolymarketOrder,
51 query::AssetType,
52 },
53};
54
55const CLOB_AUTH_DOMAIN_NAME: &str = "ClobAuthDomain";
57const CLOB_AUTH_DOMAIN_VERSION: &str = "1";
58const CLOB_AUTH_MESSAGE: &str = "This message attests that I control the given wallet";
59
60pub const CTF_EXCHANGE: Address = address!("0xE111180000d2663C0091e4f400237545B87B996B");
62
63pub const NEG_RISK_CTF_EXCHANGE: Address = address!("0xe2222d279d744050d28e00520010520000310F59");
65
66pub const EXCHANGE_V3: Address = address!("0xe3333700cA9d93003F00f0F71f8515005F6c00Aa");
68
69pub const POSITION_MANAGER: Address = address!("0x006F54F7f9A22e0000CC2AB60031000000ae9fEF");
71
72pub const ROUTER: Address = address!("0x12121212006e4CD160D18e3f00711DA5c3372600");
74
75pub const CTF_COLLATERAL_ADAPTER: Address = address!("0xAdA100Db00Ca00073811820692005400218FcE1f");
77
78pub const NEG_RISK_CTF_COLLATERAL_ADAPTER: Address =
80 address!("0xadA2005600Dec949baf300f4C6120000bDB6eAab");
81
82pub const DEPOSIT_WALLET_FACTORY: Address = address!("0x00000000000Fb5C9ADea0298D729A0CB3823Cc07");
84
85pub const POLYMARKET_COLLATERAL_TOKEN: Address =
87 address!("0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB");
88
89pub const CONDITIONAL_TOKENS: Address = address!("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045");
91
92pub const COLLATERAL_APPROVAL_TARGETS: &[Address] = &[
94 CTF_EXCHANGE,
95 NEG_RISK_CTF_EXCHANGE,
96 NEG_RISK_CTF_COLLATERAL_ADAPTER,
97];
98
99#[derive(Debug, Clone, Copy, PartialEq, Eq)]
101pub enum PolymarketApproval {
102 Collateral {
104 contract: Address,
106 spender: Address,
108 amount: U256,
110 },
111 ConditionalTokens {
113 contract: Address,
115 operator: Address,
117 approved: bool,
119 },
120}
121
122pub fn approval_plan() -> impl Iterator<Item = PolymarketApproval> {
124 COLLATERAL_APPROVAL_TARGETS
125 .iter()
126 .copied()
127 .flat_map(|target| {
128 [
129 PolymarketApproval::Collateral {
130 contract: POLYMARKET_COLLATERAL_TOKEN,
131 spender: target,
132 amount: U256::MAX,
133 },
134 PolymarketApproval::ConditionalTokens {
135 contract: CONDITIONAL_TOKENS,
136 operator: target,
137 approved: true,
138 },
139 ]
140 })
141}
142
143#[must_use]
148pub fn approval_plan_v2(collateral_allowance: U256) -> [PolymarketApproval; 2] {
149 [
150 PolymarketApproval::Collateral {
151 contract: POLYMARKET_COLLATERAL_TOKEN,
152 spender: EXCHANGE_V3,
153 amount: collateral_allowance,
154 },
155 PolymarketApproval::ConditionalTokens {
156 contract: POSITION_MANAGER,
157 operator: EXCHANGE_V3,
158 approved: true,
159 },
160 ]
161}
162
163const DOMAIN_NAME: &str = "Polymarket CTF Exchange";
164const DOMAIN_VERSION: &str = "2";
165const DOMAIN_VERSION_V3: &str = "3";
166const POLYGON_CHAIN_ID: u64 = 137;
167const ORDER_TYPE_STRING: &str = concat!(
168 "Order(uint256 salt,address maker,address signer,uint256 tokenId,",
169 "uint256 makerAmount,uint256 takerAmount,uint8 side,uint8 signatureType,",
170 "uint256 timestamp,bytes32 metadata,bytes32 builder)",
171);
172const SOLADY_TYPE_STRING: &str = concat!(
173 "TypedDataSign(Order contents,string name,string version,uint256 chainId,",
174 "address verifyingContract,bytes32 salt)",
175 "Order(uint256 salt,address maker,address signer,uint256 tokenId,",
176 "uint256 makerAmount,uint256 takerAmount,uint8 side,uint8 signatureType,",
177 "uint256 timestamp,bytes32 metadata,bytes32 builder)",
178);
179const DOMAIN_TYPE_STRING: &str =
180 "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)";
181const DEPOSIT_WALLET_DOMAIN_NAME: &str = "DepositWallet";
182const DEPOSIT_WALLET_DOMAIN_VERSION: &str = "1";
183
184#[derive(Debug, Clone, Copy, PartialEq, Eq)]
186pub struct OrderSigningContext {
187 contract: Address,
188 version: &'static str,
189}
190
191impl OrderSigningContext {
192 pub fn new(market_version: Option<&str>, neg_risk: bool) -> anyhow::Result<Self> {
198 let version = validate_data_market_version(market_version)?;
199 Ok(if version == MARKET_VERSION_V2 {
200 Self {
201 contract: EXCHANGE_V3,
202 version: DOMAIN_VERSION_V3,
203 }
204 } else {
205 Self::ctf(neg_risk)
206 })
207 }
208
209 #[must_use]
211 pub fn position_asset_type(self) -> AssetType {
212 if self.contract == EXCHANGE_V3 {
213 AssetType::ConditionalV2
214 } else {
215 AssetType::Conditional
216 }
217 }
218
219 pub(crate) const fn ctf(neg_risk: bool) -> Self {
220 Self {
221 contract: exchange_contract(neg_risk),
222 version: DOMAIN_VERSION,
223 }
224 }
225}
226
227alloy::sol! {
231 struct ClobAuth {
232 address address;
233 string timestamp;
234 uint256 nonce;
235 string message;
236 }
237}
238
239alloy::sol! {
243 struct Call {
244 address target;
245 uint256 value;
246 bytes data;
247 }
248
249 struct Batch {
250 address wallet;
251 uint256 nonce;
252 uint256 deadline;
253 Call[] calls;
254 }
255}
256
257alloy::sol! {
262 struct Order {
263 uint256 salt;
264 address maker;
265 address signer;
266 uint256 tokenId;
267 uint256 makerAmount;
268 uint256 takerAmount;
269 uint8 side;
270 uint8 signatureType;
271 uint256 timestamp;
272 bytes32 metadata;
273 bytes32 builder;
274 }
275}
276
277#[derive(Debug)]
279pub struct OrderSigner {
280 signer: PrivateKeySigner,
281 signer_type: PolymarketSignerType,
282}
283
284impl OrderSigner {
285 pub fn new(private_key: &EvmPrivateKey) -> Result<Self> {
287 let key_hex = private_key
288 .as_hex()
289 .strip_prefix("0x")
290 .unwrap_or(private_key.as_hex());
291 let signer = PrivateKeySigner::from_str(key_hex)
292 .map_err(|e| Error::bad_request(format!("Failed to create signer: {e}")))?;
293 Ok(Self {
294 signer,
295 signer_type: PolymarketSignerType::Owner,
296 })
297 }
298
299 #[must_use]
301 pub fn with_signer_type(mut self, signer_type: PolymarketSignerType) -> Self {
302 self.signer_type = signer_type;
303 self
304 }
305
306 #[must_use]
308 pub fn address(&self) -> Address {
309 self.signer.address()
310 }
311
312 pub fn sign_order(&self, order: &PolymarketOrder, neg_risk: bool) -> Result<String> {
323 self.sign_order_with_context(order, OrderSigningContext::ctf(neg_risk))
324 }
325
326 pub fn sign_order_with_context(
332 &self,
333 order: &PolymarketOrder,
334 context: OrderSigningContext,
335 ) -> Result<String> {
336 if self.signer_type == PolymarketSignerType::Session
337 && order.signature_type != PolymarketSignatureType::Poly1271
338 {
339 return Err(Error::bad_request(
340 "Session signers require POLY_1271 orders",
341 ));
342 }
343
344 let order_signer = parse_address(&order.signer, "signer")?;
345 let order_maker = parse_address(&order.maker, "maker")?;
346 if order.signature_type == PolymarketSignatureType::Poly1271 {
347 if order_signer != order_maker {
348 return Err(Error::bad_request(format!(
349 "POLY_1271 orders require maker and signer to both be the deposit wallet, maker was {order_maker}, signer was {order_signer}",
350 )));
351 }
352 } else if order_signer != self.signer.address() {
353 return Err(Error::bad_request(format!(
354 "Order signer {order_signer} does not match local signer {}",
355 self.signer.address(),
356 )));
357 }
358
359 let eip712_order = build_eip712_order(order)?;
360 if order.signature_type == PolymarketSignatureType::Poly1271 {
361 return self.sign_poly_1271_order(&eip712_order, context);
362 }
363
364 let domain = eip712_domain! {
365 name: DOMAIN_NAME,
366 version: context.version,
367 chain_id: POLYGON_CHAIN_ID,
368 verifying_contract: context.contract,
369 };
370
371 let signing_hash = eip712_order.eip712_signing_hash(&domain);
372 self.sign_hash(&signing_hash.0)
373 }
374
375 fn sign_poly_1271_order(&self, order: &Order, context: OrderSigningContext) -> Result<String> {
376 let contents_hash = poly_1271_contents_hash(order);
377 let wallet_struct_hash = poly_1271_wallet_struct_hash(contents_hash, order.signer);
378 let app_domain_separator = exchange_domain_separator(context);
379 let signing_hash = typed_data_hash(app_domain_separator, wallet_struct_hash);
380 let signature = self.sign_hash_b256(&signing_hash)?;
381
382 let mut encoded =
383 Vec::with_capacity(65 + 32 + 32 + ORDER_TYPE_STRING.len() + std::mem::size_of::<u16>());
384 encoded.extend_from_slice(&signature);
385 encoded.extend_from_slice(app_domain_separator.as_slice());
386 encoded.extend_from_slice(contents_hash.as_slice());
387 encoded.extend_from_slice(ORDER_TYPE_STRING.as_bytes());
388 encoded.extend_from_slice(&(ORDER_TYPE_STRING.len() as u16).to_be_bytes());
389
390 if self.signer_type == PolymarketSignerType::Session {
391 let signer_id = B256::left_padding_from(self.address().as_slice());
393 encoded = (signer_id, B256::ZERO, Bytes::from(encoded)).abi_encode_params();
394 encoded.extend_from_slice(&[0x64, 0x92].repeat(16));
395 }
396
397 Ok(format!(
398 "0x{}",
399 alloy_primitives::hex::encode(encoded.as_slice())
400 ))
401 }
402
403 pub fn sign_deposit_wallet_batch(
409 &self,
410 deposit_wallet: Address,
411 nonce: U256,
412 deadline: U256,
413 calls: &[DepositWalletCall],
414 ) -> Result<String> {
415 if calls.is_empty() {
416 return Err(Error::bad_request(
417 "Deposit Wallet batch must contain at least one call",
418 ));
419 }
420
421 let batch = Batch {
422 wallet: deposit_wallet,
423 nonce,
424 deadline,
425 calls: calls
426 .iter()
427 .map(|call| Call {
428 target: call.target,
429 value: call.value,
430 data: call.data.clone(),
431 })
432 .collect(),
433 };
434
435 let domain = eip712_domain! {
436 name: DEPOSIT_WALLET_DOMAIN_NAME,
437 version: DEPOSIT_WALLET_DOMAIN_VERSION,
438 chain_id: POLYGON_CHAIN_ID,
439 verifying_contract: deposit_wallet,
440 };
441 let signing_hash = batch.eip712_signing_hash(&domain);
442 self.sign_hash(&signing_hash.0)
443 }
444
445 fn sign_hash_b256(&self, hash: &B256) -> Result<[u8; 65]> {
446 let signature = self
447 .signer
448 .sign_hash_sync(hash)
449 .map_err(|e| Error::bad_request(format!("Failed to sign order: {e}")))?;
450 Ok(signature.as_bytes())
451 }
452
453 fn sign_hash(&self, hash: &[u8; 32]) -> Result<String> {
454 let hash_b256 = B256::from(*hash);
455 let signature = self.sign_hash_b256(&hash_b256)?;
456 Ok(format!(
457 "0x{}",
458 alloy_primitives::hex::encode(signature.as_slice())
459 ))
460 }
461}
462
463#[derive(Clone, Debug, PartialEq, Eq)]
465pub struct DepositWalletCall {
466 pub target: Address,
468 pub value: U256,
470 pub data: Bytes,
472}
473
474pub fn order_hash(order: &PolymarketOrder, neg_risk: bool) -> Result<B256> {
479 order_hash_with_context(order, OrderSigningContext::ctf(neg_risk))
480}
481
482pub fn order_hash_with_context(
484 order: &PolymarketOrder,
485 context: OrderSigningContext,
486) -> Result<B256> {
487 let eip712_order = build_eip712_order(order)?;
488
489 let domain = eip712_domain! {
490 name: DOMAIN_NAME,
491 version: context.version,
492 chain_id: POLYGON_CHAIN_ID,
493 verifying_contract: context.contract,
494 };
495
496 Ok(eip712_order.eip712_signing_hash(&domain))
497}
498
499const fn exchange_contract(neg_risk: bool) -> Address {
500 if neg_risk {
501 NEG_RISK_CTF_EXCHANGE
502 } else {
503 CTF_EXCHANGE
504 }
505}
506
507fn order_type_hash() -> B256 {
508 keccak256(ORDER_TYPE_STRING.as_bytes())
509}
510
511fn solady_type_hash() -> B256 {
512 keccak256(SOLADY_TYPE_STRING.as_bytes())
513}
514
515fn domain_type_hash() -> B256 {
516 keccak256(DOMAIN_TYPE_STRING.as_bytes())
517}
518
519fn domain_name_hash() -> B256 {
520 keccak256(DOMAIN_NAME.as_bytes())
521}
522
523fn deposit_wallet_name_hash() -> B256 {
524 keccak256(DEPOSIT_WALLET_DOMAIN_NAME.as_bytes())
525}
526
527fn deposit_wallet_version_hash() -> B256 {
528 keccak256(DEPOSIT_WALLET_DOMAIN_VERSION.as_bytes())
529}
530
531fn poly_1271_contents_hash(order: &Order) -> B256 {
532 let tuple = (
533 order_type_hash(),
534 order.salt,
535 order.maker,
536 order.signer,
537 order.tokenId,
538 order.makerAmount,
539 order.takerAmount,
540 U256::from(order.side),
541 U256::from(order.signatureType),
542 order.timestamp,
543 order.metadata,
544 order.builder,
545 );
546 keccak256(tuple.abi_encode())
547}
548
549fn poly_1271_wallet_struct_hash(contents_hash: B256, deposit_wallet: Address) -> B256 {
550 let tuple = (
551 solady_type_hash(),
552 contents_hash,
553 deposit_wallet_name_hash(),
554 deposit_wallet_version_hash(),
555 U256::from(POLYGON_CHAIN_ID),
556 deposit_wallet,
557 FixedBytes::<32>::ZERO,
558 );
559 keccak256(tuple.abi_encode())
560}
561
562fn exchange_domain_separator(context: OrderSigningContext) -> B256 {
563 let tuple = (
564 domain_type_hash(),
565 domain_name_hash(),
566 keccak256(context.version.as_bytes()),
567 U256::from(POLYGON_CHAIN_ID),
568 context.contract,
569 );
570 keccak256(tuple.abi_encode())
571}
572
573fn typed_data_hash(domain_separator: B256, struct_hash: B256) -> B256 {
574 let mut bytes = Vec::with_capacity(2 + 32 + 32);
575 bytes.push(0x19);
576 bytes.push(0x01);
577 bytes.extend_from_slice(domain_separator.as_slice());
578 bytes.extend_from_slice(struct_hash.as_slice());
579 keccak256(bytes)
580}
581
582pub fn sign_clob_auth(
589 private_key: &EvmPrivateKey,
590 timestamp: &str,
591 nonce: u64,
592) -> Result<(String, String)> {
593 let key_hex = private_key
594 .as_hex()
595 .strip_prefix("0x")
596 .unwrap_or(private_key.as_hex());
597 let signer = PrivateKeySigner::from_str(key_hex)
598 .map_err(|e| Error::bad_request(format!("Failed to create signer: {e}")))?;
599
600 let address = signer.address();
601
602 let auth = ClobAuth {
603 address,
604 timestamp: timestamp.to_string(),
605 nonce: U256::from(nonce),
606 message: CLOB_AUTH_MESSAGE.to_string(),
607 };
608
609 let domain = eip712_domain! {
610 name: CLOB_AUTH_DOMAIN_NAME,
611 version: CLOB_AUTH_DOMAIN_VERSION,
612 chain_id: POLYGON_CHAIN_ID,
613 };
614
615 let signing_hash = auth.eip712_signing_hash(&domain);
616 let signature = signer
617 .sign_hash_sync(&signing_hash)
618 .map_err(|e| Error::bad_request(format!("Failed to sign ClobAuth: {e}")))?;
619
620 let r = signature.r();
621 let s = signature.s();
622 let v = if signature.v() { 28u8 } else { 27u8 };
623
624 Ok((
625 format!("{address:#x}"),
626 format!("0x{r:064x}{s:064x}{v:02x}"),
627 ))
628}
629
630fn build_eip712_order(order: &PolymarketOrder) -> Result<Order> {
632 Ok(Order {
633 salt: U256::from(order.salt),
634 maker: parse_address(&order.maker, "maker")?,
635 signer: parse_address(&order.signer, "signer")?,
636 tokenId: U256::from_str(order.token_id.as_str())
637 .map_err(|e| Error::bad_request(format!("Invalid token ID: {e}")))?,
638 makerAmount: decimal_to_u256(order.maker_amount, "maker_amount")?,
639 takerAmount: decimal_to_u256(order.taker_amount, "taker_amount")?,
640 side: order_side_to_u8(order.side),
641 signatureType: order.signature_type as u8,
642 timestamp: U256::from_str(&order.timestamp)
643 .map_err(|e| Error::bad_request(format!("Invalid timestamp: {e}")))?,
644 metadata: parse_bytes32(&order.metadata, "metadata")?,
645 builder: parse_bytes32(&order.builder, "builder")?,
646 })
647}
648
649pub(crate) fn parse_address(addr: &str, field: &str) -> Result<Address> {
650 Address::from_str(addr).map_err(|e| Error::bad_request(format!("Invalid {field} address: {e}")))
651}
652
653pub(crate) fn parse_bytes32(value: &str, field: &str) -> Result<FixedBytes<32>> {
654 FixedBytes::<32>::from_str(value)
655 .map_err(|e| Error::bad_request(format!("Invalid {field} bytes32: {e}")))
656}
657
658fn decimal_to_u256(d: Decimal, field: &str) -> Result<U256> {
659 let normalized = d.normalize();
660 if normalized.scale() != 0 {
661 return Err(Error::bad_request(format!("{field} must be an integer")));
662 }
663 let mantissa = normalized.mantissa();
664 if mantissa < 0 {
665 return Err(Error::bad_request(format!("{field} must be non-negative")));
666 }
667 Ok(U256::from(mantissa as u128))
668}
669
670fn order_side_to_u8(side: PolymarketOrderSide) -> u8 {
671 match side {
672 PolymarketOrderSide::Buy => 0,
673 PolymarketOrderSide::Sell => 1,
674 }
675}
676
677#[cfg(test)]
678mod tests {
679 use alloy_primitives::{Signature, keccak256};
680 use nautilus_core::hex;
681 use rstest::rstest;
682 use rust_decimal_macros::dec;
683 use ustr::Ustr;
684
685 use super::*;
686 use crate::common::enums::PolymarketSignatureType;
687
688 const TEST_PRIVATE_KEY: &str =
689 "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
690
691 fn test_signer() -> OrderSigner {
692 let pk = EvmPrivateKey::new(TEST_PRIVATE_KEY).unwrap();
693 OrderSigner::new(&pk).unwrap()
694 }
695
696 const ZERO_BYTES32: &str = "0x0000000000000000000000000000000000000000000000000000000000000000";
697
698 fn test_order() -> PolymarketOrder {
699 PolymarketOrder {
700 salt: 123456789,
701 maker: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266".to_string(),
702 signer: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266".to_string(),
703 token_id: Ustr::from(
704 "71321045679252212594626385532706912750332728571942532289631379312455583992563",
705 ),
706 maker_amount: dec!(100000000),
707 taker_amount: dec!(50000000),
708 side: PolymarketOrderSide::Buy,
709 signature_type: PolymarketSignatureType::Eoa,
710 expiration: "0".to_string(),
711 timestamp: "1713398400000".to_string(),
712 metadata: ZERO_BYTES32.to_string(),
713 builder: ZERO_BYTES32.to_string(),
714 signature: SecretString::default(),
715 }
716 }
717
718 #[rstest]
719 fn test_order_typehash_matches_contract() {
720 let expected = keccak256(
722 "Order(uint256 salt,address maker,address signer,uint256 tokenId,uint256 makerAmount,uint256 takerAmount,uint8 side,uint8 signatureType,uint256 timestamp,bytes32 metadata,bytes32 builder)",
723 );
724 let order = test_order();
725 let eip712_order = build_eip712_order(&order).unwrap();
726 assert_eq!(eip712_order.eip712_type_hash(), expected);
727 }
728
729 #[rstest]
730 fn test_signer_debug_redacts_private_key() {
731 let signer = test_signer();
732 let debug = format!("{signer:?}");
733
734 assert!(debug.contains(&format!("{:#x}", signer.address())));
735 assert!(!debug.contains(TEST_PRIVATE_KEY.trim_start_matches("0x")));
736 }
737
738 #[rstest]
739 fn test_signer_address_derivation() {
740 let signer = test_signer();
741 let expected = Address::from_str("0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266").unwrap();
743 assert_eq!(signer.address(), expected);
744 }
745
746 #[rstest]
747 fn test_sign_clob_auth_matches_polymarket_mainnet_vector() {
748 let private_key = EvmPrivateKey::new(TEST_PRIVATE_KEY).unwrap();
749
750 let (address, signature) = sign_clob_auth(&private_key, "10000000", 23).unwrap();
751
752 assert_eq!(address, "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266");
754 assert_eq!(
755 signature,
756 "0x1a7118db6100dfd8efd102be36f472b59475dcac56eb4c9a2a94748d3655ba7c3c89deb8c19ee79eceb0a531122fbfbe88ed118034f9d8212e2b725e7b296b9d1c",
757 );
758 }
759
760 #[rstest]
761 fn test_sign_order_format() {
762 let signer = test_signer();
763 let order = test_order();
764
765 let sig = signer.sign_order(&order, false).unwrap();
766
767 assert!(sig.starts_with("0x"));
768 assert_eq!(sig.len(), 132); }
770
771 #[rstest]
772 fn test_sign_poly_1271_order_format() {
773 let signer = test_signer();
774 let mut order = test_order();
775 order.maker = "0x1111111111111111111111111111111111111111".to_string();
776 order.signer = order.maker.clone();
777 order.signature_type = PolymarketSignatureType::Poly1271;
778
779 let sig = signer.sign_order(&order, false).unwrap();
780
781 assert!(sig.starts_with("0x"));
782 assert_eq!(sig.len(), 636);
783 }
784
785 #[rstest]
786 fn test_sign_poly_1271_order_requires_deposit_wallet_signer() {
787 let signer = test_signer();
788 let mut order = test_order();
789 order.maker = "0x1111111111111111111111111111111111111111".to_string();
790 order.signature_type = PolymarketSignatureType::Poly1271;
791
792 let err = signer.sign_order(&order, false).unwrap_err();
793
794 assert!(
795 err.to_string()
796 .contains("maker and signer to both be the deposit wallet")
797 );
798 }
799
800 #[rstest]
801 fn test_sign_order_deterministic() {
802 let signer = test_signer();
803 let order = test_order();
804
805 let sig1 = signer.sign_order(&order, false).unwrap();
806 let sig2 = signer.sign_order(&order, false).unwrap();
807 assert_eq!(sig1, sig2);
808 }
809
810 #[rstest]
811 fn test_sign_deposit_wallet_batch_format_and_recovery() {
812 let signer = test_signer();
813 let deposit_wallet = address!("0x1111111111111111111111111111111111111111");
814
815 let calls = [DepositWalletCall {
816 target: CTF_COLLATERAL_ADAPTER,
817 value: U256::ZERO,
818 data: Bytes::from_static(&[0xde, 0xad, 0xbe, 0xef]),
819 }];
820
821 let sig = signer
822 .sign_deposit_wallet_batch(
823 deposit_wallet,
824 U256::from(7u64),
825 U256::from(1_714_000_000u64),
826 &calls,
827 )
828 .unwrap();
829
830 assert!(sig.starts_with("0x"));
831 assert_eq!(sig.len(), 132);
832
833 let batch = Batch {
834 wallet: deposit_wallet,
835 nonce: U256::from(7u64),
836 deadline: U256::from(1_714_000_000u64),
837 calls: vec![Call {
838 target: CTF_COLLATERAL_ADAPTER,
839 value: U256::ZERO,
840 data: Bytes::from_static(&[0xde, 0xad, 0xbe, 0xef]),
841 }],
842 };
843
844 let domain = eip712_domain! {
845 name: DEPOSIT_WALLET_DOMAIN_NAME,
846 version: DEPOSIT_WALLET_DOMAIN_VERSION,
847 chain_id: POLYGON_CHAIN_ID,
848 verifying_contract: deposit_wallet,
849 };
850 let signing_hash = batch.eip712_signing_hash(&domain);
851 let recovered = Signature::from_str(&sig)
852 .unwrap()
853 .recover_address_from_prehash(&signing_hash)
854 .unwrap();
855 assert_eq!(recovered, signer.address());
856 }
857
858 #[rstest]
859 fn test_sign_deposit_wallet_batch_rejects_empty_calls() {
860 let signer = test_signer();
861 let err = signer
862 .sign_deposit_wallet_batch(
863 address!("0x1111111111111111111111111111111111111111"),
864 U256::from(1u64),
865 U256::from(1_714_000_000u64),
866 &[],
867 )
868 .unwrap_err();
869 assert!(
870 err.to_string()
871 .contains("Deposit Wallet batch must contain at least one call")
872 );
873 }
874
875 #[rstest]
876 fn test_sign_order_neg_risk_differs() {
877 let signer = test_signer();
878 let order = test_order();
879
880 let sig_normal = signer.sign_order(&order, false).unwrap();
881 let sig_neg_risk = signer.sign_order(&order, true).unwrap();
882 assert_ne!(sig_normal, sig_neg_risk);
883 }
884
885 #[rstest]
886 fn test_sign_order_sell_side() {
887 let signer = test_signer();
888 let mut order = test_order();
889 let sig_buy = signer.sign_order(&order, false).unwrap();
890
891 order.side = PolymarketOrderSide::Sell;
892 let sig_sell = signer.sign_order(&order, false).unwrap();
893 assert_ne!(sig_buy, sig_sell);
894 }
895
896 #[rstest]
897 fn test_sign_order_different_amounts() {
898 let signer = test_signer();
899 let mut order = test_order();
900 let sig1 = signer.sign_order(&order, false).unwrap();
901
902 order.maker_amount = dec!(200000000);
903 let sig2 = signer.sign_order(&order, false).unwrap();
904 assert_ne!(sig1, sig2);
905 }
906
907 #[rstest]
908 fn test_build_eip712_order() {
909 let order = test_order();
910 let eip712 = build_eip712_order(&order).unwrap();
911
912 assert_eq!(eip712.salt, U256::from(123456789u64));
913 assert_eq!(
914 eip712.maker,
915 Address::from_str("0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266").unwrap()
916 );
917 assert_eq!(eip712.makerAmount, U256::from(100000000u128));
918 assert_eq!(eip712.takerAmount, U256::from(50000000u128));
919 assert_eq!(eip712.side, 0); assert_eq!(eip712.signatureType, 0); assert_eq!(eip712.timestamp, U256::from(1713398400000u128));
922 assert_eq!(eip712.metadata, FixedBytes::<32>::ZERO);
923 assert_eq!(eip712.builder, FixedBytes::<32>::ZERO);
924 }
925
926 #[rstest]
927 fn test_build_eip712_order_with_builder_code() {
928 let mut order = test_order();
929 order.builder =
930 "0x0000000000000000000000000000000000000000000000000000000000000001".to_string();
931 let eip712 = build_eip712_order(&order).unwrap();
932
933 let mut expected = [0u8; 32];
934 expected[31] = 1;
935 assert_eq!(eip712.builder, FixedBytes::<32>::from(expected));
936 }
937
938 #[rstest]
939 fn test_decimal_to_u256_integer() {
940 let result = decimal_to_u256(dec!(100000000), "test").unwrap();
941 assert_eq!(result, U256::from(100000000u128));
942 }
943
944 #[rstest]
945 fn test_decimal_to_u256_zero() {
946 let result = decimal_to_u256(dec!(0), "test").unwrap();
947 assert_eq!(result, U256::ZERO);
948 }
949
950 #[rstest]
951 fn test_decimal_to_u256_rejects_fractional() {
952 let result = decimal_to_u256(dec!(100.5), "test");
953 assert!(result.is_err());
954 }
955
956 #[rstest]
957 fn test_decimal_to_u256_rejects_negative() {
958 let result = decimal_to_u256(dec!(-1), "test");
959 assert!(result.is_err());
960 }
961
962 #[rstest]
963 fn test_order_side_mapping() {
964 assert_eq!(order_side_to_u8(PolymarketOrderSide::Buy), 0);
965 assert_eq!(order_side_to_u8(PolymarketOrderSide::Sell), 1);
966 }
967
968 #[rstest]
969 fn test_contract_addresses_nonzero() {
970 assert_ne!(CTF_EXCHANGE, Address::ZERO);
971 assert_ne!(NEG_RISK_CTF_EXCHANGE, Address::ZERO);
972 assert_ne!(CTF_EXCHANGE, NEG_RISK_CTF_EXCHANGE);
973 }
974
975 #[rstest]
976 fn test_v2_contract_addresses_pinned() {
977 assert_eq!(
981 format!("{CTF_EXCHANGE:#x}"),
982 "0xe111180000d2663c0091e4f400237545b87b996b"
983 );
984 assert_eq!(
985 format!("{NEG_RISK_CTF_EXCHANGE:#x}"),
986 "0xe2222d279d744050d28e00520010520000310f59"
987 );
988 assert_eq!(
989 format!("{CTF_COLLATERAL_ADAPTER:#x}"),
990 "0xada100db00ca00073811820692005400218fce1f"
991 );
992 assert_eq!(
993 format!("{NEG_RISK_CTF_COLLATERAL_ADAPTER:#x}"),
994 "0xada2005600dec949baf300f4c6120000bdb6eaab"
995 );
996 assert_eq!(
997 format!("{DEPOSIT_WALLET_FACTORY:#x}"),
998 "0x00000000000fb5c9adea0298d729a0cb3823cc07"
999 );
1000 assert_eq!(
1001 format!("{POLYMARKET_COLLATERAL_TOKEN:#x}"),
1002 "0xc011a7e12a19f7b1f670d46f03b03f3342e82dfb"
1003 );
1004 assert_eq!(
1005 format!("{CONDITIONAL_TOKENS:#x}"),
1006 "0x4d97dcd97ec945f40cf65f87097ace5ea0476045"
1007 );
1008 assert_eq!(
1009 COLLATERAL_APPROVAL_TARGETS,
1010 &[
1011 CTF_EXCHANGE,
1012 NEG_RISK_CTF_EXCHANGE,
1013 NEG_RISK_CTF_COLLATERAL_ADAPTER,
1014 ]
1015 );
1016 }
1017
1018 #[rstest]
1019 fn test_approval_plan() {
1020 let collateral_token = address!("0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB");
1021 let conditional_tokens = address!("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045");
1022 let ctf_exchange = address!("0xE111180000d2663C0091e4f400237545B87B996B");
1023 let neg_risk_ctf_exchange = address!("0xe2222d279d744050d28e00520010520000310F59");
1024 let neg_risk_collateral_adapter = address!("0xadA2005600Dec949baf300f4C6120000bDB6eAab");
1025 let expected = vec![
1026 PolymarketApproval::Collateral {
1027 contract: collateral_token,
1028 spender: ctf_exchange,
1029 amount: U256::MAX,
1030 },
1031 PolymarketApproval::ConditionalTokens {
1032 contract: conditional_tokens,
1033 operator: ctf_exchange,
1034 approved: true,
1035 },
1036 PolymarketApproval::Collateral {
1037 contract: collateral_token,
1038 spender: neg_risk_ctf_exchange,
1039 amount: U256::MAX,
1040 },
1041 PolymarketApproval::ConditionalTokens {
1042 contract: conditional_tokens,
1043 operator: neg_risk_ctf_exchange,
1044 approved: true,
1045 },
1046 PolymarketApproval::Collateral {
1047 contract: collateral_token,
1048 spender: neg_risk_collateral_adapter,
1049 amount: U256::MAX,
1050 },
1051 PolymarketApproval::ConditionalTokens {
1052 contract: conditional_tokens,
1053 operator: neg_risk_collateral_adapter,
1054 approved: true,
1055 },
1056 ];
1057
1058 assert_eq!(approval_plan().collect::<Vec<_>>(), expected);
1059 }
1060
1061 #[rstest]
1062 fn test_domain_version_is_v2() {
1063 assert_eq!(DOMAIN_VERSION, "2");
1066 }
1067
1068 #[rstest]
1069 fn test_sign_order_recoverable() {
1070 let signer = test_signer();
1071 let order = test_order();
1072 let sig_hex = signer.sign_order(&order, false).unwrap();
1073
1074 let sig_bytes = hex::decode(&sig_hex[2..]).unwrap();
1075 assert_eq!(sig_bytes.len(), 65);
1076
1077 let r = U256::from_be_slice(&sig_bytes[..32]);
1078 let s = U256::from_be_slice(&sig_bytes[32..64]);
1079 let v = sig_bytes[64];
1080 let y_parity = v == 28;
1081
1082 let signature = Signature::new(r, s, y_parity);
1083
1084 let eip712_order = build_eip712_order(&order).unwrap();
1085 let domain = eip712_domain! {
1086 name: DOMAIN_NAME,
1087 version: DOMAIN_VERSION,
1088 chain_id: POLYGON_CHAIN_ID,
1089 verifying_contract: CTF_EXCHANGE,
1090 };
1091 let signing_hash = eip712_order.eip712_signing_hash(&domain);
1092
1093 let recovered = signature
1094 .recover_address_from_prehash(&signing_hash)
1095 .unwrap();
1096 assert_eq!(recovered, signer.address());
1097 }
1098
1099 const PARITY_TOKEN_ID: &str =
1106 "71321045679252212594626385532706912750332728571942532289631379312455583992563";
1107
1108 fn parity_order(
1109 salt: u64,
1110 side: PolymarketOrderSide,
1111 signature_type: PolymarketSignatureType,
1112 maker_amount: Decimal,
1113 taker_amount: Decimal,
1114 timestamp: &str,
1115 builder: &str,
1116 ) -> PolymarketOrder {
1117 PolymarketOrder {
1118 salt,
1119 maker: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266".to_string(),
1120 signer: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266".to_string(),
1121 token_id: Ustr::from(PARITY_TOKEN_ID),
1122 maker_amount,
1123 taker_amount,
1124 side,
1125 signature_type,
1126 expiration: "0".to_string(),
1127 timestamp: timestamp.to_string(),
1128 metadata: ZERO_BYTES32.to_string(),
1129 builder: builder.to_string(),
1130 signature: SecretString::default(),
1131 }
1132 }
1133
1134 #[rstest]
1135 #[case::buy_standard_eoa(
1136 parity_order(
1137 123456789,
1138 PolymarketOrderSide::Buy,
1139 PolymarketSignatureType::Eoa,
1140 dec!(100000000),
1141 dec!(50000000),
1142 "1713398400000",
1143 ZERO_BYTES32,
1144 ),
1145 false,
1146 "0x32961c48ddac87ed3582f8e02097cd0eff4fcf80460306bd44b3710438dfa64c",
1147 "0x89f178136333c8ebb32a19146cb891233e3202d474be6ef730c24dbc06ae4d2a0c99948a86d9b57de0f2c0bb8ec6964aa244ecf17cfa3a95b86878d0b64ad78a1b",
1148 )]
1149 #[case::sell_neg_risk_eoa(
1150 parity_order(
1151 987654321,
1152 PolymarketOrderSide::Sell,
1153 PolymarketSignatureType::Eoa,
1154 dec!(50000000),
1155 dec!(100000000),
1156 "1713398400000",
1157 ZERO_BYTES32,
1158 ),
1159 true,
1160 "0x8b878404bd92dea2bfea9975c9fcd816ec70a57ae431cb20d67bb773744aaef3",
1161 "0xf7d60d64364e2615b08d9f69f3ea9afd3b4f83ecfbf05ddd3ca83f4916277fb97d2d080758d17c8e91c928aceb8ff252477ebaec051b672832500f63b4d36b061c",
1162 )]
1163 #[case::buy_with_builder_code_eoa(
1164 parity_order(
1165 1,
1166 PolymarketOrderSide::Buy,
1167 PolymarketSignatureType::Eoa,
1168 dec!(100000000),
1169 dec!(50000000),
1170 "1713398500000",
1171 "0x0000000000000000000000000000000000000000000000000000000000000001",
1172 ),
1173 false,
1174 "0x3df0b6f6ddfca837bc36964cae968b34ad35640b5d98f557c104da97e804e36a",
1175 "0xf4d2b34659e8bc07a9572d40ee5a1639a1157409613b4c21566b1f33fd8fe11a364b3f306668cae7248ca7cdf72378f9266bc5628585aa939644400030671e081c",
1176 )]
1177 #[case::buy_poly_proxy(
1178 parity_order(
1183 111_111_111,
1184 PolymarketOrderSide::Buy,
1185 PolymarketSignatureType::PolyProxy,
1186 dec!(100000000),
1187 dec!(50000000),
1188 "1713398400000",
1189 ZERO_BYTES32,
1190 ),
1191 false,
1192 "0x8f88fe2fb3448f4b8ba639992029f0a47a01a14d15b5f2bf9833516571efd279",
1193 "0x71a63c85b730cc934688f23ea6374afffef57a61690eba63dcb97a706c8a8d0f3d2a8e0280f3e252eb83be088ebae6b461a8eda18e559e079f59050b90057afa1c",
1194 )]
1195 #[case::sell_neg_risk_poly_gnosis_safe(
1196 parity_order(
1197 222_222_222,
1198 PolymarketOrderSide::Sell,
1199 PolymarketSignatureType::PolyGnosisSafe,
1200 dec!(50000000),
1201 dec!(100000000),
1202 "1713398400000",
1203 ZERO_BYTES32,
1204 ),
1205 true,
1206 "0xb34248702810a1d76580234a33f942a9801c3680de54cb3ef104572a8d482190",
1207 "0xab9d33aee8b578fe5588c4a4b16bbef6fa05fc757020f95b98212e877a919e360a90296f02e97ecbabf3c200271ffe88eb9fd86912e8376cd27237bdad5f3abc1c",
1208 )]
1209 fn test_signature_matches_py_clob_client_v2(
1210 #[case] order: PolymarketOrder,
1211 #[case] neg_risk: bool,
1212 #[case] expected_hash_hex: &str,
1213 #[case] expected_signature_hex: &str,
1214 ) {
1215 let signer = test_signer();
1216
1217 let hash = order_hash(&order, neg_risk).unwrap();
1218 assert_eq!(format!("{hash:#x}"), expected_hash_hex, "signing hash");
1219
1220 let signature = signer.sign_order(&order, neg_risk).unwrap();
1221 assert_eq!(signature, expected_signature_hex, "signature");
1222 }
1223
1224 #[rstest]
1225 #[case::standard_exchange(
1226 false,
1227 "0x48cfd4c03dcee72230750e2dc5ea71048e91244c2a9fec2ed6ef790a74869596",
1228 concat!(
1229 "0x780beffb568c4510b8a135a92ca8071f124cf368fb0e902fe451c5f51e555791",
1230 "0a2a87968caa08a242de85e83c27375fc09242e897aa77680f56622a54e6e7c",
1231 "61c3264e159346253e26a64e00b69032db0e7d32f94628de3e6eecb50304d",
1232 "7af3d2d3db4f9eed41f0490532a9460395d96602c6534a931bde4f0e3aad5",
1233 "71e4f84a04f726465722875696e743235362073616c742c6164647265737320",
1234 "6d616b65722c61646472657373207369676e65722c75696e7432353620746f",
1235 "6b656e49642c75696e74323536206d616b6572416d6f756e742c75696e7432",
1236 "35362074616b6572416d6f756e742c75696e743820736964652c75696e7438",
1237 "207369676e6174757265547970652c75696e743235362074696d657374616d",
1238 "702c62797465733332206d657461646174612c62797465733332206275696c",
1239 "6465722900ba",
1240 ),
1241 )]
1242 #[case::neg_risk_exchange(
1243 true,
1244 "0x82b94b9d570fdd7b07f517ea848606a9b74029f2387fbf07d8b9c856d652e608",
1245 concat!(
1246 "0xa411986b67c58113f8787ee54c41def9376d57ef4262b56438438710720604b7",
1247 "00137e0175d7ae6afc40c2988179ad84b1b71a739f0974c8df3c12372f31b22c",
1248 "1c9b858f53327b0bd13af8ec14cfb35234fb9eb7b0504d1a4e61f433840d3",
1249 "0e81ad3db4f9eed41f0490532a9460395d96602c6534a931bde4f0e3aad571",
1250 "e4f84a04f726465722875696e743235362073616c742c61646472657373206d",
1251 "616b65722c61646472657373207369676e65722c75696e7432353620746f6b",
1252 "656e49642c75696e74323536206d616b6572416d6f756e742c75696e743235",
1253 "362074616b6572416d6f756e742c75696e743820736964652c75696e743820",
1254 "7369676e6174757265547970652c75696e743235362074696d657374616d70",
1255 "2c62797465733332206d657461646174612c62797465733332206275696c64",
1256 "65722900ba",
1257 ),
1258 )]
1259 fn test_poly_1271_signature_matches_py_clob_client_v2(
1260 #[case] neg_risk: bool,
1261 #[case] expected_hash: &str,
1262 #[case] expected_signature: &str,
1263 ) {
1264 let signer = test_signer();
1265 let mut order = parity_order(
1266 333_333_333,
1267 PolymarketOrderSide::Buy,
1268 PolymarketSignatureType::Poly1271,
1269 dec!(100000000),
1270 dec!(50000000),
1271 "1713398400000",
1272 ZERO_BYTES32,
1273 );
1274 order.maker = "0x1111111111111111111111111111111111111111".to_string();
1275 order.signer = order.maker.clone();
1276
1277 let hash = order_hash(&order, neg_risk).unwrap();
1278 assert_eq!(format!("{hash:#x}"), expected_hash, "signing hash");
1279
1280 let signature = signer.sign_order(&order, neg_risk).unwrap();
1281 assert_eq!(signature, expected_signature, "signature");
1282 }
1283
1284 #[rstest]
1285 #[case(false)]
1286 #[case(true)]
1287 fn test_session_signature_envelope(#[case] neg_risk: bool) {
1288 let mut order = test_order();
1289 order.signature_type = PolymarketSignatureType::Poly1271;
1290 order.maker = "0x1111111111111111111111111111111111111111".to_string();
1291 order.signer = order.maker.clone();
1292 let owner = test_signer();
1293 let inner = owner.sign_order(&order, neg_risk).unwrap();
1294 let session = test_signer().with_signer_type(PolymarketSignerType::Session);
1295 let signature = session.sign_order(&order, neg_risk).unwrap();
1296 let bytes = alloy_primitives::hex::decode(&signature[2..]).unwrap();
1297 let (payload, magic) = bytes.split_at(bytes.len() - 32);
1298 let (signer_id, validator, wrapped) =
1299 <(B256, B256, Bytes)>::abi_decode_params(payload).unwrap();
1300 assert_eq!(
1301 signer_id,
1302 B256::left_padding_from(owner.address().as_slice())
1303 );
1304 assert_eq!(validator, B256::ZERO);
1305 assert_eq!(
1306 format!("0x{}", alloy_primitives::hex::encode(wrapped)),
1307 inner
1308 );
1309 assert_eq!(magic, &[0x64, 0x92].repeat(16));
1310 }
1311
1312 #[rstest]
1313 #[case(PolymarketSignatureType::Eoa)]
1314 #[case(PolymarketSignatureType::PolyProxy)]
1315 #[case(PolymarketSignatureType::PolyGnosisSafe)]
1316 fn test_session_rejects_other_wallets(#[case] signature_type: PolymarketSignatureType) {
1317 let mut order = test_order();
1318 order.signature_type = signature_type;
1319 let signer = test_signer().with_signer_type(PolymarketSignerType::Session);
1320 assert_eq!(
1321 signer.sign_order(&order, false).unwrap_err().to_string(),
1322 "bad request: Session signers require POLY_1271 orders"
1323 );
1324 }
1325
1326 #[rstest]
1327 fn test_session_signatures_match_official_sdk() {
1328 #[derive(serde::Deserialize)]
1329 struct Fixture {
1330 private_key: String,
1331 order: PolymarketOrder,
1332 vectors: Vec<Vector>,
1333 }
1334
1335 #[derive(serde::Deserialize)]
1336 struct Vector {
1337 neg_risk: bool,
1338 signature_chunks: Vec<String>,
1339 }
1340
1341 let fixture: Fixture =
1342 serde_json::from_str(include_str!("../../test_data/session_signatures.json")).unwrap();
1343 let key = EvmPrivateKey::new(&fixture.private_key).unwrap();
1344 let signer = OrderSigner::new(&key)
1345 .unwrap()
1346 .with_signer_type(PolymarketSignerType::Session);
1347 assert_eq!(fixture.vectors.len(), 2);
1348
1349 for vector in fixture.vectors {
1350 assert_eq!(
1351 signer.sign_order(&fixture.order, vector.neg_risk).unwrap(),
1352 vector.signature_chunks.concat()
1353 );
1354 }
1355 }
1356
1357 #[rstest]
1358 fn test_protocol_signatures_and_order_ids_match_official_sdk() {
1359 #[derive(serde::Deserialize)]
1360 struct Fixture {
1361 private_key: String,
1362 vectors: Vec<Vector>,
1363 }
1364 #[derive(serde::Deserialize)]
1365 struct Vector {
1366 market_version: String,
1367 neg_risk: bool,
1368 signer_type: String,
1369 exchange: Address,
1370 domain_version: String,
1371 order: PolymarketOrder,
1372 order_hash: B256,
1373 signature_chunks: Vec<String>,
1374 }
1375 let fixture: Fixture =
1376 serde_json::from_str(include_str!("../../test_data/protocol_signatures.json")).unwrap();
1377 let key = EvmPrivateKey::new(&fixture.private_key).unwrap();
1378 assert_eq!(fixture.vectors.len(), 20);
1379
1380 for vector in fixture.vectors {
1381 let context =
1382 OrderSigningContext::new(Some(&vector.market_version), vector.neg_risk).unwrap();
1383
1384 let role = if vector.signer_type == "SESSION_KEY" {
1385 PolymarketSignerType::Session
1386 } else {
1387 PolymarketSignerType::Owner
1388 };
1389
1390 let signer = OrderSigner::new(&key).unwrap().with_signer_type(role);
1391 assert_eq!(context.contract, vector.exchange);
1392 assert_eq!(context.version, vector.domain_version);
1393 assert_eq!(
1394 order_hash_with_context(&vector.order, context).unwrap(),
1395 vector.order_hash
1396 );
1397 assert_eq!(
1398 signer
1399 .sign_order_with_context(&vector.order, context)
1400 .unwrap(),
1401 vector.signature_chunks.concat()
1402 );
1403 }
1404 }
1405
1406 #[rstest]
1407 #[case(None)]
1408 #[case(Some(""))]
1409 #[case(Some("V2"))]
1410 #[case(Some("2"))]
1411 #[case(Some("v3"))]
1412 fn test_signing_context_refuses_invalid_protocol(#[case] version: Option<&str>) {
1413 assert!(OrderSigningContext::new(version, false).is_err());
1414 }
1415
1416 #[rstest]
1417 fn test_v2_approval_plan_uses_explicit_limit_and_position_manager() {
1418 let amount = U256::from(12_345_678_u64);
1419 assert_eq!(
1420 approval_plan_v2(amount),
1421 [
1422 PolymarketApproval::Collateral {
1423 contract: POLYMARKET_COLLATERAL_TOKEN,
1424 spender: EXCHANGE_V3,
1425 amount
1426 },
1427 PolymarketApproval::ConditionalTokens {
1428 contract: POSITION_MANAGER,
1429 operator: EXCHANGE_V3,
1430 approved: true
1431 },
1432 ]
1433 );
1434 }
1435}