Struct CommonSwapResponse

Source

pub struct CommonSwapResponse {
    pub block_number: CommonSwapResponseBlockNumber,
    pub fees: CommonSwapResponseFees,
    pub from_amount: CommonSwapResponseFromAmount,
    pub from_token: CommonSwapResponseFromToken,
    pub issues: CommonSwapResponseIssues,
    pub liquidity_available: bool,
    pub min_to_amount: CommonSwapResponseMinToAmount,
    pub to_amount: CommonSwapResponseToAmount,
    pub to_token: CommonSwapResponseToToken,
}

Expand description

CommonSwapResponse

JSON schema

{
 "examples": [
   {
     "blockNumber": "17038723",
     "fees": {
       "gasFee": {
         "amount": "1000000000000000000",
         "token": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
       },
       "protocolFee": {
         "amount": "1000000000000000000",
         "token": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
       }
     },
     "fromAmount": "1000000000000000000",
     "fromToken": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
     "issues": {
       "allowance": {
         "currentAllowance": "1000000000",
         "spender": "0x000000000022D473030F116dDEE9F6B43aC78BA3"
       },
       "balance": {
         "currentBalance": "1000000000000000000",
         "requiredBalance": "1000000000000000000",
         "token": "0x6B175474E89094C44Da98b954EedeAC495271d0F"
       },
       "simulationIncomplete": false
     },
     "liquidityAvailable": true,
     "minToAmount": "900000000000000000",
     "toAmount": "1000000000000000000",
     "toToken": "0x7F5c764cBc14f9669B88837ca1490cCa17c31607"
   }
 ],
 "type": "object",
 "required": [
   "blockNumber",
   "fees",
   "fromAmount",
   "fromToken",
   "issues",
   "liquidityAvailable",
   "minToAmount",
   "toAmount",
   "toToken"
 ],
 "properties": {
   "blockNumber": {
     "description": "The block number at which the liquidity conditions were examined.",
     "examples": [
       "17038723"
     ],
     "type": "string",
     "pattern": "^[1-9]\\d*$"
   },
   "fees": {
     "description": "The estimated fees for the swap.",
     "examples": [
       {
         "gasFee": {
           "amount": "1000000000000000000",
           "token": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
         },
         "protocolFee": {
           "amount": "1000000000000000000",
           "token": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
         }
       }
     ],
     "type": "object",
     "required": [
       "gasFee",
       "protocolFee"
     ],
     "properties": {
       "gasFee": {
         "description": "The estimated gas fee for the swap.",
         "type": [
           "object",
           "null"
         ],
         "allOf": [
           {
             "$ref": "#/components/schemas/TokenFee"
           }
         ]
       },
       "protocolFee": {
         "description": "The estimated protocol fee for the swap.",
         "type": [
           "object",
           "null"
         ],
         "allOf": [
           {
             "$ref": "#/components/schemas/TokenFee"
           }
         ]
       }
     }
   },
   "fromAmount": {
     "description": "The amount of the `fromToken` that will be sent in this swap, in atomic units of the `fromToken`. For example, `1000000000000000000` when sending ETH equates to 1 ETH, `1000000` when sending USDC equates to 1 USDC, etc.",
     "examples": [
       "1000000000000000000"
     ],
     "type": "string",
     "pattern": "^(0|[1-9]\\d*)$"
   },
   "fromToken": {
     "description": "The 0x-prefixed contract address of the token that will be sent.",
     "examples": [
       "0x6B175474E89094C44Da98b954EedeAC495271d0F"
     ],
     "type": "string",
     "pattern": "^0x[a-fA-F0-9]{40}$"
   },
   "issues": {
     "description": "An object containing potential issues discovered during validation that could prevent the swap from being executed successfully.",
     "examples": [
       {
         "allowance": {
           "currentAllowance": "1000000000",
           "spender": "0x000000000022D473030F116dDEE9F6B43aC78BA3"
         },
         "balance": {
           "currentBalance": "900000000000000000",
           "requiredBalance": "1000000000000000000",
           "token": "0x6B175474E89094C44Da98b954EedeAC495271d0F"
         },
         "simulationIncomplete": false
       }
     ],
     "type": "object",
     "required": [
       "allowance",
       "balance",
       "simulationIncomplete"
     ],
     "properties": {
       "allowance": {
         "description": "Details of the allowances that the taker must set in order to execute the swap successfully. Null if no allowance is required.",
         "examples": [
           {
             "currentAllowance": "1000000000",
             "spender": "0x000000000022D473030F116dDEE9F6B43aC78BA3"
           }
         ],
         "type": [
           "object",
           "null"
         ],
         "required": [
           "currentAllowance",
           "spender"
         ],
         "properties": {
           "currentAllowance": {
             "description": "The current allowance of the `fromToken` by the `taker`.",
             "examples": [
               "1000000000"
             ],
             "type": "string",
             "pattern": "^\\d+$"
           },
           "spender": {
             "description": "The 0x-prefixed address of to set the allowance on.",
             "examples": [
               "0x000000000022D473030F116dDEE9F6B43aC78BA3"
             ],
             "type": "string",
             "pattern": "^0x[a-fA-F0-9]{40}$"
           }
         }
       },
       "balance": {
         "description": "Details of the balance of the `fromToken` that the `taker` must hold. Null if the `taker` has a sufficient balance.",
         "examples": [
           {
             "currentBalance": "1000000000000000000",
             "requiredBalance": "1000000000000000000",
             "token": "0x6B175474E89094C44Da98b954EedeAC495271d0F"
           }
         ],
         "type": [
           "object",
           "null"
         ],
         "required": [
           "currentBalance",
           "requiredBalance",
           "token"
         ],
         "properties": {
           "currentBalance": {
             "description": "The current balance of the `fromToken` by the `taker`.",
             "examples": [
               "10000000"
             ],
             "type": "string",
             "pattern": "^\\d+$"
           },
           "requiredBalance": {
             "description": "The amount of the token that the `taker` must hold.",
             "examples": [
               "1000000000000000000"
             ],
             "type": "string",
             "pattern": "^\\d+$"
           },
           "token": {
             "description": "The 0x-prefixed contract address of the token.",
             "type": "string",
             "pattern": "^0x[a-fA-F0-9]{40}$"
           }
         }
       },
       "simulationIncomplete": {
         "description": "This is set to true when the transaction cannot be validated. This can happen when the taker has an insufficient balance of the `fromToken`. Note that this does not necessarily mean that the trade will revert.",
         "examples": [
           false
         ],
         "type": "boolean"
       }
     }
   },
   "liquidityAvailable": {
     "description": "Whether sufficient liquidity is available to settle the swap. All other fields in the response will be empty if this is false.",
     "examples": [
       true
     ],
     "type": "boolean",
     "enum": [
       true
     ]
   },
   "minToAmount": {
     "description": "The minimum amount of the `toToken` that must be received for the swap to succeed, in atomic units of the `toToken`.  For example, `1000000000000000000` when receiving ETH equates to 1 ETH, `1000000` when receiving USDC equates to 1 USDC, etc. This value is influenced by the `slippageBps` parameter.",
     "examples": [
       "900000000000000000"
     ],
     "type": "string",
     "pattern": "^(0|[1-9]\\d*)$"
   },
   "toAmount": {
     "description": "The amount of the `toToken` that will be received in atomic units of the `toToken`. For example, `1000000000000000000` when receiving ETH equates to 1 ETH, `1000000` when receiving USDC equates to 1 USDC, etc.",
     "examples": [
       "1000000000000000000"
     ],
     "type": "string",
     "pattern": "^(0|[1-9]\\d*)$"
   },
   "toToken": {
     "description": "The 0x-prefixed contract address of the token that will be received.",
     "examples": [
       "0x7F5c764cBc14f9669B88837ca1490cCa17c31607"
     ],
     "type": "string",
     "pattern": "^0x[a-fA-F0-9]{40}$"
   }
 }
}

Fields§

§block_number: CommonSwapResponseBlockNumber

The block number at which the liquidity conditions were examined.

§fees: CommonSwapResponseFees§from_amount: CommonSwapResponseFromAmount

The amount of the fromToken that will be sent in this swap, in atomic units of the fromToken. For example, 1000000000000000000 when sending ETH equates to 1 ETH, 1000000 when sending USDC equates to 1 USDC, etc.

§from_token: CommonSwapResponseFromToken

The 0x-prefixed contract address of the token that will be sent.

§issues: CommonSwapResponseIssues§liquidity_available: bool

Whether sufficient liquidity is available to settle the swap. All other fields in the response will be empty if this is false.

§min_to_amount: CommonSwapResponseMinToAmount

The minimum amount of the toToken that must be received for the swap to succeed, in atomic units of the toToken. For example, 1000000000000000000 when receiving ETH equates to 1 ETH, 1000000 when receiving USDC equates to 1 USDC, etc. This value is influenced by the slippageBps parameter.

§to_amount: CommonSwapResponseToAmount

The amount of the toToken that will be received in atomic units of the toToken. For example, 1000000000000000000 when receiving ETH equates to 1 ETH, 1000000 when receiving USDC equates to 1 USDC, etc.

§to_token: CommonSwapResponseToToken

The 0x-prefixed contract address of the token that will be received.

Struct CommonSwapResponse Copy item path

Fields§

Implementations§

impl CommonSwapResponse

pub fn builder() -> CommonSwapResponse

Trait Implementations§

impl Clone for CommonSwapResponse

fn clone(&self) -> CommonSwapResponse

fn clone_from(&mut self, source: &Self)

impl Debug for CommonSwapResponse

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<'de> Deserialize<'de> for CommonSwapResponse

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl From<&CommonSwapResponse> for CommonSwapResponse

fn from(value: &CommonSwapResponse) -> Self

impl From<CommonSwapResponse> for CommonSwapResponse

fn from(value: CommonSwapResponse) -> Self

impl Serialize for CommonSwapResponse

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

impl TryFrom<CommonSwapResponse> for CommonSwapResponse

type Error = ConversionError

fn try_from(value: CommonSwapResponse) -> Result<Self, ConversionError>

Auto Trait Implementations§

impl Freeze for CommonSwapResponse

impl RefUnwindSafe for CommonSwapResponse

impl Send for CommonSwapResponse

impl Sync for CommonSwapResponse

impl Unpin for CommonSwapResponse

impl UnwindSafe for CommonSwapResponse

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> PolicyExt for Twhere T: ?Sized,

fn and<P, B, E>(self, other: P) -> And<T, P>where T: Policy<B, E>, P: Policy<B, E>,

fn or<P, B, E>(self, other: P) -> Or<T, P>where T: Policy<B, E>, P: Policy<B, E>,

impl<T> Same for T

type Output = T

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

impl<T> DeserializeOwned for Twhere T: for<'de> Deserialize<'de>,

impl<T> ErasedDestructor for Twhere T: 'static,

Struct CommonSwapResponse

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T> PolicyExt for T
where T: ?Sized,

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

impl<T> ErasedDestructor for T
where T: 'static,