precolator-program 1.0.0

Core Rust library for the Precolator perpetual futures trading protocol on Solana — oracle management, position handling, risk engine, and liquidation system.
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

// State structures for market and position data

use serde::{Deserialize, Serialize};
use solana_program::pubkey::Pubkey;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Market {
    pub market_id: Pubkey,
    pub admin: Pubkey,
    pub collateral_mint: Pubkey,
    pub vault: Pubkey,
    pub oracle: Pubkey,
    pub max_leverage: u8,
    pub total_volume: u64,
    pub trade_count: u64,
    pub open_interest: u64,
    pub insurance_fund: u64,
    pub created_at: i64,
    pub is_resolved: bool,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum PositionSide {
    Long,
    Short,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum PositionStatus {
    Open,
    Closed,
    Liquidated,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Position {
    pub position_id: Pubkey,
    pub trader: Pubkey,
    pub market_id: Pubkey,
    pub side: PositionSide,
    pub size: u64,
    pub entry_price: u64,
    pub current_price: u64,
    pub collateral: u64,
    pub leverage: u8,
    pub liquidation_price: u64,
    pub status: PositionStatus,
    pub pnl: i64,
    pub pnl_percent: i32,
    pub opened_at: i64,
    pub closed_at: i64,
    pub last_updated: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Account {
    pub owner: Pubkey,
    pub market_id: Pubkey,
    pub balance: u64,
    pub total_deposited: u64,
    pub total_withdrawn: u64,
    pub position_count: u64,
    pub created_at: i64,
    pub is_active: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LiquidityPool {
    pub pool_id: Pubkey,
    pub market_id: Pubkey,
    pub available_liquidity: u64,
    pub utilization_pct: u8,
    pub fee_accrued: u64,
}

impl Market {
    pub fn new(market_id: Pubkey, admin: Pubkey, collateral_mint: Pubkey, vault: Pubkey, oracle: Pubkey) -> Self {
        Self {
            market_id,
            admin,
            collateral_mint,
            vault,
            oracle,
            max_leverage: 50,
            total_volume: 0,
            trade_count: 0,
            open_interest: 0,
            insurance_fund: 0,
            created_at: 0,
            is_resolved: false,
        }
    }
}

impl Position {
    pub fn new(
        position_id: Pubkey,
        trader: Pubkey,
        market_id: Pubkey,
        side: PositionSide,
        size: u64,
        entry_price: u64,
        collateral: u64,
        leverage: u8,
    ) -> Self {
        let liquidation_price = match side {
            PositionSide::Long => {
                ((entry_price as u128 * (leverage - 1) as u128) / leverage as u128) as u64
            }
            PositionSide::Short => {
                ((entry_price as u128 * (leverage + 1) as u128) / leverage as u128) as u64
            }
        };

        Self {
            position_id,
            trader,
            market_id,
            side,
            size,
            entry_price,
            current_price: entry_price,
            collateral,
            leverage,
            liquidation_price,
            status: PositionStatus::Open,
            pnl: 0,
            pnl_percent: 0,
            opened_at: 0,
            closed_at: 0,
            last_updated: 0,
        }
    }
}