use std::collections::HashMap;
use crate::common::{
instruction::AddressLookupTableAccount, BoundedValueWithDefault, Instruction, Pubkey,
};
pub const VERSION_MAJOR: u16 = 1;
pub const VERSION_MINOR: u16 = 2;
pub const WEBSOCKET_SUBPROTO_BASE: &str = "v1.api.titan.ag";
pub const WEBSOCKET_SUBPROTO_ZSTD: &str = "v1.api.titan.ag+zstd";
pub const WEBSOCKET_SUBPROTO_BROTLI: &str = "v1.api.titan.ag+br";
pub const WEBSOCKET_SUBPROTO_GZIP: &str = "v1.api.titan.ag+gzip";
pub const WEBSOCKET_SUBPROTOCOLS: [&str; 4] = [
WEBSOCKET_SUBPROTO_ZSTD,
WEBSOCKET_SUBPROTO_BROTLI,
WEBSOCKET_SUBPROTO_GZIP,
WEBSOCKET_SUBPROTO_BASE,
];
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VersionInfo {
pub major: u16,
pub minor: u16,
pub patch: u16,
}
impl VersionInfo {
pub const fn new(major: u16, minor: u16, patch: u16) -> Self {
Self {
major,
minor,
patch,
}
}
pub const fn serial(&self) -> u64 {
((self.major as u64) << 32) + ((self.minor as u64) << 16) + (self.minor as u64)
}
}
#[derive(Default, PartialEq, Eq, Clone, Copy, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SwapMode {
#[default]
ExactIn,
ExactOut,
}
#[derive(Default, PartialEq, Eq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TransactionTemplate {
#[cfg_attr(feature = "serde", serde(rename = "i"))]
pub instructions: Vec<Instruction>,
#[cfg_attr(feature = "serde", serde(rename = "a"))]
pub alts: Vec<AddressLookupTableAccount>,
#[cfg_attr(feature = "serde", serde(rename = "idx"))]
pub index: usize,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct SwapParams {
pub input_mint: Pubkey,
pub output_mint: Pubkey,
pub amount: u64,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub swap_mode: Option<SwapMode>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub slippage_bps: Option<u16>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub dexes: Option<Vec<String>>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub exclude_dexes: Option<Vec<String>>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub only_direct_routes: Option<bool>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub add_size_constraint: Option<bool>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub size_constraint: Option<u32>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub providers: Option<Vec<String>>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub accounts_limit_total: Option<u16>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub accounts_limit_writable: Option<u16>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub transaction_template: Option<TransactionTemplate>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct SwapSettings {
pub slippage_bps: BoundedValueWithDefault<u16>,
pub only_direct_routes: bool,
pub add_size_constraint: bool,
pub size_constraint: u32,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct QuoteUpdateParams {
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub interval_ms: Option<u64>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub num_quotes: Option<u32>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct QuoteUpdateSettings {
pub interval_ms: BoundedValueWithDefault<u64>,
pub num_quotes: BoundedValueWithDefault<u32>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct TransactionParams {
pub user_public_key: Pubkey,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub close_input_token_account: Option<bool>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub create_output_token_account: Option<bool>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub fee_account: Option<Pubkey>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub fee_bps: Option<u16>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub fee_from_input_mint: Option<bool>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub output_account: Option<Pubkey>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct TransactionSettings {
pub close_input_token_account: bool,
pub create_output_token_account: bool,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct ConnectionSettings {
pub concurrent_streams: u32,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct ServerSettings {
pub quote_update: QuoteUpdateSettings,
pub swap: SwapSettings,
pub transaction: TransactionSettings,
pub connection: ConnectionSettings,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct ServerInfo {
pub protocol_version: VersionInfo,
pub settings: ServerSettings,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct SwapQuoteRequest {
pub swap: SwapParams,
pub transaction: TransactionParams,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub update: Option<QuoteUpdateParams>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct SwapPriceRequest {
pub input_mint: Pubkey,
pub output_mint: Pubkey,
pub amount: u64,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub dexes: Option<Vec<String>>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub exclude_dexes: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct RoutePlanStep {
pub amm_key: Pubkey,
pub label: String,
pub input_mint: Pubkey,
pub output_mint: Pubkey,
pub in_amount: u64,
pub out_amount: u64,
pub alloc_ppb: u32,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub fee_mint: Option<Pubkey>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub fee_amount: Option<u64>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub context_slot: Option<u64>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct PlatformFee {
pub amount: u64,
pub fee_bps: u8,
}
#[derive(Debug, Clone, Default, PartialEq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct SwapRoute {
pub in_amount: u64,
pub out_amount: u64,
pub slippage_bps: u16,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub platform_fee: Option<PlatformFee>,
pub steps: Vec<RoutePlanStep>,
pub instructions: Vec<Instruction>,
pub address_lookup_tables: Vec<Pubkey>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub context_slot: Option<u64>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub time_taken_ns: Option<u64>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub expires_at_ms: Option<u64>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub expires_after_slot: Option<u64>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub compute_units: Option<u64>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub compute_units_safe: Option<u64>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", with = "serde_bytes", default)
)]
pub transaction: Option<Vec<u8>>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub reference_id: Option<String>,
}
#[derive(Debug, Clone, Default, PartialEq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct SwapQuotes {
pub id: String,
pub input_mint: Pubkey,
pub output_mint: Pubkey,
pub swap_mode: SwapMode,
pub amount: u64,
pub quotes: HashMap<String, SwapRoute>,
}
#[derive(Debug, Clone, Default, PartialEq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct SwapPrice {
pub id: String,
pub input_mint: Pubkey,
pub output_mint: Pubkey,
pub amount_in: u64,
pub amount_out: u64,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct QuoteSwapStreamResponse {
pub interval_ms: u64,
pub num_quotes: u32,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GetInfoRequest {
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub dummy: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct StopStreamRequest {
pub id: u32,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct StopStreamResponse {
pub id: u32,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct GetVenuesRequest {
#[cfg_attr(
feature = "serde",
serde(default, skip_serializing_if = "Option::is_none")
)]
pub include_program_ids: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct VenueInfo {
pub labels: Vec<String>,
#[cfg_attr(
feature = "serde",
serde(default, skip_serializing_if = "Option::is_none")
)]
pub program_ids: Option<Vec<Pubkey>>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct ListProvidersRequest {
#[cfg_attr(
feature = "serde",
serde(default, skip_serializing_if = "Option::is_none")
)]
pub include_icons: Option<bool>,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
pub struct ProviderInfo {
pub id: String,
pub name: String,
pub kind: ProviderKind,
#[cfg_attr(
feature = "serde",
serde(default, skip_serializing_if = "Option::is_none")
)]
pub icon_uri_48: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ProviderKind {
DexAggregator,
RFQ,
#[cfg_attr(feature = "serde", serde(untagged))]
Other(String),
}
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[allow(clippy::large_enum_variant)]
pub enum RequestData {
GetInfo(GetInfoRequest),
NewSwapQuoteStream(SwapQuoteRequest),
StopStream(StopStreamRequest),
GetVenues(GetVenuesRequest),
ListProviders(ListProvidersRequest),
GetSwapPrice(SwapPriceRequest),
#[cfg(feature = "enum-other")]
#[cfg_attr(feature = "serde", serde(untagged))]
Other(rmpv::Value),
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Clone, Debug, PartialEq)]
pub enum ResponseData {
GetInfo(ServerInfo),
NewSwapQuoteStream(QuoteSwapStreamResponse),
StreamStopped(StopStreamResponse),
GetVenues(VenueInfo),
ListProviders(Vec<ProviderInfo>),
GetSwapPrice(SwapPrice),
#[cfg(feature = "enum-other")]
#[cfg_attr(feature = "serde", serde(untagged))]
Other(rmpv::Value),
}
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ClientRequest {
pub id: u32,
pub data: RequestData,
}
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StreamStart {
pub id: u32,
pub data_type: StreamDataType,
}
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
#[derive(Debug, Clone, PartialEq)]
pub struct StreamData {
pub id: u32,
pub seq: u32,
pub payload: StreamDataPayload,
}
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StreamEnd {
pub id: u32,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub error_code: Option<u32>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub error_message: Option<String>,
}
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
#[derive(Debug, Clone, PartialEq)]
pub struct ResponseSuccess {
pub request_id: u32,
pub data: ResponseData,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
pub stream: Option<StreamStart>,
}
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(rename_all = "camelCase")
)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ResponseError {
pub request_id: u32,
pub code: u32,
pub message: String,
}
#[derive(PartialEq, Eq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum StreamDataType {
SwapQuotes,
#[cfg(feature = "enum-other")]
#[cfg_attr(feature = "serde", serde(untagged))]
Other(String),
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq)]
pub enum StreamDataPayload {
SwapQuotes(SwapQuotes),
#[cfg(feature = "enum-other")]
#[cfg_attr(feature = "serde", serde(untagged))]
Other(rmpv::Value),
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq)]
pub enum ServerMessage {
Response(ResponseSuccess),
Error(ResponseError),
StreamData(StreamData),
StreamEnd(StreamEnd),
#[cfg(feature = "enum-other")]
#[cfg_attr(feature = "serde", serde(untagged))]
Other(rmpv::Value),
}
#[cfg(test)]
mod test {
use super::*;
use hex_literal::hex;
use rmp_serde::{decode::Error as DecError, encode::Error as EncError};
use rmpv::Value;
const WSOL_ADDR: Pubkey = Pubkey::from_str_const("So11111111111111111111111111111111111111112");
const USDC_ADDR: Pubkey =
Pubkey::from_str_const("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const METEORA_DLMM_WSOL_USDC: Pubkey =
Pubkey::from_str_const("2kSaQT7BcB92uVeDtmxsDJm9fbGxupf64KgtsF5xzLhf");
#[test]
fn test_encode_version_info() -> Result<(), EncError> {
let info = VersionInfo::new(1, 2, 3);
let expected = hex!("83a56d616a6f7201a56d696e6f7202a5706174636803");
let encoded = rmp_serde::to_vec_named(&info)?;
assert_eq!(encoded, expected);
Ok(())
}
#[test]
fn test_decode_version_info() -> Result<(), DecError> {
let info = VersionInfo::new(1, 2, 3);
let data = hex!("83a56d616a6f7201a56d696e6f7202a5706174636803");
let decoded = rmp_serde::from_slice::<VersionInfo>(&data)?;
assert_eq!(decoded, info);
Ok(())
}
#[test]
fn test_encode_swap_mode() -> Result<(), EncError> {
let exact_in_data = hex!("a74578616374496e");
let exact_out_data = hex!("a845786163744f7574");
assert_eq!(rmp_serde::to_vec_named(&SwapMode::ExactIn)?, &exact_in_data);
assert_eq!(
rmp_serde::to_vec_named(&SwapMode::ExactOut)?,
&exact_out_data
);
Ok(())
}
#[test]
fn test_decode_swap_mode() -> Result<(), DecError> {
let exact_in_data = hex!("a74578616374496e");
let exact_out_data = hex!("a845786163744f7574");
assert_eq!(
rmp_serde::from_slice::<SwapMode>(&exact_in_data)?,
SwapMode::ExactIn
);
assert_eq!(
rmp_serde::from_slice::<SwapMode>(&exact_out_data)?,
SwapMode::ExactOut
);
Ok(())
}
#[test]
fn test_encode_swap_params() -> Result<(), EncError> {
let data = hex!("83a9696e7075744d696e74c420069b8857feab8184fb687f634618c035dac439dc1aeb3b5598a0f00000000001aa6f75747075744d696e74c420c6fa7af3bedbad3a3d65f36aabc97431b1bbe4c2d2f6e0e47ca60203452f5d61a6616d6f756e74ce3b9aca00");
let info = SwapParams {
input_mint: WSOL_ADDR,
output_mint: USDC_ADDR,
amount: 1_000_000_000,
..Default::default()
};
let encoded = rmp_serde::to_vec_named(&info)?;
assert_eq!(encoded, data);
Ok(())
}
#[test]
fn test_decode_swap_params() -> Result<(), DecError> {
let data = hex!("83a9696e7075744d696e74c420069b8857feab8184fb687f634618c035dac439dc1aeb3b5598a0f00000000001aa6f75747075744d696e74c420c6fa7af3bedbad3a3d65f36aabc97431b1bbe4c2d2f6e0e47ca60203452f5d61a6616d6f756e74ce3b9aca00");
let info = SwapParams {
input_mint: WSOL_ADDR,
output_mint: USDC_ADDR,
amount: 1_000_000_000,
..Default::default()
};
let decoded: SwapParams = rmp_serde::from_slice(&data)?;
assert_eq!(decoded, info);
Ok(())
}
#[test]
fn test_encode_swap_settings() -> Result<(), EncError> {
let expected_rmp = Value::Map(vec![
(
Value::from("slippageBps"),
Value::Map(vec![
(Value::from("min"), Value::from(0u16)),
(Value::from("max"), Value::from(10_000u16)),
(Value::from("default"), Value::from(100u16)),
]),
),
(Value::from("onlyDirectRoutes"), Value::from(false)),
(Value::from("addSizeConstraint"), Value::from(true)),
(Value::from("sizeConstraint"), Value::from(1232)),
]);
let data = rmp_serde::to_vec_named(&expected_rmp).expect("expected rmp should encode");
let info = SwapSettings {
slippage_bps: BoundedValueWithDefault {
min: 0,
max: 10_000,
default: 100,
},
only_direct_routes: false,
add_size_constraint: true,
size_constraint: 1232,
};
let encoded = rmp_serde::to_vec_named(&info)?;
assert_eq!(encoded, data);
Ok(())
}
#[test]
fn test_decode_swap_settings() -> Result<(), DecError> {
let expected_rmp = Value::Map(vec![
(
Value::from("slippageBps"),
Value::Map(vec![
(Value::from("min"), Value::from(0u16)),
(Value::from("max"), Value::from(10_000u16)),
(Value::from("default"), Value::from(100u16)),
]),
),
(Value::from("onlyDirectRoutes"), Value::from(false)),
(Value::from("addSizeConstraint"), Value::from(true)),
(Value::from("sizeConstraint"), Value::from(1232)),
]);
let data = rmp_serde::to_vec_named(&expected_rmp).expect("expected rmp should encode");
let info = SwapSettings {
slippage_bps: BoundedValueWithDefault {
min: 0,
max: 10_000,
default: 100,
},
only_direct_routes: false,
add_size_constraint: true,
size_constraint: 1232,
};
let decoded: SwapSettings = rmp_serde::from_slice(&data)?;
assert_eq!(decoded, info);
Ok(())
}
#[test]
fn test_encode_quote_update_params() -> Result<(), EncError> {
let data = hex!("81aa696e74657276616c4d73cd03e8");
let info = QuoteUpdateParams {
interval_ms: Some(1000),
..Default::default()
};
let encoded = rmp_serde::to_vec_named(&info)?;
assert_eq!(encoded, data);
let empty_data = hex!("80");
let info = QuoteUpdateParams {
interval_ms: None,
..Default::default()
};
let encoded = rmp_serde::to_vec_named(&info)?;
assert_eq!(encoded, empty_data);
Ok(())
}
#[test]
fn test_decode_quote_update_params() -> Result<(), DecError> {
let data = hex!("81aa696e74657276616c4d73cd03e8");
let info = QuoteUpdateParams {
interval_ms: Some(1000),
..Default::default()
};
let decoded: QuoteUpdateParams = rmp_serde::from_slice(&data)?;
assert_eq!(decoded, info);
let empty_data = hex!("80");
let info = QuoteUpdateParams {
interval_ms: None,
..Default::default()
};
let decoded: QuoteUpdateParams = rmp_serde::from_slice(&empty_data)?;
assert_eq!(decoded, info);
Ok(())
}
#[test]
fn test_encode_transaction_params() -> Result<(), EncError> {
let data = hex!("82ad757365725075626c69634b6579c42019fc949cf6d288d076e39f923bf6f1b45da023310e606afc40cc080d5b25983ab6636c6f7365496e707574546f6b656e4163636f756e74c3");
let info = TransactionParams {
user_public_key: METEORA_DLMM_WSOL_USDC,
close_input_token_account: Some(true),
create_output_token_account: None,
..Default::default()
};
let encoded = rmp_serde::to_vec_named(&info)?;
assert_eq!(encoded, data);
Ok(())
}
#[test]
fn test_decode_transaction_params() -> Result<(), DecError> {
let data = hex!("82ad757365725075626c69634b6579c42019fc949cf6d288d076e39f923bf6f1b45da023310e606afc40cc080d5b25983ab6636c6f7365496e707574546f6b656e4163636f756e74c3");
let info = TransactionParams {
user_public_key: METEORA_DLMM_WSOL_USDC,
close_input_token_account: Some(true),
create_output_token_account: None,
..Default::default()
};
let decoded: TransactionParams = rmp_serde::from_slice(&data)?;
assert_eq!(decoded, info);
Ok(())
}
#[test]
fn test_encode_transaction_settings() -> Result<(), EncError> {
let data = hex!("82b6636c6f7365496e707574546f6b656e4163636f756e74c2b86372656174654f7574707574546f6b656e4163636f756e74c3");
let info = TransactionSettings {
close_input_token_account: false,
create_output_token_account: true,
};
let encoded = rmp_serde::to_vec_named(&info)?;
assert_eq!(encoded, data);
Ok(())
}
#[test]
fn test_decode_transaction_settings() -> Result<(), DecError> {
let data = hex!("82b6636c6f7365496e707574546f6b656e4163636f756e74c2b86372656174654f7574707574546f6b656e4163636f756e74c3");
let info = TransactionSettings {
close_input_token_account: false,
create_output_token_account: true,
};
let decoded: TransactionSettings = rmp_serde::from_slice(&data)?;
assert_eq!(decoded, info);
Ok(())
}
#[test]
fn test_encode_route_plan_step() -> Result<(), EncError> {
let data = hex!("88a6616d6d4b6579c42019fc949cf6d288d076e39f923bf6f1b45da023310e606afc40cc080d5b25983aa56c6162656cac4d6574656f726120444c4d4da9696e7075744d696e74c420069b8857feab8184fb687f634618c035dac439dc1aeb3b5598a0f00000000001aa6f75747075744d696e74c420c6fa7af3bedbad3a3d65f36aabc97431b1bbe4c2d2f6e0e47ca60203452f5d61a8696e416d6f756e74ce3b9aca00a96f7574416d6f756e74ce08d0ed70a8616c6c6f63507062ce3b9aca00ab636f6e74657874536c6f74ce00bc614e");
let step = RoutePlanStep {
amm_key: METEORA_DLMM_WSOL_USDC,
label: "Meteora DLMM".into(),
input_mint: WSOL_ADDR,
output_mint: USDC_ADDR,
in_amount: 1_000_000_000, out_amount: 147_910_000, alloc_ppb: 1_000_000_000, fee_mint: None,
fee_amount: None,
context_slot: Some(12345678),
};
let encoded = rmp_serde::to_vec_named(&step)?;
assert_eq!(encoded, data);
Ok(())
}
#[test]
fn test_decode_route_plan_step() -> Result<(), DecError> {
let data = hex!("88a6616d6d4b6579c42019fc949cf6d288d076e39f923bf6f1b45da023310e606afc40cc080d5b25983aa56c6162656cac4d6574656f726120444c4d4da9696e7075744d696e74c420069b8857feab8184fb687f634618c035dac439dc1aeb3b5598a0f00000000001aa6f75747075744d696e74c420c6fa7af3bedbad3a3d65f36aabc97431b1bbe4c2d2f6e0e47ca60203452f5d61a8696e416d6f756e74ce3b9aca00a96f7574416d6f756e74ce08d0ed70a8616c6c6f63507062ce3b9aca00ab636f6e74657874536c6f74ce00bc614e");
let step = RoutePlanStep {
amm_key: METEORA_DLMM_WSOL_USDC,
label: "Meteora DLMM".into(),
input_mint: WSOL_ADDR,
output_mint: USDC_ADDR,
in_amount: 1_000_000_000, out_amount: 147_910_000, alloc_ppb: 1_000_000_000, fee_mint: None,
fee_amount: None,
context_slot: Some(12345678),
};
let decoded: RoutePlanStep = rmp_serde::from_slice(&data)?;
assert_eq!(decoded, step);
Ok(())
}
#[test]
fn test_encode_request_data() -> Result<(), EncError> {
let data = hex!("81a7476574496e666f80");
let req = RequestData::GetInfo(GetInfoRequest { dummy: None });
let encoded = rmp_serde::to_vec_named(&req)?;
assert_eq!(encoded, data);
Ok(())
}
#[test]
fn test_decode_request_data() -> Result<(), DecError> {
let data = hex!("81a7476574496e666f80");
let req = RequestData::GetInfo(GetInfoRequest { dummy: None });
let decoded: RequestData = rmp_serde::from_slice(&data)?;
assert_eq!(decoded, req);
Ok(())
}
#[test]
fn test_encode_server_message() -> Result<(), EncError> {
let data = hex!("81a953747265616d456e6483a26964cd3039a96572726f72436f6465cd01f8ac6572726f724d657373616765bb626f622074726970706564206f7665722074686520726f75746572");
let message = ServerMessage::StreamEnd(StreamEnd {
id: 12345,
error_code: Some(504),
error_message: Some("bob tripped over the router".into()),
});
let encoded = rmp_serde::to_vec_named(&message)?;
assert_eq!(encoded, data);
Ok(())
}
#[test]
fn test_decode_server_message() -> Result<(), DecError> {
let data = hex!("81a953747265616d456e6483a26964cd3039a96572726f72436f6465cd01f8ac6572726f724d657373616765bb626f622074726970706564206f7665722074686520726f75746572");
let message = ServerMessage::StreamEnd(StreamEnd {
id: 12345,
error_code: Some(504),
error_message: Some("bob tripped over the router".into()),
});
let decoded: ServerMessage = rmp_serde::from_slice(&data)?;
assert_eq!(decoded, message);
Ok(())
}
#[test]
fn test_other_server_message() -> Result<(), DecError> {
let unhandled = Value::Map(vec![(
Value::from("SomeOtherWeirdMessageType"),
Value::from(1),
)]);
let unhandled_data = rmp_serde::to_vec_named(&unhandled).expect("should encode");
let decoded: ServerMessage = rmp_serde::from_slice(&unhandled_data)?;
let unhandled_sm = ServerMessage::Other(unhandled);
assert_eq!(decoded, unhandled_sm);
Ok(())
}
#[test]
fn test_other_request_data() -> Result<(), DecError> {
let bad_request_data = Value::Map(vec![(
Value::from("BadDataType"),
Value::Map(vec![(Value::from("foo"), Value::from("bar"))]),
)]);
let unhandled = Value::Map(vec![
(Value::from("id"), Value::from(1)),
(Value::from("data"), bad_request_data.clone()),
]);
let unhandled_data = rmp_serde::to_vec_named(&unhandled).expect("should encode");
let decoded: ClientRequest = rmp_serde::from_slice(&unhandled_data)?;
let unhandled_msg = ClientRequest {
id: 1,
data: RequestData::Other(bad_request_data),
};
assert_eq!(decoded, unhandled_msg);
Ok(())
}
}