polyte-cli 0.4.0

CLI tool for querying Polymarket Gamma API
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

mod activity;
mod builders;
mod holders;
mod live_volume;
mod open_interest;
mod positions;
mod traded;
mod trades;

use clap::{Subcommand, ValueEnum};
use color_eyre::eyre::Result;
use polyte_data::DataApi;

use crate::commands::data::{
    activity::UserActivityCommand, holders::HoldersCommand, live_volume::LiveVolumeCommand,
    open_interest::OpenInterestCommand, positions::PositionsCommand, traded::TradedCommand,
};

#[derive(Subcommand)]
pub enum DataCommand {
    /// Check API health status
    Health,
    /// Query user activity
    Activity(UserActivityCommand),
    /// Query builder leaderboard and volume
    Builders {
        #[command(subcommand)]
        command: builders::BuildersCommand,
    },
    /// Query top holders for markets
    Holders(HoldersCommand),
    /// Query trades
    Trades {
        #[command(subcommand)]
        command: trades::TradesCommand,
    },
    /// Get traded markets by user
    Traded(TradedCommand),
    /// Query user-specific data (positions, traded count)
    Positions(PositionsCommand),
    /// Get open interest for markets
    OpenInterest(OpenInterestCommand),
    /// Get live volume for an event
    LiveVolume(LiveVolumeCommand),
}

impl DataCommand {
    pub async fn run(self) -> Result<()> {
        let data = DataApi::new()?;

        match self {
            Self::Health => {
                let health = data.health().check().await?;
                println!("{}", serde_json::to_string_pretty(&health)?);
                Ok(())
            }
            Self::Activity(cmd) => cmd.run(&data).await,
            Self::Builders { command } => command.run(&data).await,
            Self::Holders(cmd) => cmd.run(&data).await,
            Self::Trades { command } => command.run(&data).await,
            Self::Traded(cmd) => cmd.run(&data).await,
            Self::Positions(cmd) => cmd.run(&data).await,
            Self::OpenInterest(cmd) => cmd.run(&data).await,
            Self::LiveVolume(cmd) => cmd.run(&data).await,
        }
    }
}

/// Sort order
#[derive(Debug, Clone, Copy, ValueEnum, Default)]
pub enum SortOrder {
    /// Ascending order
    Asc,
    /// Descending order
    #[default]
    Desc,
}

impl From<SortOrder> for polyte_data::types::SortDirection {
    fn from(order: SortOrder) -> Self {
        match order {
            SortOrder::Asc => Self::Asc,
            SortOrder::Desc => Self::Desc,
        }
    }
}