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        FeeBreakdown::new(
230            fb.router_fee().clone(),
231            fb.client_fee().clone(),
232            fb.max_slippage().clone(),
233            fb.min_amount_received().clone(),
234        )
235    });
236    Ok(Quote::new(
237        order_quote.order_id().to_string(),
238        status,
239        BackendKind::Fynd,
240        route,
241        order_quote.amount_in().clone(),
242        order_quote.amount_out().clone(),
243        order_quote.gas_estimate().clone(),
244        order_quote.amount_out_net_gas().clone(),
245        order_quote.price_impact_bps(),
246        block,
247        token_out,
248        receiver,
249        transaction,
250        fee_breakdown,
251    ))
252}
253
254impl From<dto::Transaction> for Transaction {
255    fn from(dt: dto::Transaction) -> Self {
256        Transaction::new(
257            bytes::Bytes::copy_from_slice(dt.to().as_ref()),
258            dt.value().clone(),
259            dt.data().to_vec(),
260        )
261    }
262}
263
264/// Maps a quote response to client [`Quote`]s using per-order `(token_out, receiver)` metadata.
265///
266/// `order_meta` must be index-aligned with the orders in the original request. Returns an error
267/// if the response order count differs from `order_meta.len()`. `solve_time_ms` from the response
268/// is propagated to every returned quote.
269pub(crate) fn map_quote_response(
270    response: dto::Quote,
271    order_meta: Vec<(bytes::Bytes, bytes::Bytes)>,
272) -> Result<Vec<Quote>, FyndError> {
273    let solve_time_ms = response.solve_time_ms();
274    let order_quotes = response.into_orders();
275    if order_quotes.len() != order_meta.len() {
276        return Err(FyndError::Protocol(format!(
277            "server returned {} quotes but {} were requested",
278            order_quotes.len(),
279            order_meta.len()
280        )));
281    }
282    order_quotes
283        .into_iter()
284        .zip(order_meta)
285        .map(|(oq, (token_out, receiver))| {
286            let mut quote = order_quote_to_quote(oq, token_out, receiver)?;
287            quote.solve_time_ms = solve_time_ms;
288            Ok(quote)
289        })
290        .collect()
291}
292
293impl From<dto::QuoteStatus> for QuoteStatus {
294    fn from(ds: dto::QuoteStatus) -> Self {
295        match ds {
296            dto::QuoteStatus::Success => Self::Success,
297            dto::QuoteStatus::NoRouteFound => Self::NoRouteFound,
298            dto::QuoteStatus::InsufficientLiquidity => Self::InsufficientLiquidity,
299            dto::QuoteStatus::Timeout => Self::Timeout,
300            dto::QuoteStatus::NotReady => Self::NotReady,
301            dto::QuoteStatus::PriceCheckFailed => Self::PriceCheckFailed,
302            _ => Self::NotReady,
303        }
304    }
305}
306
307impl TryFrom<dto::Route> for Route {
308    type Error = FyndError;
309
310    fn try_from(dr: dto::Route) -> Result<Self, Self::Error> {
311        let swaps = dr
312            .into_swaps()
313            .into_iter()
314            .map(Swap::try_from)
315            .collect::<Result<Vec<_>, _>>()?;
316        Ok(Route::new(swaps))
317    }
318}
319
320impl TryFrom<dto::Swap> for Swap {
321    type Error = FyndError;
322
323    fn try_from(ds: dto::Swap) -> Result<Self, Self::Error> {
324        let token_in = dto_addr_to_bytes(ds.token_in().clone());
325        let token_out = dto_addr_to_bytes(ds.token_out().clone());
326        Ok(Swap::new(
327            ds.component_id().to_string(),
328            ds.protocol().to_string(),
329            token_in,
330            token_out,
331            ds.amount_in().clone(),
332            ds.amount_out().clone(),
333            ds.gas_estimate().clone(),
334            ds.split(),
335        ))
336    }
337}
338
339impl From<dto::BlockInfo> for BlockInfo {
340    fn from(db: dto::BlockInfo) -> Self {
341        BlockInfo::new(db.number(), db.hash().to_string(), db.timestamp())
342    }
343}
344
345impl TryFrom<fynd_rpc_types::InstanceInfo> for crate::types::InstanceInfo {
346    type Error = FyndError;
347
348    fn try_from(dto: fynd_rpc_types::InstanceInfo) -> Result<Self, Self::Error> {
349        let router = bytes::Bytes::copy_from_slice(dto.router_address().as_ref());
350        let permit2 = bytes::Bytes::copy_from_slice(dto.permit2_address().as_ref());
351        if router.len() != 20 {
352            return Err(FyndError::Protocol(format!(
353                "router_address must be 20 bytes, got {}",
354                router.len()
355            )));
356        }
357        if permit2.len() != 20 {
358            return Err(FyndError::Protocol(format!(
359                "permit2_address must be 20 bytes, got {}",
360                permit2.len()
361            )));
362        }
363        Ok(crate::types::InstanceInfo::new(router, permit2, dto.chain_id()))
364    }
365}
366
367impl From<dto::HealthStatus> for HealthStatus {
368    fn from(dh: dto::HealthStatus) -> Self {
369        HealthStatus::new(
370            dh.healthy(),
371            dh.last_update_ms(),
372            dh.num_solver_pools(),
373            dh.derived_data_ready(),
374            dh.gas_price_age_ms(),
375        )
376    }
377}
378
379// ============================================================================
380// ERROR CONVERSION
381// ============================================================================
382
383pub(crate) fn dto_error_to_fynd(de: dto::ErrorResponse) -> FyndError {
384    let code = ErrorCode::from_server_code(de.code());
385    FyndError::Api { code, message: de.error().to_string() }
386}
387
388#[cfg(test)]
389mod tests {
390    use bytes::Bytes;
391    use num_bigint::BigUint;
392
393    use super::*;
394
395    fn sample_dto_swap() -> dto::Swap {
396        serde_json::from_str(
397            r#"{
398            "component_id": "pool-1",
399            "protocol": "uniswap-v3",
400            "token_in": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
401            "token_out": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
402            "amount_in": "100",
403            "amount_out": "99",
404            "gas_estimate": "50000",
405            "split": "0"
406        }"#,
407        )
408        .expect("valid swap JSON")
409    }
410
411    fn sample_dto_block() -> dto::BlockInfo {
412        serde_json::from_str(
413            r#"{
414            "number": 21000000,
415            "hash": "0xdeadbeef",
416            "timestamp": 1730000000
417        }"#,
418        )
419        .expect("valid block JSON")
420    }
421
422    fn sample_dto_order_quote() -> dto::OrderQuote {
423        serde_json::from_str(
424            r#"{
425            "order_id": "test-order-id",
426            "status": "success",
427            "amount_in": "1000",
428            "amount_out": "999",
429            "gas_estimate": "100000",
430            "price_impact_bps": 5,
431            "amount_out_net_gas": "998",
432            "block": {"number": 21000000, "hash": "0xdeadbeef", "timestamp": 1730000000}
433        }"#,
434        )
435        .expect("valid order quote JSON")
436    }
437
438    // -----------------------------------------------------------------------
439    // biguint_to_u256
440    // -----------------------------------------------------------------------
441
442    #[test]
443    fn biguint_to_u256_zero() {
444        let result = biguint_to_u256(&BigUint::ZERO);
445        assert_eq!(result, alloy::primitives::U256::ZERO);
446    }
447
448    #[test]
449    fn biguint_to_u256_known_value() {
450        let n = BigUint::from(0x1234_5678u64);
451        let result = biguint_to_u256(&n);
452        assert_eq!(result, alloy::primitives::U256::from(0x1234_5678u64));
453    }
454
455    // -----------------------------------------------------------------------
456    // Transaction conversion
457    // -----------------------------------------------------------------------
458
459    #[test]
460    fn transaction_from_dto() {
461        let router_bytes = vec![0x01u8; 20];
462        let dto_tx = dto::Transaction::new(
463            dto::Bytes::from(router_bytes.as_slice()),
464            BigUint::ZERO,
465            vec![0x12, 0x34],
466        );
467        let tx = Transaction::from(dto_tx);
468        assert_eq!(tx.to().as_ref(), router_bytes.as_slice());
469        assert_eq!(tx.value(), &BigUint::ZERO);
470        assert_eq!(tx.data(), &[0x12, 0x34]);
471    }
472
473    // -----------------------------------------------------------------------
474    // bytes_to_alloy_address
475    // -----------------------------------------------------------------------
476
477    #[test]
478    fn bytes_to_alloy_address_happy_path() {
479        let b = Bytes::copy_from_slice(&[0xab; 20]);
480        let addr = bytes_to_alloy_address(&b).unwrap();
481        assert_eq!(addr.as_slice(), &[0xab; 20]);
482    }
483
484    #[test]
485    fn bytes_to_alloy_address_wrong_length() {
486        let b = Bytes::copy_from_slice(&[0xab; 4]);
487        assert!(matches!(bytes_to_alloy_address(&b), Err(FyndError::Protocol(_))));
488    }
489
490    // -----------------------------------------------------------------------
491    // Swap conversion
492    // -----------------------------------------------------------------------
493
494    #[test]
495    fn swap_try_from_dto_happy_path() {
496        let client_swap = Swap::try_from(sample_dto_swap()).unwrap();
497        assert_eq!(client_swap.component_id(), "pool-1");
498        assert_eq!(client_swap.protocol(), "uniswap-v3");
499        assert_eq!(client_swap.token_in(), &Bytes::copy_from_slice(&[0xaa; 20]));
500        assert_eq!(client_swap.token_out(), &Bytes::copy_from_slice(&[0xbb; 20]));
501        assert_eq!(client_swap.amount_in(), &BigUint::from(100u32));
502        assert_eq!(client_swap.amount_out(), &BigUint::from(99u32));
503        assert_eq!(client_swap.gas_estimate(), &BigUint::from(50_000u32));
504    }
505
506    // -----------------------------------------------------------------------
507    // QuoteStatus conversion
508    // -----------------------------------------------------------------------
509
510    #[test]
511    fn quote_status_all_variants() {
512        use dto::QuoteStatus as Dto;
513        assert!(matches!(QuoteStatus::from(Dto::Success), QuoteStatus::Success));
514        assert!(matches!(QuoteStatus::from(Dto::NoRouteFound), QuoteStatus::NoRouteFound));
515        assert!(matches!(
516            QuoteStatus::from(Dto::InsufficientLiquidity),
517            QuoteStatus::InsufficientLiquidity
518        ));
519        assert!(matches!(QuoteStatus::from(Dto::Timeout), QuoteStatus::Timeout));
520        assert!(matches!(QuoteStatus::from(Dto::NotReady), QuoteStatus::NotReady));
521        assert!(matches!(QuoteStatus::from(Dto::PriceCheckFailed), QuoteStatus::PriceCheckFailed));
522    }
523
524    // -----------------------------------------------------------------------
525    // BlockInfo conversion
526    // -----------------------------------------------------------------------
527
528    #[test]
529    fn block_info_from_dto() {
530        let dto_block = sample_dto_block();
531        let block = BlockInfo::from(dto_block);
532        assert_eq!(block.number(), 21_000_000);
533        assert_eq!(block.hash(), "0xdeadbeef");
534        assert_eq!(block.timestamp(), 1_730_000_000);
535    }
536
537    // -----------------------------------------------------------------------
538    // OrderQuote conversion
539    // -----------------------------------------------------------------------
540
541    #[test]
542    fn quote_from_dto() {
543        let ds = sample_dto_order_quote();
544        let quote = order_quote_to_quote(ds, Bytes::new(), Bytes::new()).unwrap();
545        assert_eq!(quote.order_id(), "test-order-id");
546        assert!(matches!(quote.status(), QuoteStatus::Success));
547        assert!(matches!(quote.backend(), BackendKind::Fynd));
548        assert_eq!(quote.amount_in(), &BigUint::from(1_000u32));
549        assert_eq!(quote.amount_out(), &BigUint::from(999u32));
550        assert_eq!(quote.gas_estimate(), &BigUint::from(100_000u32));
551        assert_eq!(quote.amount_out_net_gas(), &BigUint::from(998u32));
552        assert_eq!(quote.price_impact_bps(), Some(5));
553        // token_out and receiver are left empty until populated by quote()
554        assert!(quote.token_out().is_empty());
555        assert!(quote.receiver().is_empty());
556    }
557
558    // -----------------------------------------------------------------------
559    // Order → dto::Order conversion
560    // -----------------------------------------------------------------------
561
562    #[test]
563    fn order_try_from_client_encodes_addresses_as_tycho() {
564        let order = Order::new(
565            Bytes::copy_from_slice(&[0xaa; 20]),
566            Bytes::copy_from_slice(&[0xbb; 20]),
567            BigUint::from(1_000u32),
568            OrderSide::Sell,
569            Bytes::copy_from_slice(&[0xcc; 20]),
570            None,
571        );
572
573        let dto_order = dto::Order::try_from(order).unwrap();
574        assert_eq!(dto_order.token_in().as_ref(), &[0xaa; 20]);
575        assert_eq!(dto_order.token_out().as_ref(), &[0xbb; 20]);
576        assert_eq!(dto_order.sender().as_ref(), &[0xcc; 20]);
577        assert!(dto_order.receiver().is_none());
578        assert_eq!(dto_order.amount(), &BigUint::from(1_000u32));
579    }
580
581    #[test]
582    fn order_try_from_client_with_receiver() {
583        let order = Order::new(
584            Bytes::copy_from_slice(&[0xaa; 20]),
585            Bytes::copy_from_slice(&[0xbb; 20]),
586            BigUint::from(1u32),
587            OrderSide::Sell,
588            Bytes::copy_from_slice(&[0xcc; 20]),
589            Some(Bytes::copy_from_slice(&[0xdd; 20])),
590        );
591
592        let dto_order = dto::Order::try_from(order).unwrap();
593        let receiver = dto_order.receiver().unwrap();
594        assert_eq!(receiver.as_ref(), &[0xdd; 20]);
595    }
596
597    #[test]
598    fn order_try_from_client_invalid_address_length() {
599        let order = Order::new(
600            Bytes::copy_from_slice(&[0xaa; 4]), // wrong length
601            Bytes::copy_from_slice(&[0xbb; 20]),
602            BigUint::from(1u32),
603            OrderSide::Sell,
604            Bytes::copy_from_slice(&[0xcc; 20]),
605            None,
606        );
607        assert!(matches!(dto::Order::try_from(order), Err(FyndError::Protocol(_))));
608    }
609
610    // -----------------------------------------------------------------------
611    // UserTransferType mapping
612    // -----------------------------------------------------------------------
613
614    #[test]
615    fn user_transfer_type_permit2_maps_correctly() {
616        let result = dto::UserTransferType::from(UserTransferType::TransferFromPermit2);
617        assert!(matches!(result, dto::UserTransferType::TransferFromPermit2));
618    }
619
620    #[test]
621    fn user_transfer_type_vault_funds_maps_correctly() {
622        let result = dto::UserTransferType::from(UserTransferType::UseVaultsFunds);
623        assert!(matches!(result, dto::UserTransferType::UseVaultsFunds));
624    }
625
626    // -----------------------------------------------------------------------
627    // PermitDetails TryFrom
628    // -----------------------------------------------------------------------
629
630    #[test]
631    fn permit_details_try_from_happy_path() {
632        let details = PermitDetails::new(
633            Bytes::copy_from_slice(&[0xaa; 20]),
634            BigUint::from(1_000u32),
635            BigUint::from(9_999_999u32),
636            BigUint::from(0u32),
637        );
638        let dto_details = dto::PermitDetails::try_from(details).unwrap();
639        assert_eq!(dto_details.token().as_ref(), &[0xaa; 20]);
640        assert_eq!(dto_details.amount(), &BigUint::from(1_000u32));
641        assert_eq!(dto_details.expiration(), &BigUint::from(9_999_999u32));
642        assert_eq!(dto_details.nonce(), &BigUint::from(0u32));
643    }
644
645    #[test]
646    fn permit_details_try_from_invalid_token() {
647        let details = PermitDetails::new(
648            Bytes::copy_from_slice(&[0xaa; 4]), // wrong length
649            BigUint::from(1u32),
650            BigUint::from(1u32),
651            BigUint::from(0u32),
652        );
653        assert!(matches!(dto::PermitDetails::try_from(details), Err(FyndError::Protocol(_))));
654    }
655
656    // -----------------------------------------------------------------------
657    // PermitSingle TryFrom
658    // -----------------------------------------------------------------------
659
660    #[test]
661    fn permit_single_try_from_happy_path() {
662        let details = PermitDetails::new(
663            Bytes::copy_from_slice(&[0xaa; 20]),
664            BigUint::from(500u32),
665            BigUint::from(1_000_000u32),
666            BigUint::from(1u32),
667        );
668        let permit = PermitSingle::new(
669            details,
670            Bytes::copy_from_slice(&[0xbb; 20]),
671            BigUint::from(2_000_000u32),
672        );
673        let dto_permit = dto::PermitSingle::try_from(permit).unwrap();
674        assert_eq!(dto_permit.spender().as_ref(), &[0xbb; 20]);
675        assert_eq!(dto_permit.sig_deadline(), &BigUint::from(2_000_000u32));
676        assert_eq!(dto_permit.details().amount(), &BigUint::from(500u32));
677    }
678
679    // -----------------------------------------------------------------------
680    // EncodingOptions TryFrom with permit2
681    // -----------------------------------------------------------------------
682
683    #[test]
684    fn encoding_options_try_from_with_permit2() {
685        use crate::types::{EncodingOptions, PermitDetails, PermitSingle};
686
687        let details = PermitDetails::new(
688            Bytes::copy_from_slice(&[0xaa; 20]),
689            BigUint::from(1_000u32),
690            BigUint::from(9_999_999u32),
691            BigUint::from(0u32),
692        );
693        let permit = PermitSingle::new(
694            details,
695            Bytes::copy_from_slice(&[0xbb; 20]),
696            BigUint::from(9_999_999u32),
697        );
698        let sig = Bytes::copy_from_slice(&[0xcc; 65]);
699        let opts = EncodingOptions::new(0.005)
700            .with_permit2(permit, sig.clone())
701            .unwrap();
702
703        let dto_opts = dto::EncodingOptions::try_from(opts).unwrap();
704        assert!(matches!(dto_opts.transfer_type(), dto::UserTransferType::TransferFromPermit2));
705        assert!(dto_opts.permit().is_some());
706        assert_eq!(
707            dto_opts
708                .permit2_signature()
709                .unwrap()
710                .as_ref(),
711            sig.as_ref()
712        );
713    }
714
715    // -----------------------------------------------------------------------
716    // EncodingOptions TryFrom with client fee
717    // -----------------------------------------------------------------------
718
719    #[test]
720    fn encoding_options_try_from_with_client_fee() {
721        use crate::types::{ClientFeeParams, EncodingOptions};
722
723        let fee = ClientFeeParams::new(
724            100,
725            Bytes::copy_from_slice(&[0x44; 20]),
726            BigUint::from(500_000u64),
727            1_893_456_000u64,
728        )
729        .with_signature(Bytes::copy_from_slice(&[0xAB; 65]));
730        let opts = EncodingOptions::new(0.01).with_client_fee(fee);
731
732        let dto_opts = dto::EncodingOptions::try_from(opts).unwrap();
733        assert!(dto_opts.client_fee_params().is_some());
734        let dto_fee = dto_opts.client_fee_params().unwrap();
735        assert_eq!(dto_fee.bps(), 100);
736        assert_eq!(*dto_fee.max_contribution(), BigUint::from(500_000u64));
737        assert_eq!(dto_fee.deadline(), 1_893_456_000u64);
738        assert_eq!(dto_fee.signature().len(), 65);
739    }
740
741    #[test]
742    fn encoding_options_try_from_without_client_fee() {
743        use crate::types::EncodingOptions;
744
745        let opts = EncodingOptions::new(0.005);
746        let dto_opts = dto::EncodingOptions::try_from(opts).unwrap();
747        assert!(dto_opts.client_fee_params().is_none());
748    }
749
750    // -----------------------------------------------------------------------
751    // batch_quote_params_to_dto
752    // -----------------------------------------------------------------------
753
754    #[test]
755    fn batch_quote_params_to_dto_empty_orders_errors() {
756        use crate::types::{BatchQuoteParams, QuoteOptions};
757
758        let params = BatchQuoteParams::new(vec![], QuoteOptions::default());
759        assert!(matches!(batch_quote_params_to_dto(params), Err(FyndError::Protocol(_))));
760    }
761
762    #[test]
763    fn batch_quote_params_to_dto_extracts_per_order_meta() {
764        use crate::types::{BatchQuoteParams, Order, OrderSide, QuoteOptions};
765
766        let token_in_a = Bytes::copy_from_slice(&[0xaa; 20]);
767        let token_out_a = Bytes::copy_from_slice(&[0xbb; 20]);
768        let sender_a = Bytes::copy_from_slice(&[0xcc; 20]);
769        let receiver_a = Bytes::copy_from_slice(&[0xdd; 20]);
770
771        let token_in_b = Bytes::copy_from_slice(&[0x11; 20]);
772        let token_out_b = Bytes::copy_from_slice(&[0x22; 20]);
773        let sender_b = Bytes::copy_from_slice(&[0x33; 20]);
774
775        let order_a = Order::new(
776            token_in_a,
777            token_out_a.clone(),
778            BigUint::from(1_000u32),
779            OrderSide::Sell,
780            sender_a.clone(),
781            Some(receiver_a.clone()),
782        );
783        let order_b = Order::new(
784            token_in_b,
785            token_out_b.clone(),
786            BigUint::from(2_000u32),
787            OrderSide::Sell,
788            sender_b.clone(),
789            None, // receiver defaults to sender
790        );
791
792        let params = BatchQuoteParams::new(vec![order_a, order_b], QuoteOptions::default());
793        let (request, meta) = batch_quote_params_to_dto(params).unwrap();
794
795        assert_eq!(request.orders().len(), 2);
796        assert_eq!(meta.len(), 2);
797
798        let (tok_out_0, rec_0) = &meta[0];
799        assert_eq!(tok_out_0.as_ref(), token_out_a.as_ref());
800        assert_eq!(rec_0.as_ref(), receiver_a.as_ref());
801
802        let (tok_out_1, rec_1) = &meta[1];
803        assert_eq!(tok_out_1.as_ref(), token_out_b.as_ref());
804        // no explicit receiver → defaults to sender
805        assert_eq!(rec_1.as_ref(), sender_b.as_ref());
806    }
807
808    // -----------------------------------------------------------------------
809    // map_quote_response
810    // -----------------------------------------------------------------------
811
812    #[test]
813    fn map_quote_response_count_mismatch_errors() {
814        let oq = sample_dto_order_quote();
815        let dto_quote = dto::Quote::new(vec![oq], BigUint::from(100_000u32), 42);
816        // supply two metadata entries for one response quote
817        let meta = vec![(Bytes::new(), Bytes::new()), (Bytes::new(), Bytes::new())];
818        assert!(matches!(map_quote_response(dto_quote, meta), Err(FyndError::Protocol(_))));
819    }
820
821    #[test]
822    fn map_quote_response_maps_per_order_meta_and_solve_time() {
823        let oq_a = sample_dto_order_quote();
824        let oq_b = sample_dto_order_quote();
825        let solve_ms = 77u64;
826        let dto_quote = dto::Quote::new(vec![oq_a, oq_b], BigUint::from(200_000u32), solve_ms);
827
828        let token_out_a = Bytes::copy_from_slice(&[0xaa; 20]);
829        let receiver_a = Bytes::copy_from_slice(&[0xbb; 20]);
830        let token_out_b = Bytes::copy_from_slice(&[0xcc; 20]);
831        let receiver_b = Bytes::copy_from_slice(&[0xdd; 20]);
832
833        let meta = vec![
834            (token_out_a.clone(), receiver_a.clone()),
835            (token_out_b.clone(), receiver_b.clone()),
836        ];
837
838        let quotes = map_quote_response(dto_quote, meta).unwrap();
839        assert_eq!(quotes.len(), 2);
840
841        assert_eq!(quotes[0].token_out().as_ref(), token_out_a.as_ref());
842        assert_eq!(quotes[0].receiver().as_ref(), receiver_a.as_ref());
843        assert_eq!(quotes[0].solve_time_ms(), solve_ms);
844
845        assert_eq!(quotes[1].token_out().as_ref(), token_out_b.as_ref());
846        assert_eq!(quotes[1].receiver().as_ref(), receiver_b.as_ref());
847        assert_eq!(quotes[1].solve_time_ms(), solve_ms);
848    }
849}
fynd_client/mapping.rs

fynd_client/
mapping.rs
