1use 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#[derive(Clone, Debug, PartialEq, Eq)]
70pub struct PositionCall {
71 pub target: Address,
73 pub data: Bytes,
75}
76
77#[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#[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
110pub 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
138pub 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
166pub 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
187pub 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
207pub 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
227pub 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}