polyrel 0.4.0

Unofficial Polymarket relayer client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use alloc::vec::Vec;

use alloy_primitives::{Address, B256, Bytes, U256};
use alloy_sol_types::{SolCall, sol};

use crate::Call;

sol! {
	interface INegRiskAdapter {
		function redeemPositions(bytes32 conditionId, uint256[] amounts) external;
	}
}

/// Builds neg-risk adapter `redeemPositions(conditionId, amounts)` calldata.
pub fn redeem_positions(adapter: Address, condition_id: B256, amounts: Vec<U256>) -> Call {
	let data = Bytes::from(
		INegRiskAdapter::redeemPositionsCall { conditionId: condition_id, amounts }.abi_encode(),
	);

	Call::builder().to(adapter).data(data).build()
}

#[cfg(test)]
mod tests {
	use alloc::vec;

	use alloy_primitives::{Bytes, U256, address, b256};

	use super::*;

	const ADAPTER: Address = address!("1212121212121212121212121212121212121212");
	const CONDITION_ID: B256 =
		b256!("abababababababababababababababababababababababababababababababab");
	const FIRST_AMOUNT: u64 = 5;
	const SECOND_AMOUNT: u64 = 9;
	const EXPECTED_CALLDATA: &str = "dbeccb23abababababababababababababababababababababababababababababababab0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000009";
	const VALID_CALLDATA_FIXTURE: &str = "valid calldata fixture";

	#[test]
	fn redeem_positions_encodes_expected_calldata() {
		// Arrange
		let adapter = ADAPTER;
		let condition_id = CONDITION_ID;
		let amounts = vec![U256::from(FIRST_AMOUNT), U256::from(SECOND_AMOUNT)];
		let expected = bytes(EXPECTED_CALLDATA);

		// Act
		let call = redeem_positions(adapter, condition_id, amounts.clone());

		// Assert
		assert_eq!(call.to(), adapter);
		assert_eq!(call.value(), U256::ZERO);
		assert_eq!(call.data(), &expected);
	}

	fn bytes(hex: &str) -> Bytes {
		let decoded = alloy_primitives::hex::decode(hex).expect(VALID_CALLDATA_FIXTURE);

		Bytes::from(decoded)
	}
}