Skip to main content

nautilus_polymarket/signing/
eip712.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! EIP-712 order signing for the Polymarket CTF Exchange.
17//!
18//! Orders on Polymarket are signed typed structured data (EIP-712) against the
19//! exchange contract selected by the market protocol on Polygon. CTF markets use:
20//! - [`CTF_EXCHANGE`]: Standard binary markets.
21//! - [`NEG_RISK_CTF_EXCHANGE`]: Negative-risk (multi-outcome) markets.
22//!
23//! CTF exchanges share domain version `2`. Protocol V2 markets use [`EXCHANGE_V3`] and domain
24//! version `3`, irrespective of `neg_risk`. [`OrderSigningContext`] binds this selection for
25//! ordinary signatures, Deposit Wallet signatures, allowance requests, and order IDs.
26//!
27//! This module owns Polygon contract identities and the CTF and V2 approval plans
28//! ([`approval_plan`], [`approval_plan_v2`]) used by the set-allowances binary.
29
30use 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
55// L1 ClobAuth constants
56const 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
60/// CTF Exchange contract address on Polygon mainnet (CLOB V2).
61pub const CTF_EXCHANGE: Address = address!("0xE111180000d2663C0091e4f400237545B87B996B");
62
63/// Neg Risk CTF Exchange contract address on Polygon mainnet (CLOB V2).
64pub const NEG_RISK_CTF_EXCHANGE: Address = address!("0xe2222d279d744050d28e00520010520000310F59");
65
66/// Protocol V2 exchange contract on Polygon mainnet.
67pub const EXCHANGE_V3: Address = address!("0xe3333700cA9d93003F00f0F71f8515005F6c00Aa");
68
69/// Protocol V2 position ledger on Polygon mainnet.
70pub const POSITION_MANAGER: Address = address!("0x006F54F7f9A22e0000CC2AB60031000000ae9fEF");
71
72/// Protocol V2 position-operation Router proxy on Polygon mainnet.
73pub const ROUTER: Address = address!("0x12121212006e4CD160D18e3f00711DA5c3372600");
74
75/// Standard CTF collateral adapter address on Polygon mainnet.
76pub const CTF_COLLATERAL_ADAPTER: Address = address!("0xAdA100Db00Ca00073811820692005400218FcE1f");
77
78/// Neg Risk CTF collateral adapter address on Polygon mainnet.
79pub const NEG_RISK_CTF_COLLATERAL_ADAPTER: Address =
80    address!("0xadA2005600Dec949baf300f4C6120000bDB6eAab");
81
82/// Deposit Wallet factory address on Polygon mainnet.
83pub const DEPOSIT_WALLET_FACTORY: Address = address!("0x00000000000Fb5C9ADea0298D729A0CB3823Cc07");
84
85/// Polymarket pUSD collateral token contract address on Polygon mainnet.
86pub const POLYMARKET_COLLATERAL_TOKEN: Address =
87    address!("0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB");
88
89/// Conditional Tokens Framework contract address on Polygon mainnet.
90pub const CONDITIONAL_TOKENS: Address = address!("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045");
91
92/// CTF-market spender set requiring pUSD collateral approval.
93pub const COLLATERAL_APPROVAL_TARGETS: &[Address] = &[
94    CTF_EXCHANGE,
95    NEG_RISK_CTF_EXCHANGE,
96    NEG_RISK_CTF_COLLATERAL_ADAPTER,
97];
98
99/// One transaction in the Polymarket approval plan.
100#[derive(Debug, Clone, Copy, PartialEq, Eq)]
101pub enum PolymarketApproval {
102    /// Approves a contract to spend pUSD collateral.
103    Collateral {
104        /// Collateral token contract receiving the approval call.
105        contract: Address,
106        /// Contract receiving the collateral allowance.
107        spender: Address,
108        /// Collateral allowance amount.
109        amount: U256,
110    },
111    /// Enables a contract as an operator for a position ledger.
112    ConditionalTokens {
113        /// Position ledger receiving the operator call.
114        contract: Address,
115        /// Contract receiving position-ledger operator authority.
116        operator: Address,
117        /// Whether operator authority is enabled.
118        approved: bool,
119    },
120}
121
122/// Returns the ordered approval plan for CTF (`v1`) markets.
123pub 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/// Returns the V2 trading approvals for an explicit pUSD limit in six-decimal base units.
144///
145/// The asset holder submits these calls. The collateral limit must cover BUY spend plus fees.
146/// This plan grants neither Router nor AutoRedeemer permission.
147#[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/// Validated exchange and EIP-712 domain for a market's orders and order IDs.
185#[derive(Debug, Clone, Copy, PartialEq, Eq)]
186pub struct OrderSigningContext {
187    contract: Address,
188    version: &'static str,
189}
190
191impl OrderSigningContext {
192    /// Selects the exchange from explicit `v1` or `v2` market metadata.
193    ///
194    /// # Errors
195    ///
196    /// Returns an error if market metadata is missing or unsupported.
197    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    /// Returns the position ledger's exact CLOB balance/allowance asset type.
210    #[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
227// EIP-712 ClobAuth struct for L1 API authentication.
228//
229// Reference: <https://docs.polymarket.com/api-reference/authentication#l1-authentication>
230alloy::sol! {
231    struct ClobAuth {
232        address address;
233        string timestamp;
234        uint256 nonce;
235        string message;
236    }
237}
238
239// EIP-712 Deposit Wallet batch authorization.
240//
241// Reference: <https://docs.polymarket.com/trading/wallets-auth#execute-gasless-transactions>
242alloy::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
257// EIP-712 Order struct for CLOB V2 CTFExchange.
258//
259// Fees are set by the protocol at match time (not signed) and per-address
260// uniqueness comes from `timestamp` (milliseconds) rather than `nonce`.
261alloy::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/// EIP-712 order signer for the Polymarket CTF Exchange.
278#[derive(Debug)]
279pub struct OrderSigner {
280    signer: PrivateKeySigner,
281    signer_type: PolymarketSignerType,
282}
283
284impl OrderSigner {
285    /// Creates a new [`OrderSigner`] from an EVM private key.
286    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    /// Selects the signer role. Session signing requires `POLY_1271` orders.
300    #[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    /// Returns the signer's Ethereum address.
307    #[must_use]
308    pub fn address(&self) -> Address {
309        self.signer.address()
310    }
311
312    /// Signs a [`PolymarketOrder`] and returns the hex-encoded ECDSA signature.
313    ///
314    /// This CTF-only method uses domain version `2`; `neg_risk` selects the CTF exchange.
315    /// Use [`Self::sign_order_with_context`] for a Protocol V2 market.
316    ///
317    /// # Errors
318    ///
319    /// Returns an error if a non-`POLY_1271` order signer does not match this
320    /// signer's address, or if a `POLY_1271` order does not use the deposit
321    /// wallet for both `maker` and `signer`.
322    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    /// Signs an order with the validated market's exchange and domain.
327    ///
328    /// # Errors
329    ///
330    /// Returns an error if signer validation or signing fails; see [`Self::sign_order`].
331    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            // The session envelope wraps the complete Deposit Wallet signature.
392            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    /// Signs a Deposit Wallet `Batch` and returns the hex-encoded ECDSA signature.
404    ///
405    /// # Errors
406    ///
407    /// Returns an error if `calls` is empty or signing fails.
408    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/// One contract call in a Deposit Wallet batch.
464#[derive(Clone, Debug, PartialEq, Eq)]
465pub struct DepositWalletCall {
466    /// Contract receiving the call.
467    pub target: Address,
468    /// Native POL value in wei.
469    pub value: U256,
470    /// ABI-encoded calldata.
471    pub data: Bytes,
472}
473
474/// Computes the EIP-712 signing hash used by Polymarket as the order ID.
475///
476/// This CTF-only function uses domain version `2`; `neg_risk` selects the CTF exchange.
477/// Use [`order_hash_with_context`] for a Protocol V2 market.
478pub fn order_hash(order: &PolymarketOrder, neg_risk: bool) -> Result<B256> {
479    order_hash_with_context(order, OrderSigningContext::ctf(neg_risk))
480}
481
482/// Computes the order ID with the same validated context used for signing.
483pub 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
582/// Signs a ClobAuth EIP-712 message for L1 API authentication.
583///
584/// Used to create or derive API credentials via the CLOB `/auth/api-key`
585/// and `/auth/derive-api-key` endpoints.
586///
587/// Returns `(signer_address_hex, signature_hex)`.
588pub 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
630// Converts a PolymarketOrder to the EIP-712 Order struct
631fn 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        // ORDER_TYPEHASH from the CLOB V2 CTFExchange contract
721        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        // Hardhat account #0
742        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        // https://github.com/Polymarket/clob-client/blob/7df8257dc95f99edb257b53a7873e273a9b4a9b3/src/signing/eip712.ts
753        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); // 0x + r(64) + s(64) + v(2)
769    }
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); // BUY
920        assert_eq!(eip712.signatureType, 0); // EOA
921        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        // Pin the V2 contract addresses so a revert to V1 is caught by unit tests.
978        // V1 addresses (must NOT match): 0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E,
979        // 0xC5d563A36AE78145C45a50134d48A1215220f80a.
980        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        // Domain version is embedded in the EIP-712 signing hash; a revert to
1064        // "1" would silently break V2 order acceptance.
1065        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    // Reference vectors generated with `py_clob_client_v2==1.0.0`'s
1100    // `ExchangeOrderBuilderV2`. Same test private key (Hardhat account #0),
1101    // same contract addresses and chain id. Locks our EIP-712 hash + ECDSA
1102    // signature output to the SDK's, so drift between the two signers (domain
1103    // typo, struct field reorder, bytes32 padding, etc.) is caught locally
1104    // before orders get sent to the venue.
1105    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        // V2 unblocks EIP-1271 smart contract wallet signing. signatureType
1179        // enters the typed-data hash directly, so a regression that only
1180        // manifests for proxy/safe wallets is undetectable from the Eoa
1181        // cases above.
1182        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}