odos-sdk 7.0.0

Rust SDK for Odos
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

// SPDX-FileCopyrightText: 2025 Semiotic AI, Inc.
//
// SPDX-License-Identifier: Apache-2.0

use std::fmt::Display;

use alloy_chains::NamedChain;
use alloy_primitives::{Address, U256};
use bon::Builder;
use serde::{Deserialize, Deserializer, Serialize, Serializer};

/// Request for assembling a transaction from a quote
///
/// Contains all the information needed to assemble a transaction from
/// a quote path ID, including signer address, recipient, and routing details.
#[derive(Builder, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct AssemblyRequest {
    /// The chain of the swap.
    chain: NamedChain,
    /// The address of the router.
    router_address: Address,
    /// The address of the signer.
    signer_address: Address,
    /// The address of the recipient of the output token.
    output_recipient: Address,
    /// The address of the token to swap.
    token_address: Address,
    /// The amount of tokens to swap.
    token_amount: U256,
    /// The path ID of the swap.
    path_id: String,
}

impl AssemblyRequest {
    pub fn chain(&self) -> NamedChain {
        self.chain
    }

    pub fn output_recipient(&self) -> Address {
        self.output_recipient
    }

    pub fn router_address(&self) -> Address {
        self.router_address
    }

    pub fn signer_address(&self) -> Address {
        self.signer_address
    }

    pub fn token_address(&self) -> Address {
        self.token_address
    }

    pub fn token_amount(&self) -> U256 {
        self.token_amount
    }

    pub fn path_id(&self) -> &str {
        &self.path_id
    }
}

impl Serialize for AssemblyRequest {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let chain_id: u64 = self.chain.into();
        let data = (
            chain_id,
            self.router_address,
            self.signer_address,
            self.output_recipient,
            self.token_address,
            self.token_amount,
            &self.path_id,
        );
        data.serialize(serializer)
    }
}

impl<'de> Deserialize<'de> for AssemblyRequest {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let (
            chain_id,
            router_address,
            signer_address,
            output_recipient,
            token_address,
            token_amount,
            path_id,
        ): (u64, Address, Address, Address, Address, U256, String) =
            Deserialize::deserialize(deserializer)?;

        let chain = NamedChain::try_from(chain_id).map_err(serde::de::Error::custom)?;

        Ok(Self {
            chain,
            router_address,
            signer_address,
            output_recipient,
            token_address,
            token_amount,
            path_id,
        })
    }
}

impl Display for AssemblyRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Swap {{ chain: {}, router_address: {}, signer_address: {}, output_recipient: {}, token_address: {}, token_amount: {}, path_id: {} }}",
            self.chain,
            self.router_address,
            self.signer_address,
            self.output_recipient,
            self.token_address,
            self.token_amount,
            self.path_id
        )
    }
}

/// Deprecated alias for [`AssemblyRequest`]
///
/// This type alias is provided for backward compatibility.
/// Use [`AssemblyRequest`] instead in new code.
#[deprecated(since = "0.25.0", note = "Use `AssemblyRequest` instead")]
pub type SwapContext = AssemblyRequest;