meteora-sdk 0.6.0

meteora sdk
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
135
136
137
138
139

use serde::{Deserialize, Serialize};
use solana_sdk::pubkey::Pubkey;
use std::fmt;

/// Result type alias for Meteora operations
pub type MeteoraResult<T> = Result<T, MeteoraError>;

/// Error types for Meteora operations
#[derive(Debug)]
pub enum MeteoraError {
    RpcError(String),
    AccountNotFound(String),
    InvalidPoolData,
    TransactionFailed(String),
    DeserializationError(String),
    InvalidAccountData,
    CalculationError(String),
    NoLiquidityPoolFound,
    Error(String),
    NoHistoricalData,
    SlippageExceeded,
    InsufficientBalance,
    InvalidInput(String),
    SimulationFailed(String),
    TransactionTimeout,
    InvalidPrice,
}

/// Token price information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenPrice {
    pub token_mint: Pubkey,
    pub sol_price: f64,
    pub usd_price: f64,
    pub timestamp: i64,
    pub liquidity: u64,
}

/// Candlestick data for price charts
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CandleStick {
    pub open: f64,
    pub high: f64,
    pub low: f64,
    pub close: f64,
    pub volume: f64,
    pub timestamp: i64,
    pub time_frame: TimeFrame,
}

/// Supported time frames for chart data
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum TimeFrame {
    M1,  // 1分钟
    M5,  // 5分钟
    M15, // 15分钟
    H1,  // 1小时
    H4,  // 4小时
    D1,  // 1天
}

impl fmt::Display for TimeFrame {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            TimeFrame::M1 => write!(f, "1m"),
            TimeFrame::M5 => write!(f, "5m"),
            TimeFrame::M15 => write!(f, "15m"),
            TimeFrame::H1 => write!(f, "1h"),
            TimeFrame::H4 => write!(f, "4h"),
            TimeFrame::D1 => write!(f, "1d"),
        }
    }
}

/// Liquidity pool information
#[derive(Debug, Clone)]
pub struct PoolInfo {
    pub address: Pubkey,
    pub token_a_mint: Pubkey,
    pub token_b_mint: Pubkey,
    pub token_a_reserve: Pubkey,
    pub token_b_reserve: Pubkey,
    pub lp_mint: Pubkey,
    pub fee_account: Pubkey,
    pub trade_fee_bps: u64,
    pub token_a_decimals: u8,
    pub token_b_decimals: u8,
    pub token_a_reserve_amount: u64,
    pub token_b_reserve_amount: u64,
    pub lp_supply: u64,
}

/// Token information and metadata
#[derive(Debug, Clone)]
pub struct TokenInfo {
    pub mint: Pubkey,
    pub decimals: u8,
    pub supply: u64,
    pub holder_count: u64,
    pub metadata: Option<TokenMetadata>,
}

/// Token metadata from on-chain data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenMetadata {
    pub name: String,
    pub symbol: String,
    pub uri: String,
}

/// Parameters for executing a trade
#[derive(Debug, Clone)]
pub struct TradeParams {
    pub input_mint: Pubkey,
    pub output_mint: Pubkey,
    pub amount_in: u64,
    pub slippage_bps: u16,
    pub user: Pubkey,
}

/// Quote information for a proposed trade
#[derive(Debug, Clone)]
pub struct TradeQuote {
    pub amount_out: u64,
    pub min_amount_out: u64,
    pub price_impact: f64,
    pub fee_amount: u64,
    pub route: Vec<Pubkey>,
}

/// Simulation results for a swap operation
#[derive(Debug, Clone)]
pub struct SwapSimulation {
    pub success: bool,
    pub logs: Vec<String>,
    pub units_consumed: u64,
    pub price_impact: f64,
    pub actual_output: u64,
}