Skip to main content

nautilus_polymarket/positions/
calldata.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//! ABI encoding for Polymarket CTF and Protocol V2 position operations.
17
18use alloy::{primitives::Bytes, sol, sol_types::SolCall};
19use alloy_primitives::{Address, B256, FixedBytes, U256, hex};
20use rust_decimal::Decimal;
21
22use super::amounts::pusd_to_base_units;
23use crate::{
24    http::error::{Error, Result},
25    signing::eip712::{
26        CTF_COLLATERAL_ADAPTER, NEG_RISK_CTF_COLLATERAL_ADAPTER, POLYMARKET_COLLATERAL_TOKEN,
27        PolymarketApproval, ROUTER, parse_bytes32,
28    },
29};
30
31sol! {
32    function approve(address spender, uint256 amount);
33    function setApprovalForAll(address operator, bool approved);
34    function split(bytes31 conditionId, uint256 amount);
35    function merge(bytes31 conditionId, uint256 amount);
36    function redeem(bytes31 conditionId, uint256 outcomeIndex, uint256 amount);
37
38    function splitPosition(
39        address collateralToken,
40        bytes32 parentCollectionId,
41        bytes32 conditionId,
42        uint256[] partition,
43        uint256 amount
44    );
45
46    function mergePositions(
47        address collateralToken,
48        bytes32 parentCollectionId,
49        bytes32 conditionId,
50        uint256[] partition,
51        uint256 amount
52    );
53
54    function redeemPositions(
55        address collateralToken,
56        bytes32 parentCollectionId,
57        bytes32 conditionId,
58        uint256[] indexSets
59    );
60}
61
62const PARENT_COLLECTION_ID: B256 = B256::ZERO;
63const BINARY_INDEX_SETS: [U256; 2] = [
64    U256::from_limbs([1, 0, 0, 0]),
65    U256::from_limbs([2, 0, 0, 0]),
66];
67
68/// Encoded contract call for a position operation.
69#[derive(Clone, Debug, PartialEq, Eq)]
70pub struct PositionCall {
71    /// Contract that receives the call.
72    pub target: Address,
73    /// ABI-encoded function call.
74    pub data: Bytes,
75}
76
77/// Encodes one approval for submission by the asset holder.
78#[must_use]
79pub fn encode_approval(approval: PolymarketApproval) -> PositionCall {
80    match approval {
81        PolymarketApproval::Collateral {
82            contract,
83            spender,
84            amount,
85        } => PositionCall {
86            target: contract,
87            data: Bytes::from(approveCall { spender, amount }.abi_encode()),
88        },
89        PolymarketApproval::ConditionalTokens {
90            contract,
91            operator,
92            approved,
93        } => PositionCall {
94            target: contract,
95            data: Bytes::from(setApprovalForAllCall { operator, approved }.abi_encode()),
96        },
97    }
98}
99
100/// Returns the canonical collateral adapter for a standard or negative-risk market.
101#[must_use]
102pub const fn collateral_adapter(neg_risk: bool) -> Address {
103    if neg_risk {
104        NEG_RISK_CTF_COLLATERAL_ADAPTER
105    } else {
106        CTF_COLLATERAL_ADAPTER
107    }
108}
109
110/// Encodes a `splitPosition` call for `amount` pUSD.
111///
112/// # Errors
113///
114/// Returns an error if `condition_id` is not a 32-byte hex value or `amount`
115/// is not an exact positive six-decimal pUSD quantity.
116pub fn encode_split_position(
117    condition_id: &str,
118    amount: Decimal,
119    neg_risk: bool,
120) -> Result<PositionCall> {
121    let condition_id = parse_condition_id(condition_id)?;
122    let amount = pusd_to_base_units(amount)?;
123    Ok(PositionCall {
124        target: collateral_adapter(neg_risk),
125        data: Bytes::from(
126            splitPositionCall {
127                collateralToken: POLYMARKET_COLLATERAL_TOKEN,
128                parentCollectionId: PARENT_COLLECTION_ID,
129                conditionId: condition_id,
130                partition: BINARY_INDEX_SETS.to_vec(),
131                amount,
132            }
133            .abi_encode(),
134        ),
135    })
136}
137
138/// Encodes a `mergePositions` call for `amount` pUSD of complete sets.
139///
140/// # Errors
141///
142/// Returns an error if `condition_id` is not a 32-byte hex value or `amount`
143/// is not an exact positive six-decimal pUSD quantity.
144pub fn encode_merge_positions(
145    condition_id: &str,
146    amount: Decimal,
147    neg_risk: bool,
148) -> Result<PositionCall> {
149    let condition_id = parse_condition_id(condition_id)?;
150    let amount = pusd_to_base_units(amount)?;
151    Ok(PositionCall {
152        target: collateral_adapter(neg_risk),
153        data: Bytes::from(
154            mergePositionsCall {
155                collateralToken: POLYMARKET_COLLATERAL_TOKEN,
156                parentCollectionId: PARENT_COLLECTION_ID,
157                conditionId: condition_id,
158                partition: BINARY_INDEX_SETS.to_vec(),
159                amount,
160            }
161            .abi_encode(),
162        ),
163    })
164}
165
166/// Encodes a `redeemPositions` call for both binary index sets.
167///
168/// # Errors
169///
170/// Returns an error if `condition_id` is not a 32-byte hex value.
171pub fn encode_redeem_positions(condition_id: &str, neg_risk: bool) -> Result<PositionCall> {
172    let condition_id = parse_condition_id(condition_id)?;
173    Ok(PositionCall {
174        target: collateral_adapter(neg_risk),
175        data: Bytes::from(
176            redeemPositionsCall {
177                collateralToken: POLYMARKET_COLLATERAL_TOKEN,
178                parentCollectionId: PARENT_COLLECTION_ID,
179                conditionId: condition_id,
180                indexSets: BINARY_INDEX_SETS.to_vec(),
181            }
182            .abi_encode(),
183        ),
184    })
185}
186
187/// Encodes a V2 Router split for an exact six-decimal pUSD amount.
188///
189/// # Errors
190///
191/// Returns an error if the V2 condition ID is invalid, or the amount is nonpositive or inexact.
192pub fn encode_split_position_v2(condition_id: &str, amount: Decimal) -> Result<PositionCall> {
193    let condition_id = parse_condition_id_v2(condition_id)?;
194    let amount = pusd_to_base_units(amount)?;
195    Ok(PositionCall {
196        target: ROUTER,
197        data: Bytes::from(
198            splitCall {
199                conditionId: condition_id,
200                amount,
201            }
202            .abi_encode(),
203        ),
204    })
205}
206
207/// Encodes a V2 Router merge that consumes `amount` shares of each outcome.
208///
209/// # Errors
210///
211/// Returns an error if the V2 condition ID is invalid, or the amount is nonpositive or inexact.
212pub fn encode_merge_positions_v2(condition_id: &str, amount: Decimal) -> Result<PositionCall> {
213    let condition_id = parse_condition_id_v2(condition_id)?;
214    let amount = pusd_to_base_units(amount)?;
215    Ok(PositionCall {
216        target: ROUTER,
217        data: Bytes::from(
218            mergeCall {
219                conditionId: condition_id,
220                amount,
221            }
222            .abi_encode(),
223        ),
224    })
225}
226
227/// Encodes a V2 Router redemption of `amount` shares of outcome `0` or `1`.
228///
229/// # Errors
230///
231/// Returns an error if the condition ID or outcome index is invalid, or the amount is nonpositive
232/// or inexact.
233pub fn encode_redeem_position_v2(
234    condition_id: &str,
235    outcome_index: u8,
236    amount: Decimal,
237) -> Result<PositionCall> {
238    if outcome_index > 1 {
239        return Err(Error::bad_request("V2 outcome_index must be 0 or 1"));
240    }
241
242    let condition_id = parse_condition_id_v2(condition_id)?;
243    let amount = pusd_to_base_units(amount)?;
244    Ok(PositionCall {
245        target: ROUTER,
246        data: Bytes::from(
247            redeemCall {
248                conditionId: condition_id,
249                outcomeIndex: U256::from(outcome_index),
250                amount,
251            }
252            .abi_encode(),
253        ),
254    })
255}
256
257pub(super) fn parse_condition_id_v2(condition_id: &str) -> Result<FixedBytes<31>> {
258    let value = condition_id
259        .strip_prefix("0x")
260        .ok_or_else(|| Error::bad_request("V2 condition_id must be 0x-prefixed hex"))?;
261    let bytes =
262        hex::decode(value).map_err(|_| Error::bad_request("V2 condition_id must be valid hex"))?;
263
264    if bytes.len() != 31 && bytes.len() != 32 {
265        return Err(Error::bad_request(
266            "V2 condition_id must contain 31 or 32 bytes",
267        ));
268    }
269
270    if bytes.len() == 32 && bytes[31] != 0 {
271        return Err(Error::bad_request(
272            "V2 padded condition_id must have a zero final byte",
273        ));
274    }
275
276    if !matches!(bytes[0], 1 | 2) {
277        return Err(Error::bad_request(
278            "V2 position operations require BinaryModule or NegRiskModule",
279        ));
280    }
281
282    Ok(FixedBytes::from_slice(&bytes[..31]))
283}
284
285fn parse_condition_id(condition_id: &str) -> Result<B256> {
286    parse_bytes32(condition_id, "condition_id")
287}
288
289#[cfg(test)]
290mod tests {
291    use alloy_primitives::keccak256;
292    use rstest::rstest;
293    use rust_decimal_macros::dec;
294
295    use super::*;
296
297    const CONDITION_ID: &str = "0x1111111111111111111111111111111111111111111111111111111111111111";
298
299    fn selector(signature: &str) -> [u8; 4] {
300        let hash = keccak256(signature.as_bytes());
301        [hash[0], hash[1], hash[2], hash[3]]
302    }
303
304    #[rstest]
305    fn test_collateral_adapter_targets() {
306        assert_eq!(collateral_adapter(false), CTF_COLLATERAL_ADAPTER);
307        assert_eq!(collateral_adapter(true), NEG_RISK_CTF_COLLATERAL_ADAPTER);
308        assert_ne!(CTF_COLLATERAL_ADAPTER, NEG_RISK_CTF_COLLATERAL_ADAPTER);
309    }
310
311    #[rstest]
312    fn test_encode_split_standard_fixture() {
313        let call = encode_split_position(CONDITION_ID, dec!(1), false).unwrap();
314        assert_eq!(call.target, CTF_COLLATERAL_ADAPTER);
315        assert_eq!(
316            &call.data[..4],
317            selector("splitPosition(address,bytes32,bytes32,uint256[],uint256)")
318        );
319        assert_eq!(
320            format!("0x{}", alloy_primitives::hex::encode(&call.data)),
321            concat!(
322                "0x72ce4275",
323                "000000000000000000000000c011a7e12a19f7b1f670d46f03b03f3342e82dfb",
324                "0000000000000000000000000000000000000000000000000000000000000000",
325                "1111111111111111111111111111111111111111111111111111111111111111",
326                "00000000000000000000000000000000000000000000000000000000000000a0",
327                "00000000000000000000000000000000000000000000000000000000000f4240",
328                "0000000000000000000000000000000000000000000000000000000000000002",
329                "0000000000000000000000000000000000000000000000000000000000000001",
330                "0000000000000000000000000000000000000000000000000000000000000002",
331            )
332        );
333    }
334
335    #[rstest]
336    fn test_encode_merge_neg_risk_fixture() {
337        let call = encode_merge_positions(CONDITION_ID, dec!(1), true).unwrap();
338        assert_eq!(call.target, NEG_RISK_CTF_COLLATERAL_ADAPTER);
339        assert_eq!(
340            &call.data[..4],
341            selector("mergePositions(address,bytes32,bytes32,uint256[],uint256)")
342        );
343        assert_eq!(
344            format!("0x{}", alloy_primitives::hex::encode(&call.data)),
345            concat!(
346                "0x9e7212ad",
347                "000000000000000000000000c011a7e12a19f7b1f670d46f03b03f3342e82dfb",
348                "0000000000000000000000000000000000000000000000000000000000000000",
349                "1111111111111111111111111111111111111111111111111111111111111111",
350                "00000000000000000000000000000000000000000000000000000000000000a0",
351                "00000000000000000000000000000000000000000000000000000000000f4240",
352                "0000000000000000000000000000000000000000000000000000000000000002",
353                "0000000000000000000000000000000000000000000000000000000000000001",
354                "0000000000000000000000000000000000000000000000000000000000000002",
355            )
356        );
357    }
358
359    #[rstest]
360    fn test_encode_redeem_standard_and_neg_risk_share_calldata() {
361        let standard = encode_redeem_positions(CONDITION_ID, false).unwrap();
362        let neg_risk = encode_redeem_positions(CONDITION_ID, true).unwrap();
363        assert_eq!(standard.target, CTF_COLLATERAL_ADAPTER);
364        assert_eq!(neg_risk.target, NEG_RISK_CTF_COLLATERAL_ADAPTER);
365        assert_eq!(standard.data, neg_risk.data);
366        assert_eq!(
367            &standard.data[..4],
368            selector("redeemPositions(address,bytes32,bytes32,uint256[])")
369        );
370        assert_eq!(
371            format!("0x{}", alloy_primitives::hex::encode(&standard.data)),
372            concat!(
373                "0x01b7037c",
374                "000000000000000000000000c011a7e12a19f7b1f670d46f03b03f3342e82dfb",
375                "0000000000000000000000000000000000000000000000000000000000000000",
376                "1111111111111111111111111111111111111111111111111111111111111111",
377                "0000000000000000000000000000000000000000000000000000000000000080",
378                "0000000000000000000000000000000000000000000000000000000000000002",
379                "0000000000000000000000000000000000000000000000000000000000000001",
380                "0000000000000000000000000000000000000000000000000000000000000002",
381            )
382        );
383    }
384
385    #[rstest]
386    fn test_encode_rejects_invalid_condition_id() {
387        let err = encode_split_position("not-a-condition", dec!(1), false).unwrap_err();
388        assert!(err.to_string().contains("Invalid condition_id"));
389    }
390
391    #[rstest]
392    #[case("split", "split(bytes31,uint256)")]
393    #[case("merge", "merge(bytes31,uint256)")]
394    #[case("redeem_yes", "redeem(bytes31,uint256,uint256)")]
395    #[case("redeem_no", "redeem(bytes31,uint256,uint256)")]
396    fn test_encode_v2_router_fixture(
397        #[case] operation: &str,
398        #[case] signature: &str,
399        #[values(false, true)] padded: bool,
400        #[values(1u8, 2u8)] module: u8,
401    ) {
402        let native = format!("0x{module:02x}{}", "23".repeat(30));
403
404        let condition_id = if padded {
405            format!("{native}00")
406        } else {
407            native
408        };
409
410        let call = match operation {
411            "split" => encode_split_position_v2(&condition_id, dec!(1.234567)),
412            "merge" => encode_merge_positions_v2(&condition_id, dec!(1.234567)),
413            "redeem_yes" => encode_redeem_position_v2(&condition_id, 0, dec!(1.234567)),
414            "redeem_no" => encode_redeem_position_v2(&condition_id, 1, dec!(1.234567)),
415            _ => unreachable!(),
416        }
417        .unwrap();
418
419        assert_eq!(
420            format!("{:#x}", call.target),
421            "0x12121212006e4cd160d18e3f00711da5c3372600"
422        );
423        assert_eq!(&call.data[..4], selector(signature));
424        let mut expected = format!("{module:02x}{}00", "23".repeat(30));
425        if operation.starts_with("redeem") {
426            expected.push_str(&format!("{:064x}", u8::from(operation == "redeem_no")));
427        }
428
429        expected.push_str("000000000000000000000000000000000000000000000000000000000012d687");
430        assert_eq!(hex::encode(&call.data[4..]), expected);
431    }
432
433    #[rstest]
434    #[case("0x01")]
435    #[case("01")]
436    #[case("0xzz")]
437    #[case("0x0111111111111111111111111111111111111111111111111111111111111101")]
438    #[case("0x0311111111111111111111111111111111111111111111111111111111111100")]
439    fn test_encode_v2_rejects_invalid_condition(#[case] condition_id: &str) {
440        assert!(encode_split_position_v2(condition_id, dec!(1)).is_err());
441        assert!(encode_merge_positions_v2(condition_id, dec!(1)).is_err());
442        assert!(encode_redeem_position_v2(condition_id, 0, dec!(1)).is_err());
443    }
444
445    #[rstest]
446    #[case(dec!(0))]
447    #[case(dec!(-1))]
448    #[case(dec!(0.0000001))]
449    #[case(Decimal::MAX)]
450    fn test_encode_v2_rejects_invalid_amount(#[case] amount: Decimal) {
451        let condition_id = format!("0x01{}", "23".repeat(30));
452        assert!(encode_split_position_v2(&condition_id, amount).is_err());
453        assert!(encode_merge_positions_v2(&condition_id, amount).is_err());
454        assert!(encode_redeem_position_v2(&condition_id, 1, amount).is_err());
455    }
456
457    #[rstest]
458    #[case(2)]
459    #[case(255)]
460    fn test_encode_v2_rejects_invalid_outcome(#[case] outcome_index: u8) {
461        let condition_id = format!("0x01{}", "23".repeat(30));
462        assert_eq!(
463            encode_redeem_position_v2(&condition_id, outcome_index, dec!(1))
464                .unwrap_err()
465                .to_string(),
466            "bad request: V2 outcome_index must be 0 or 1"
467        );
468    }
469}