nautilus_blockchain/exchanges/parsing/uniswap_v3/
burn.rs1use alloy::{dyn_abi::SolType, primitives::Address, sol};
17use nautilus_model::defi::{PoolIdentifier, SharedDex, rpc::RpcLog};
18use ustr::Ustr;
19
20use crate::{
21 events::burn::BurnEvent,
22 exchanges::parsing::core,
23 hypersync::{
24 HypersyncLog,
25 log::{
26 extract_address_from_topic, extract_block_hash, extract_block_number,
27 extract_log_index, extract_transaction_hash, extract_transaction_index,
28 validate_event_signature_hash,
29 },
30 },
31 rpc::log as rpc_log,
32};
33
34const BURN_EVENT_SIGNATURE_HASH: &str =
35 "0c396cd989a39f4459b5fa1aed6a9a8dcdbc45908acfd67e028cd568da98982c";
36
37sol! {
41 struct BurnEventData {
42 uint128 amount;
43 uint256 amount0;
44 uint256 amount1;
45 }
46}
47
48pub fn parse_burn_event_hypersync(dex: SharedDex, log: &HypersyncLog) -> anyhow::Result<BurnEvent> {
58 validate_event_signature_hash("Burn", BURN_EVENT_SIGNATURE_HASH, log)?;
59
60 let owner = extract_address_from_topic(log, 1, "owner")?;
61
62 let tick_lower = match log.topics.get(2).and_then(|t| t.as_ref()) {
64 Some(topic) => {
65 let tick_lower_bytes: [u8; 32] = topic.as_ref().try_into()?;
66 i32::from_be_bytes(tick_lower_bytes[28..32].try_into()?)
67 }
68 None => anyhow::bail!("Missing tickLower in topic2 when parsing burn event"),
69 };
70
71 let tick_upper = match log.topics.get(3).and_then(|t| t.as_ref()) {
73 Some(topic) => {
74 let tick_upper_bytes: [u8; 32] = topic.as_ref().try_into()?;
75 i32::from_be_bytes(tick_upper_bytes[28..32].try_into()?)
76 }
77 None => anyhow::bail!("Missing tickUpper in topic3 when parsing burn event"),
78 };
79
80 if let Some(data) = &log.data {
81 let data_bytes = data.as_ref();
82
83 if data_bytes.len() < 3 * 32 {
85 anyhow::bail!("Burn event data is too short");
86 }
87
88 let decoded = match <BurnEventData as SolType>::abi_decode(data_bytes) {
90 Ok(decoded) => decoded,
91 Err(e) => anyhow::bail!("Failed to decode burn event data: {e}"),
92 };
93
94 let pool_address = Address::from_slice(
95 log.address
96 .clone()
97 .expect("Contract address should be set in logs")
98 .as_ref(),
99 );
100 let pool_identifier = PoolIdentifier::Address(Ustr::from(&pool_address.to_string()));
101 Ok(BurnEvent::new(
102 dex,
103 pool_identifier,
104 extract_block_number(log)?,
105 extract_block_hash(log),
106 extract_transaction_hash(log)?,
107 extract_transaction_index(log)?,
108 extract_log_index(log)?,
109 owner,
110 tick_lower,
111 tick_upper,
112 decoded.amount,
113 decoded.amount0,
114 decoded.amount1,
115 ))
116 } else {
117 Err(anyhow::anyhow!("Missing data in burn event log"))
118 }
119}
120
121pub fn parse_burn_event_rpc(dex: SharedDex, log: &RpcLog) -> anyhow::Result<BurnEvent> {
127 rpc_log::validate_event_signature(log, BURN_EVENT_SIGNATURE_HASH, "Burn")?;
128
129 let owner = rpc_log::extract_address_from_topic(log, 1, "owner")?;
130
131 let tick_lower_bytes = rpc_log::extract_topic_bytes(log, 2)?;
133 let tick_lower = core::extract_i32_from_bytes(&tick_lower_bytes)?;
134
135 let tick_upper_bytes = rpc_log::extract_topic_bytes(log, 3)?;
137 let tick_upper = core::extract_i32_from_bytes(&tick_upper_bytes)?;
138
139 let data_bytes = rpc_log::extract_data_bytes(log)?;
140
141 if data_bytes.len() < 3 * 32 {
143 anyhow::bail!("Burn event data is too short");
144 }
145
146 let decoded = match <BurnEventData as SolType>::abi_decode(&data_bytes) {
148 Ok(decoded) => decoded,
149 Err(e) => anyhow::bail!("Failed to decode burn event data: {e}"),
150 };
151
152 let pool_address = rpc_log::extract_address(log)?;
153 let pool_identifier = PoolIdentifier::Address(Ustr::from(&pool_address.to_string()));
154 Ok(BurnEvent::new(
155 dex,
156 pool_identifier,
157 rpc_log::extract_block_number(log)?,
158 rpc_log::extract_block_hash(log)?,
159 rpc_log::extract_transaction_hash(log)?,
160 rpc_log::extract_transaction_index(log)?,
161 rpc_log::extract_log_index(log)?,
162 owner,
163 tick_lower,
164 tick_upper,
165 decoded.amount,
166 decoded.amount0,
167 decoded.amount1,
168 ))
169}
170
171#[cfg(test)]
172mod tests {
173 use std::{str::FromStr, sync::Arc};
174
175 use alloy::primitives::{B256, U256};
176 use rstest::*;
177 use serde_json::json;
178
179 use super::*;
180 use crate::exchanges::arbitrum;
181
182 #[fixture]
188 fn hypersync_log() -> HypersyncLog {
189 let log_json = json!({
190 "removed": null,
191 "log_index": "0xd",
192 "transaction_index": "0x5",
193 "transaction_hash": "0x0c70f6d6bcf8508ba620b9d1250c95ad67108e35707c5d7456349ea207051bae",
194 "block_hash": null,
195 "block_number": "0x175a6484",
196 "address": "0xd13040d4fe917EE704158CfCB3338dCd2838B245",
197 "data": "0x00000000000000000000000000000000000000000002bc997c8ea58d3a8521ec0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000065b33ff853688eb",
198 "topics": [
199 "0x0c396cd989a39f4459b5fa1aed6a9a8dcdbc45908acfd67e028cd568da98982c",
200 "0x000000000000000000000000c36442b4a4522e871399cd717abdd847ab11fe88",
201 "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdde09",
202 "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdde0c"
203 ]
204 });
205 serde_json::from_value(log_json).expect("Failed to deserialize HyperSync log")
206 }
207
208 #[fixture]
210 fn rpc_log() -> RpcLog {
211 let log_json = json!({
212 "removed": false,
213 "logIndex": "0xd",
214 "transactionIndex": "0x5",
215 "transactionHash": "0x0c70f6d6bcf8508ba620b9d1250c95ad67108e35707c5d7456349ea207051bae",
216 "blockHash": "0xe925eaa1f5178ceedfa24043a974edb928ddab7195600b6b99ff5403fbf13c8b",
217 "blockNumber": "0x175a6484",
218 "address": "0xd13040d4fe917EE704158CfCB3338dCd2838B245",
219 "data": "0x00000000000000000000000000000000000000000002bc997c8ea58d3a8521ec0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000065b33ff853688eb",
220 "topics": [
221 "0x0c396cd989a39f4459b5fa1aed6a9a8dcdbc45908acfd67e028cd568da98982c",
222 "0x000000000000000000000000c36442b4a4522e871399cd717abdd847ab11fe88",
223 "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdde09",
224 "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdde0c"
225 ]
226 });
227 serde_json::from_value(log_json).expect("Failed to deserialize RPC log")
228 }
229
230 #[rstest]
231 fn test_parse_burn_event_hypersync(hypersync_log: HypersyncLog) {
232 let dex = Arc::clone(&arbitrum::UNISWAP_V3.dex);
233 let event = parse_burn_event_hypersync(dex, &hypersync_log).unwrap();
234
235 assert_eq!(event.block_hash, None);
236
237 assert_eq!(
238 event.pool_identifier.to_string(),
239 "0xd13040d4fe917EE704158CfCB3338dCd2838B245"
240 );
241 assert_eq!(
242 event.owner.to_string().to_lowercase(),
243 "0xc36442b4a4522e871399cd717abdd847ab11fe88"
244 );
245 assert_eq!(event.tick_lower, -139767);
246 assert_eq!(event.tick_upper, -139764);
247 let expected_amount = u128::from_str_radix("2bc997c8ea58d3a8521ec", 16).unwrap();
248 assert_eq!(event.amount, expected_amount);
249 assert_eq!(event.amount0, U256::ZERO);
250 let expected_amount1 = U256::from_str_radix("65b33ff853688eb", 16).unwrap();
251 assert_eq!(event.amount1, expected_amount1);
252 assert_eq!(event.block_number, 391799940);
253 }
254
255 #[rstest]
256 fn test_parse_burn_event_rpc(rpc_log: RpcLog) {
257 let dex = Arc::clone(&arbitrum::UNISWAP_V3.dex);
258 let event = parse_burn_event_rpc(dex, &rpc_log).unwrap();
259
260 let expected =
261 B256::from_str("0xe925eaa1f5178ceedfa24043a974edb928ddab7195600b6b99ff5403fbf13c8b")
262 .unwrap();
263 assert_eq!(event.block_hash, Some(expected));
264
265 assert_eq!(
266 event.pool_identifier.to_string(),
267 "0xd13040d4fe917EE704158CfCB3338dCd2838B245"
268 );
269 assert_eq!(
270 event.owner.to_string().to_lowercase(),
271 "0xc36442b4a4522e871399cd717abdd847ab11fe88"
272 );
273 assert_eq!(event.tick_lower, -139767);
274 assert_eq!(event.tick_upper, -139764);
275 let expected_amount = u128::from_str_radix("2bc997c8ea58d3a8521ec", 16).unwrap();
276 assert_eq!(event.amount, expected_amount);
277 assert_eq!(event.amount0, U256::ZERO);
278 let expected_amount1 = U256::from_str_radix("65b33ff853688eb", 16).unwrap();
279 assert_eq!(event.amount1, expected_amount1);
280 assert_eq!(event.block_number, 391799940);
281 }
282
283 #[rstest]
284 #[case(2, 1)]
285 #[case(3, 1)]
286 #[case(2, 31)]
287 #[case(2, 33)]
288 fn test_parse_burn_event_rpc_rejects_noncanonical_tick_topic(
289 mut rpc_log: RpcLog,
290 #[case] topic_index: usize,
291 #[case] byte_len: usize,
292 ) {
293 let valid_log = rpc_log.clone();
294 rpc_log.topics[topic_index] = format!("0x{}", "00".repeat(byte_len));
295 let dex = Arc::clone(&arbitrum::UNISWAP_V3.dex);
296
297 let error = parse_burn_event_rpc(Arc::clone(&dex), &rpc_log).unwrap_err();
298 let event = parse_burn_event_rpc(dex, &valid_log).unwrap();
299
300 assert_eq!(
301 error.to_string(),
302 format!("Topic must be 32 bytes, was {byte_len}")
303 );
304 assert_eq!(event.block_number, 391799940);
305 }
306
307 #[rstest]
308 fn test_hypersync_rpc_match(hypersync_log: HypersyncLog, rpc_log: RpcLog) {
309 let dex = Arc::clone(&arbitrum::UNISWAP_V3.dex);
310 let event_hypersync = parse_burn_event_hypersync(Arc::clone(&dex), &hypersync_log).unwrap();
311 let event_rpc = parse_burn_event_rpc(dex, &rpc_log).unwrap();
312
313 assert_eq!(event_hypersync.pool_identifier, event_rpc.pool_identifier);
314 assert_eq!(event_hypersync.owner, event_rpc.owner);
315 assert_eq!(event_hypersync.tick_lower, event_rpc.tick_lower);
316 assert_eq!(event_hypersync.tick_upper, event_rpc.tick_upper);
317 assert_eq!(event_hypersync.amount, event_rpc.amount);
318 assert_eq!(event_hypersync.amount0, event_rpc.amount0);
319 assert_eq!(event_hypersync.amount1, event_rpc.amount1);
320 assert_eq!(event_hypersync.block_number, event_rpc.block_number);
321 assert_eq!(event_hypersync.transaction_hash, event_rpc.transaction_hash);
322 }
323}