fynd_client/
mapping.rs

1//! Conversions between client types and the Fynd RPC server's DTO types.
2//!
3//! Uses `fynd-rpc-types` directly for the DTO format, providing compile-time
4//! compatibility guarantees with the server.
5
6use fynd_rpc_types as dto;
7use fynd_rpc_types::OrderQuote;
8
9use crate::{
10    error::{ErrorCode, FyndError},
11    types::{
12        BackendKind, BatchQuoteParams, BlockInfo, EncodingOptions, FeeBreakdown, HealthStatus,
13        Order, OrderSide, PermitDetails, PermitSingle, Quote, QuoteOptions, QuoteParams,
14        QuoteStatus, Route, Swap, Transaction, UserTransferType,
15    },
16};
17// ============================================================================
18// ADDRESS CONVERSION HELPERS
19// ============================================================================
20
21pub(crate) fn bytes_to_alloy_address(
22    b: &bytes::Bytes,
23) -> Result<alloy::primitives::Address, FyndError> {
24    let arr: [u8; 20] = b.as_ref().try_into().map_err(|_| {
25        FyndError::Protocol(format!("expected 20-byte address, got {} bytes", b.len()))
26    })?;
27
28    Ok(alloy::primitives::Address::from(arr))
29}
30
31/// Wrap a client `bytes::Bytes` address as a DTO address, validating the 20-byte length.
32fn bytes_to_dto_addr(b: &bytes::Bytes) -> Result<dto::Bytes, FyndError> {
33    if b.len() != 20 {
34        return Err(FyndError::Protocol(format!("expected 20-byte address, got {} bytes", b.len())));
35    }
36    Ok(dto::Bytes::from(b.as_ref()))
37}
38
39/// Unwrap a DTO address back to a client `bytes::Bytes`.
40fn dto_addr_to_bytes(b: dto::Bytes) -> bytes::Bytes {
41    b.0
42}
43
44// ============================================================================
45// PRIMITIVE CONVERSIONS
46// ============================================================================
47
48/// Convert a [`num_bigint::BigUint`] to an [`alloy::primitives::U256`].
49pub(crate) fn biguint_to_u256(n: &num_bigint::BigUint) -> alloy::primitives::U256 {
50    alloy::primitives::U256::from_be_slice(&n.to_bytes_be())
51}
52
53// ============================================================================
54// CLIENT TYPES → DTO FORMAT
55// ============================================================================
56
57pub(crate) fn quote_params_to_dto(params: QuoteParams) -> Result<dto::QuoteRequest, FyndError> {
58    let order = dto::Order::try_from(params.order)?;
59    let options = dto::QuoteOptions::try_from(params.options)?;
60    Ok(dto::QuoteRequest::new(vec![order]).with_options(options))
61}
62
63/// Converts [`BatchQuoteParams`] into a DTO request plus per-order `(token_out, receiver)`
64/// metadata.
65///
66/// The metadata vec is index-aligned with the DTO orders and must be threaded through to
67/// [`map_quote_response`] so each response quote gets the correct token/receiver fields.
68pub(crate) fn batch_quote_params_to_dto(
69    params: BatchQuoteParams,
70) -> Result<(dto::QuoteRequest, Vec<(bytes::Bytes, bytes::Bytes)>), FyndError> {
71    if params.orders.is_empty() {
72        return Err(FyndError::Protocol("batch_quote requires at least one order".into()));
73    }
74    let options = dto::QuoteOptions::try_from(params.options)?;
75    let mut dto_orders = Vec::with_capacity(params.orders.len());
76    let mut order_meta = Vec::with_capacity(params.orders.len());
77    for order in params.orders {
78        let token_out = order.token_out().clone();
79        let receiver = order
80            .receiver()
81            .unwrap_or_else(|| order.sender())
82            .clone();
83        dto_orders.push(dto::Order::try_from(order)?);
84        order_meta.push((token_out, receiver));
85    }
86    let request = dto::QuoteRequest::new(dto_orders).with_options(options);
87    Ok((request, order_meta))
88}
89
90impl TryFrom<Order> for dto::Order {
91    type Error = FyndError;
92
93    fn try_from(order: Order) -> Result<Self, Self::Error> {
94        let token_in = bytes_to_dto_addr(order.token_in())?;
95        let token_out = bytes_to_dto_addr(order.token_out())?;
96        let sender = bytes_to_dto_addr(order.sender())?;
97        let receiver = order
98            .receiver()
99            .map(bytes_to_dto_addr)
100            .transpose()?;
101        let mut dto_order = dto::Order::new(
102            token_in,
103            token_out,
104            order.amount().clone(),
105            order.side().into(),
106            sender,
107        );
108        if let Some(r) = receiver {
109            dto_order = dto_order.with_receiver(r);
110        }
111        Ok(dto_order)
112    }
113}
114
115impl From<OrderSide> for dto::OrderSide {
116    fn from(side: OrderSide) -> Self {
117        match side {
118            OrderSide::Sell => dto::OrderSide::Sell,
119        }
120    }
121}
122
123impl TryFrom<QuoteOptions> for dto::QuoteOptions {
124    type Error = FyndError;
125
126    fn try_from(opts: QuoteOptions) -> Result<Self, Self::Error> {
127        let mut dto_opts = dto::QuoteOptions::default();
128        if let Some(ms) = opts.timeout_ms {
129            dto_opts = dto_opts.with_timeout_ms(ms);
130        }
131        if let Some(n) = opts.min_responses {
132            dto_opts = dto_opts.with_min_responses(n);
133        }
134        if let Some(gas) = opts.max_gas {
135            dto_opts = dto_opts.with_max_gas(gas);
136        }
137        if let Some(enc) = opts.encoding_options {
138            dto_opts = dto_opts.with_encoding_options(dto::EncodingOptions::try_from(enc)?);
139        }
140        Ok(dto_opts)
141    }
142}
143
144impl TryFrom<EncodingOptions> for dto::EncodingOptions {
145    type Error = FyndError;
146
147    fn try_from(opts: EncodingOptions) -> Result<Self, Self::Error> {
148        let mut dto_opts =
149            dto::EncodingOptions::new(opts.slippage).with_transfer_type(opts.transfer_type.into());
150        if let (Some(permit), Some(sig)) = (
151            opts.permit
152                .map(dto::PermitSingle::try_from)
153                .transpose()?,
154            opts.permit2_signature
155                .map(|b| dto::Bytes::from(b.as_ref())),
156        ) {
157            dto_opts = dto_opts.with_permit2(permit, sig);
158        }
159        if let Some(fee) = opts.client_fee_params {
160            dto_opts = dto_opts.with_client_fee_params(dto::ClientFeeParams::new(
161                fee.bps,
162                dto::Bytes::from(fee.receiver.as_ref()),
163                fee.max_contribution,
164                fee.deadline,
165                dto::Bytes::from(
166                    fee.signature
167                        .unwrap_or_default()
168                        .as_ref(),
169                ),
170            ));
171        }
172        if let Some(pg) = opts.price_guard {
173            dto_opts = dto_opts.with_price_guard(pg);
174        }
175        Ok(dto_opts)
176    }
177}
178
179impl TryFrom<PermitSingle> for dto::PermitSingle {
180    type Error = FyndError;
181
182    fn try_from(p: PermitSingle) -> Result<Self, Self::Error> {
183        let details = dto::PermitDetails::try_from(p.details)?;
184        let spender = bytes_to_dto_addr(&p.spender)?;
185        Ok(dto::PermitSingle::new(details, spender, p.sig_deadline))
186    }
187}
188
189impl TryFrom<PermitDetails> for dto::PermitDetails {
190    type Error = FyndError;
191
192    fn try_from(d: PermitDetails) -> Result<Self, Self::Error> {
193        let token = bytes_to_dto_addr(&d.token)?;
194        Ok(dto::PermitDetails::new(token, d.amount, d.expiration, d.nonce))
195    }
196}
197
198impl From<UserTransferType> for dto::UserTransferType {
199    fn from(t: UserTransferType) -> Self {
200        match t {
201            UserTransferType::TransferFrom => dto::UserTransferType::TransferFrom,
202            UserTransferType::TransferFromPermit2 => dto::UserTransferType::TransferFromPermit2,
203            UserTransferType::UseVaultsFunds => dto::UserTransferType::UseVaultsFunds,
204        }
205    }
206}
207
208// ============================================================================
209// DTO FORMAT → CLIENT TYPES
210// ============================================================================
211
212fn order_quote_to_quote(
213    order_quote: OrderQuote,
214    token_out: bytes::Bytes,
215    receiver: bytes::Bytes,
216) -> Result<Quote, FyndError> {
217    let status = QuoteStatus::from(order_quote.status());
218    let route = order_quote
219        .route()
220        .cloned()
221        .map(Route::try_from)
222        .transpose()?;
223    let block = BlockInfo::from(order_quote.block().clone());
224    let transaction = order_quote
225        .transaction()
226        .cloned()
227        .map(Transaction::from);
228    let fee_breakdown = order_quote.fee_breakdown().map(|fb| {
229        let swaps_hash = fb.swaps_hash().and_then(|b| {
230            let arr: [u8; 32] = b.0.as_ref().try_into().ok()?;
231            Some(arr)
232        });
233        FeeBreakdown::new(
234            fb.router_fee().clone(),
235            fb.client_fee().clone(),
236            fb.max_slippage().clone(),
237            fb.min_amount_received().clone(),
238            swaps_hash,
239        )
240    });
241    Ok(Quote::new(
242        order_quote.order_id().to_string(),
243        status,
244        BackendKind::Fynd,
245        route,
246        order_quote.amount_in().clone(),
247        order_quote.amount_out().clone(),
248        order_quote.gas_estimate().clone(),
249        order_quote.amount_out_net_gas().clone(),
250        order_quote.price_impact_bps(),
251        block,
252        token_out,
253        receiver,
254        transaction,
255        fee_breakdown,
256    ))
257}
258
259impl From<dto::Transaction> for Transaction {
260    fn from(dt: dto::Transaction) -> Self {
261        let mut tx = Transaction::new(
262            bytes::Bytes::copy_from_slice(dt.to().as_ref()),
263            dt.value().clone(),
264            dt.data().to_vec(),
265        );
266        if let Some(offset) = dt.client_fee_signature_offset() {
267            tx.client_fee_signature_offset = Some(offset);
268        }
269        tx
270    }
271}
272
273/// Maps a quote response to client [`Quote`]s using per-order `(token_out, receiver)` metadata.
274///
275/// `order_meta` must be index-aligned with the orders in the original request. Returns an error
276/// if the response order count differs from `order_meta.len()`. `solve_time_ms` from the response
277/// is propagated to every returned quote.
278pub(crate) fn map_quote_response(
279    response: dto::Quote,
280    order_meta: Vec<(bytes::Bytes, bytes::Bytes)>,
281) -> Result<Vec<Quote>, FyndError> {
282    let solve_time_ms = response.solve_time_ms();
283    let order_quotes = response.into_orders();
284    if order_quotes.len() != order_meta.len() {
285        return Err(FyndError::Protocol(format!(
286            "server returned {} quotes but {} were requested",
287            order_quotes.len(),
288            order_meta.len()
289        )));
290    }
291    order_quotes
292        .into_iter()
293        .zip(order_meta)
294        .map(|(oq, (token_out, receiver))| {
295            let mut quote = order_quote_to_quote(oq, token_out, receiver)?;
296            quote.solve_time_ms = solve_time_ms;
297            Ok(quote)
298        })
299        .collect()
300}
301
302impl From<dto::QuoteStatus> for QuoteStatus {
303    fn from(ds: dto::QuoteStatus) -> Self {
304        match ds {
305            dto::QuoteStatus::Success => Self::Success,
306            dto::QuoteStatus::NoRouteFound => Self::NoRouteFound,
307            dto::QuoteStatus::InsufficientLiquidity => Self::InsufficientLiquidity,
308            dto::QuoteStatus::Timeout => Self::Timeout,
309            dto::QuoteStatus::NotReady => Self::NotReady,
310            dto::QuoteStatus::PriceCheckFailed => Self::PriceCheckFailed,
311            _ => Self::NotReady,
312        }
313    }
314}
315
316impl TryFrom<dto::Route> for Route {
317    type Error = FyndError;
318
319    fn try_from(dr: dto::Route) -> Result<Self, Self::Error> {
320        let swaps = dr
321            .into_swaps()
322            .into_iter()
323            .map(Swap::try_from)
324            .collect::<Result<Vec<_>, _>>()?;
325        Ok(Route::new(swaps))
326    }
327}
328
329impl TryFrom<dto::Swap> for Swap {
330    type Error = FyndError;
331
332    fn try_from(ds: dto::Swap) -> Result<Self, Self::Error> {
333        let token_in = dto_addr_to_bytes(ds.token_in().clone());
334        let token_out = dto_addr_to_bytes(ds.token_out().clone());
335        Ok(Swap::new(
336            ds.component_id().to_string(),
337            ds.protocol().to_string(),
338            token_in,
339            token_out,
340            ds.amount_in().clone(),
341            ds.amount_out().clone(),
342            ds.gas_estimate().clone(),
343            ds.split(),
344        ))
345    }
346}
347
348impl From<dto::BlockInfo> for BlockInfo {
349    fn from(db: dto::BlockInfo) -> Self {
350        BlockInfo::new(db.number(), db.hash().to_string(), db.timestamp())
351    }
352}
353
354impl TryFrom<fynd_rpc_types::InstanceInfo> for crate::types::InstanceInfo {
355    type Error = FyndError;
356
357    fn try_from(dto: fynd_rpc_types::InstanceInfo) -> Result<Self, Self::Error> {
358        let router = bytes::Bytes::copy_from_slice(dto.router_address().as_ref());
359        let permit2 = bytes::Bytes::copy_from_slice(dto.permit2_address().as_ref());
360        if router.len() != 20 {
361            return Err(FyndError::Protocol(format!(
362                "router_address must be 20 bytes, got {}",
363                router.len()
364            )));
365        }
366        if permit2.len() != 20 {
367            return Err(FyndError::Protocol(format!(
368                "permit2_address must be 20 bytes, got {}",
369                permit2.len()
370            )));
371        }
372        Ok(crate::types::InstanceInfo::new(router, permit2, dto.chain_id()))
373    }
374}
375
376impl From<dto::HealthStatus> for HealthStatus {
377    fn from(dh: dto::HealthStatus) -> Self {
378        HealthStatus::new(
379            dh.healthy(),
380            dh.last_update_ms(),
381            dh.num_solver_pools(),
382            dh.derived_data_ready(),
383            dh.gas_price_age_ms(),
384        )
385    }
386}
387
388// ============================================================================
389// ERROR CONVERSION
390// ============================================================================
391
392pub(crate) fn dto_error_to_fynd(de: dto::ErrorResponse) -> FyndError {
393    let code = ErrorCode::from_server_code(de.code());
394    FyndError::Api { code, message: de.error().to_string() }
395}
396
397#[cfg(test)]
398mod tests {
399    use bytes::Bytes;
400    use num_bigint::BigUint;
401
402    use super::*;
403
404    fn sample_dto_swap() -> dto::Swap {
405        serde_json::from_str(
406            r#"{
407            "component_id": "pool-1",
408            "protocol": "uniswap-v3",
409            "token_in": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
410            "token_out": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
411            "amount_in": "100",
412            "amount_out": "99",
413            "gas_estimate": "50000",
414            "split": "0"
415        }"#,
416        )
417        .expect("valid swap JSON")
418    }
419
420    fn sample_dto_block() -> dto::BlockInfo {
421        serde_json::from_str(
422            r#"{
423            "number": 21000000,
424            "hash": "0xdeadbeef",
425            "timestamp": 1730000000
426        }"#,
427        )
428        .expect("valid block JSON")
429    }
430
431    fn sample_dto_order_quote() -> dto::OrderQuote {
432        serde_json::from_str(
433            r#"{
434            "order_id": "test-order-id",
435            "status": "success",
436            "amount_in": "1000",
437            "amount_out": "999",
438            "gas_estimate": "100000",
439            "price_impact_bps": 5,
440            "amount_out_net_gas": "998",
441            "block": {"number": 21000000, "hash": "0xdeadbeef", "timestamp": 1730000000}
442        }"#,
443        )
444        .expect("valid order quote JSON")
445    }
446
447    // -----------------------------------------------------------------------
448    // biguint_to_u256
449    // -----------------------------------------------------------------------
450
451    #[test]
452    fn biguint_to_u256_zero() {
453        let result = biguint_to_u256(&BigUint::ZERO);
454        assert_eq!(result, alloy::primitives::U256::ZERO);
455    }
456
457    #[test]
458    fn biguint_to_u256_known_value() {
459        let n = BigUint::from(0x1234_5678u64);
460        let result = biguint_to_u256(&n);
461        assert_eq!(result, alloy::primitives::U256::from(0x1234_5678u64));
462    }
463
464    // -----------------------------------------------------------------------
465    // Transaction conversion
466    // -----------------------------------------------------------------------
467
468    #[test]
469    fn transaction_from_dto() {
470        let router_bytes = vec![0x01u8; 20];
471        let dto_tx = dto::Transaction::new(
472            dto::Bytes::from(router_bytes.as_slice()),
473            BigUint::ZERO,
474            vec![0x12, 0x34],
475        );
476        let tx = Transaction::from(dto_tx);
477        assert_eq!(tx.to().as_ref(), router_bytes.as_slice());
478        assert_eq!(tx.value(), &BigUint::ZERO);
479        assert_eq!(tx.data(), &[0x12, 0x34]);
480    }
481
482    // -----------------------------------------------------------------------
483    // bytes_to_alloy_address
484    // -----------------------------------------------------------------------
485
486    #[test]
487    fn bytes_to_alloy_address_happy_path() {
488        let b = Bytes::copy_from_slice(&[0xab; 20]);
489        let addr = bytes_to_alloy_address(&b).unwrap();
490        assert_eq!(addr.as_slice(), &[0xab; 20]);
491    }
492
493    #[test]
494    fn bytes_to_alloy_address_wrong_length() {
495        let b = Bytes::copy_from_slice(&[0xab; 4]);
496        assert!(matches!(bytes_to_alloy_address(&b), Err(FyndError::Protocol(_))));
497    }
498
499    // -----------------------------------------------------------------------
500    // Swap conversion
501    // -----------------------------------------------------------------------
502
503    #[test]
504    fn swap_try_from_dto_happy_path() {
505        let client_swap = Swap::try_from(sample_dto_swap()).unwrap();
506        assert_eq!(client_swap.component_id(), "pool-1");
507        assert_eq!(client_swap.protocol(), "uniswap-v3");
508        assert_eq!(client_swap.token_in(), &Bytes::copy_from_slice(&[0xaa; 20]));
509        assert_eq!(client_swap.token_out(), &Bytes::copy_from_slice(&[0xbb; 20]));
510        assert_eq!(client_swap.amount_in(), &BigUint::from(100u32));
511        assert_eq!(client_swap.amount_out(), &BigUint::from(99u32));
512        assert_eq!(client_swap.gas_estimate(), &BigUint::from(50_000u32));
513    }
514
515    // -----------------------------------------------------------------------
516    // QuoteStatus conversion
517    // -----------------------------------------------------------------------
518
519    #[test]
520    fn quote_status_all_variants() {
521        use dto::QuoteStatus as Dto;
522        assert!(matches!(QuoteStatus::from(Dto::Success), QuoteStatus::Success));
523        assert!(matches!(QuoteStatus::from(Dto::NoRouteFound), QuoteStatus::NoRouteFound));
524        assert!(matches!(
525            QuoteStatus::from(Dto::InsufficientLiquidity),
526            QuoteStatus::InsufficientLiquidity
527        ));
528        assert!(matches!(QuoteStatus::from(Dto::Timeout), QuoteStatus::Timeout));
529        assert!(matches!(QuoteStatus::from(Dto::NotReady), QuoteStatus::NotReady));
530        assert!(matches!(QuoteStatus::from(Dto::PriceCheckFailed), QuoteStatus::PriceCheckFailed));
531    }
532
533    // -----------------------------------------------------------------------
534    // BlockInfo conversion
535    // -----------------------------------------------------------------------
536
537    #[test]
538    fn block_info_from_dto() {
539        let dto_block = sample_dto_block();
540        let block = BlockInfo::from(dto_block);
541        assert_eq!(block.number(), 21_000_000);
542        assert_eq!(block.hash(), "0xdeadbeef");
543        assert_eq!(block.timestamp(), 1_730_000_000);
544    }
545
546    // -----------------------------------------------------------------------
547    // OrderQuote conversion
548    // -----------------------------------------------------------------------
549
550    #[test]
551    fn quote_from_dto() {
552        let ds = sample_dto_order_quote();
553        let quote = order_quote_to_quote(ds, Bytes::new(), Bytes::new()).unwrap();
554        assert_eq!(quote.order_id(), "test-order-id");
555        assert!(matches!(quote.status(), QuoteStatus::Success));
556        assert!(matches!(quote.backend(), BackendKind::Fynd));
557        assert_eq!(quote.amount_in(), &BigUint::from(1_000u32));
558        assert_eq!(quote.amount_out(), &BigUint::from(999u32));
559        assert_eq!(quote.gas_estimate(), &BigUint::from(100_000u32));
560        assert_eq!(quote.amount_out_net_gas(), &BigUint::from(998u32));
561        assert_eq!(quote.price_impact_bps(), Some(5));
562        // token_out and receiver are left empty until populated by quote()
563        assert!(quote.token_out().is_empty());
564        assert!(quote.receiver().is_empty());
565    }
566
567    // -----------------------------------------------------------------------
568    // Order → dto::Order conversion
569    // -----------------------------------------------------------------------
570
571    #[test]
572    fn order_try_from_client_encodes_addresses_as_tycho() {
573        let order = Order::new(
574            Bytes::copy_from_slice(&[0xaa; 20]),
575            Bytes::copy_from_slice(&[0xbb; 20]),
576            BigUint::from(1_000u32),
577            OrderSide::Sell,
578            Bytes::copy_from_slice(&[0xcc; 20]),
579            None,
580        );
581
582        let dto_order = dto::Order::try_from(order).unwrap();
583        assert_eq!(dto_order.token_in().as_ref(), &[0xaa; 20]);
584        assert_eq!(dto_order.token_out().as_ref(), &[0xbb; 20]);
585        assert_eq!(dto_order.sender().as_ref(), &[0xcc; 20]);
586        assert!(dto_order.receiver().is_none());
587        assert_eq!(dto_order.amount(), &BigUint::from(1_000u32));
588    }
589
590    #[test]
591    fn order_try_from_client_with_receiver() {
592        let order = Order::new(
593            Bytes::copy_from_slice(&[0xaa; 20]),
594            Bytes::copy_from_slice(&[0xbb; 20]),
595            BigUint::from(1u32),
596            OrderSide::Sell,
597            Bytes::copy_from_slice(&[0xcc; 20]),
598            Some(Bytes::copy_from_slice(&[0xdd; 20])),
599        );
600
601        let dto_order = dto::Order::try_from(order).unwrap();
602        let receiver = dto_order.receiver().unwrap();
603        assert_eq!(receiver.as_ref(), &[0xdd; 20]);
604    }
605
606    #[test]
607    fn order_try_from_client_invalid_address_length() {
608        let order = Order::new(
609            Bytes::copy_from_slice(&[0xaa; 4]), // wrong length
610            Bytes::copy_from_slice(&[0xbb; 20]),
611            BigUint::from(1u32),
612            OrderSide::Sell,
613            Bytes::copy_from_slice(&[0xcc; 20]),
614            None,
615        );
616        assert!(matches!(dto::Order::try_from(order), Err(FyndError::Protocol(_))));
617    }
618
619    // -----------------------------------------------------------------------
620    // UserTransferType mapping
621    // -----------------------------------------------------------------------
622
623    #[test]
624    fn user_transfer_type_permit2_maps_correctly() {
625        let result = dto::UserTransferType::from(UserTransferType::TransferFromPermit2);
626        assert!(matches!(result, dto::UserTransferType::TransferFromPermit2));
627    }
628
629    #[test]
630    fn user_transfer_type_vault_funds_maps_correctly() {
631        let result = dto::UserTransferType::from(UserTransferType::UseVaultsFunds);
632        assert!(matches!(result, dto::UserTransferType::UseVaultsFunds));
633    }
634
635    // -----------------------------------------------------------------------
636    // PermitDetails TryFrom
637    // -----------------------------------------------------------------------
638
639    #[test]
640    fn permit_details_try_from_happy_path() {
641        let details = PermitDetails::new(
642            Bytes::copy_from_slice(&[0xaa; 20]),
643            BigUint::from(1_000u32),
644            BigUint::from(9_999_999u32),
645            BigUint::from(0u32),
646        );
647        let dto_details = dto::PermitDetails::try_from(details).unwrap();
648        assert_eq!(dto_details.token().as_ref(), &[0xaa; 20]);
649        assert_eq!(dto_details.amount(), &BigUint::from(1_000u32));
650        assert_eq!(dto_details.expiration(), &BigUint::from(9_999_999u32));
651        assert_eq!(dto_details.nonce(), &BigUint::from(0u32));
652    }
653
654    #[test]
655    fn permit_details_try_from_invalid_token() {
656        let details = PermitDetails::new(
657            Bytes::copy_from_slice(&[0xaa; 4]), // wrong length
658            BigUint::from(1u32),
659            BigUint::from(1u32),
660            BigUint::from(0u32),
661        );
662        assert!(matches!(dto::PermitDetails::try_from(details), Err(FyndError::Protocol(_))));
663    }
664
665    // -----------------------------------------------------------------------
666    // PermitSingle TryFrom
667    // -----------------------------------------------------------------------
668
669    #[test]
670    fn permit_single_try_from_happy_path() {
671        let details = PermitDetails::new(
672            Bytes::copy_from_slice(&[0xaa; 20]),
673            BigUint::from(500u32),
674            BigUint::from(1_000_000u32),
675            BigUint::from(1u32),
676        );
677        let permit = PermitSingle::new(
678            details,
679            Bytes::copy_from_slice(&[0xbb; 20]),
680            BigUint::from(2_000_000u32),
681        );
682        let dto_permit = dto::PermitSingle::try_from(permit).unwrap();
683        assert_eq!(dto_permit.spender().as_ref(), &[0xbb; 20]);
684        assert_eq!(dto_permit.sig_deadline(), &BigUint::from(2_000_000u32));
685        assert_eq!(dto_permit.details().amount(), &BigUint::from(500u32));
686    }
687
688    // -----------------------------------------------------------------------
689    // EncodingOptions TryFrom with permit2
690    // -----------------------------------------------------------------------
691
692    #[test]
693    fn encoding_options_try_from_with_permit2() {
694        use crate::types::{EncodingOptions, PermitDetails, PermitSingle};
695
696        let details = PermitDetails::new(
697            Bytes::copy_from_slice(&[0xaa; 20]),
698            BigUint::from(1_000u32),
699            BigUint::from(9_999_999u32),
700            BigUint::from(0u32),
701        );
702        let permit = PermitSingle::new(
703            details,
704            Bytes::copy_from_slice(&[0xbb; 20]),
705            BigUint::from(9_999_999u32),
706        );
707        let sig = Bytes::copy_from_slice(&[0xcc; 65]);
708        let opts = EncodingOptions::new(0.005)
709            .with_permit2(permit, sig.clone())
710            .unwrap();
711
712        let dto_opts = dto::EncodingOptions::try_from(opts).unwrap();
713        assert!(matches!(dto_opts.transfer_type(), dto::UserTransferType::TransferFromPermit2));
714        assert!(dto_opts.permit().is_some());
715        assert_eq!(
716            dto_opts
717                .permit2_signature()
718                .unwrap()
719                .as_ref(),
720            sig.as_ref()
721        );
722    }
723
724    // -----------------------------------------------------------------------
725    // EncodingOptions TryFrom with client fee
726    // -----------------------------------------------------------------------
727
728    #[test]
729    fn encoding_options_try_from_with_client_fee() {
730        use crate::types::{ClientFeeParams, EncodingOptions};
731
732        let fee = ClientFeeParams::new(
733            100,
734            Bytes::copy_from_slice(&[0x44; 20]),
735            BigUint::from(500_000u64),
736            1_893_456_000u64,
737        )
738        .with_signature(Bytes::copy_from_slice(&[0xAB; 65]));
739        let opts = EncodingOptions::new(0.01).with_client_fee(fee);
740
741        let dto_opts = dto::EncodingOptions::try_from(opts).unwrap();
742        assert!(dto_opts.client_fee_params().is_some());
743        let dto_fee = dto_opts.client_fee_params().unwrap();
744        assert_eq!(dto_fee.bps(), 100);
745        assert_eq!(*dto_fee.max_contribution(), BigUint::from(500_000u64));
746        assert_eq!(dto_fee.deadline(), 1_893_456_000u64);
747        assert_eq!(dto_fee.signature().len(), 65);
748    }
749
750    #[test]
751    fn encoding_options_try_from_without_client_fee() {
752        use crate::types::EncodingOptions;
753
754        let opts = EncodingOptions::new(0.005);
755        let dto_opts = dto::EncodingOptions::try_from(opts).unwrap();
756        assert!(dto_opts.client_fee_params().is_none());
757    }
758
759    // -----------------------------------------------------------------------
760    // batch_quote_params_to_dto
761    // -----------------------------------------------------------------------
762
763    #[test]
764    fn batch_quote_params_to_dto_empty_orders_errors() {
765        use crate::types::{BatchQuoteParams, QuoteOptions};
766
767        let params = BatchQuoteParams::new(vec![], QuoteOptions::default());
768        assert!(matches!(batch_quote_params_to_dto(params), Err(FyndError::Protocol(_))));
769    }
770
771    #[test]
772    fn batch_quote_params_to_dto_extracts_per_order_meta() {
773        use crate::types::{BatchQuoteParams, Order, OrderSide, QuoteOptions};
774
775        let token_in_a = Bytes::copy_from_slice(&[0xaa; 20]);
776        let token_out_a = Bytes::copy_from_slice(&[0xbb; 20]);
777        let sender_a = Bytes::copy_from_slice(&[0xcc; 20]);
778        let receiver_a = Bytes::copy_from_slice(&[0xdd; 20]);
779
780        let token_in_b = Bytes::copy_from_slice(&[0x11; 20]);
781        let token_out_b = Bytes::copy_from_slice(&[0x22; 20]);
782        let sender_b = Bytes::copy_from_slice(&[0x33; 20]);
783
784        let order_a = Order::new(
785            token_in_a,
786            token_out_a.clone(),
787            BigUint::from(1_000u32),
788            OrderSide::Sell,
789            sender_a.clone(),
790            Some(receiver_a.clone()),
791        );
792        let order_b = Order::new(
793            token_in_b,
794            token_out_b.clone(),
795            BigUint::from(2_000u32),
796            OrderSide::Sell,
797            sender_b.clone(),
798            None, // receiver defaults to sender
799        );
800
801        let params = BatchQuoteParams::new(vec![order_a, order_b], QuoteOptions::default());
802        let (request, meta) = batch_quote_params_to_dto(params).unwrap();
803
804        assert_eq!(request.orders().len(), 2);
805        assert_eq!(meta.len(), 2);
806
807        let (tok_out_0, rec_0) = &meta[0];
808        assert_eq!(tok_out_0.as_ref(), token_out_a.as_ref());
809        assert_eq!(rec_0.as_ref(), receiver_a.as_ref());
810
811        let (tok_out_1, rec_1) = &meta[1];
812        assert_eq!(tok_out_1.as_ref(), token_out_b.as_ref());
813        // no explicit receiver → defaults to sender
814        assert_eq!(rec_1.as_ref(), sender_b.as_ref());
815    }
816
817    // -----------------------------------------------------------------------
818    // map_quote_response
819    // -----------------------------------------------------------------------
820
821    #[test]
822    fn map_quote_response_count_mismatch_errors() {
823        let oq = sample_dto_order_quote();
824        let dto_quote = dto::Quote::new(vec![oq], BigUint::from(100_000u32), 42);
825        // supply two metadata entries for one response quote
826        let meta = vec![(Bytes::new(), Bytes::new()), (Bytes::new(), Bytes::new())];
827        assert!(matches!(map_quote_response(dto_quote, meta), Err(FyndError::Protocol(_))));
828    }
829
830    #[test]
831    fn map_quote_response_maps_per_order_meta_and_solve_time() {
832        let oq_a = sample_dto_order_quote();
833        let oq_b = sample_dto_order_quote();
834        let solve_ms = 77u64;
835        let dto_quote = dto::Quote::new(vec![oq_a, oq_b], BigUint::from(200_000u32), solve_ms);
836
837        let token_out_a = Bytes::copy_from_slice(&[0xaa; 20]);
838        let receiver_a = Bytes::copy_from_slice(&[0xbb; 20]);
839        let token_out_b = Bytes::copy_from_slice(&[0xcc; 20]);
840        let receiver_b = Bytes::copy_from_slice(&[0xdd; 20]);
841
842        let meta = vec![
843            (token_out_a.clone(), receiver_a.clone()),
844            (token_out_b.clone(), receiver_b.clone()),
845        ];
846
847        let quotes = map_quote_response(dto_quote, meta).unwrap();
848        assert_eq!(quotes.len(), 2);
849
850        assert_eq!(quotes[0].token_out().as_ref(), token_out_a.as_ref());
851        assert_eq!(quotes[0].receiver().as_ref(), receiver_a.as_ref());
852        assert_eq!(quotes[0].solve_time_ms(), solve_ms);
853
854        assert_eq!(quotes[1].token_out().as_ref(), token_out_b.as_ref());
855        assert_eq!(quotes[1].receiver().as_ref(), receiver_b.as_ref());
856        assert_eq!(quotes[1].solve_time_ms(), solve_ms);
857    }
858}
fynd_client/mapping.rs

fynd_client/
mapping.rs
