Struct EntityStore 

pub struct EntityStore<T> { /* private fields */ }

Implementations

impl<T> EntityStore<T>

where T: Serialize + DeserializeOwned + Clone + Send + Sync + 'static,

pub fn new(mode: Mode) -> Self

pub fn subscribe(&self) -> Receiver<(String, T)>

Examples found in repository

examples/flip/flip_demo.rs (line 80)

async fn main() -> anyhow::Result<()> {
    let url = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "ws://127.0.0.1:8080".to_string());

    let view = std::env::var("VIEW").unwrap_or_else(|_| "SettlementGame/kv".to_string());

    let mut client = HyperStackClient::<SettlementGame>::new(url, &view);

    if let Ok(key) = std::env::var("KEY") {
        client = client.with_key(key);
    }

    let store = client.connect().await?;

    println!("connected, watching {}...\n", view);

    let mut updates = store.subscribe();

    loop {
        tokio::select! {
            Ok((key, game)) = updates.recv() => {
                println!("\n=== Game {} ===", key);
                println!("{}", serde_json::to_string_pretty(&game).unwrap_or_default());
            }
            _ = sleep(Duration::from_secs(30)) => {
                println!("No updates for 30s...");
            }
        }
    }
}

examples/pump/token_trades.rs (line 41)

async fn main() -> anyhow::Result<()> {
    let url = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "ws://127.0.0.1:8080".to_string());
    let mint = std::env::var("KEY").expect("KEY env var required (token mint address)");

    let client = HyperStackClient::<PumpToken>::new(url, "PumpToken/kv").with_key(&mint);

    let store = client.connect().await?;

    println!("watching trades for token {}...\n", mint);

    let mut updates = store.subscribe();
    let mut trade_history: VecDeque<TradeInfo> = VecDeque::with_capacity(100);

    loop {
        tokio::select! {
            Ok((_key, token)) = updates.recv() => {
                if let Some(trade) = token.last_trade {
                    trade_history.push_back(trade.clone());
                    if trade_history.len() > 100 {
                        trade_history.pop_front();
                    }

                    println!("[{}] {} | {}... | {:.4} SOL (total: {} trades)",
                        Utc::now().format("%H:%M:%S"),
                        trade.direction,
                        &trade.wallet[..8],
                        trade.amount_sol,
                        trade_history.len());
                }
            }
            _ = sleep(Duration::from_secs(60)) => {
                println!("No trades for 60s...");
            }
        }
    }
}

examples/pump/new_launches.rs (line 32)

async fn main() -> anyhow::Result<()> {
    let url = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "ws://127.0.0.1:8080".to_string());

    let client = HyperStackClient::<PumpToken>::new(url, "PumpToken/list");

    let store = client.connect().await?;

    println!("watching for new pump.fun token launches...\n");

    let mut updates = store.subscribe();

    loop {
        tokio::select! {
            Ok((mint, token)) = updates.recv() => {
                if token.name.is_some() || token.symbol.is_some() {
                    println!("\n[{}] new token launch", Utc::now().format("%Y-%m-%d %H:%M:%S UTC"));
                    println!("mint: {}", mint);
                    if let Some(name) = &token.name {
                        println!("name: {}", name);
                    }
                    if let Some(symbol) = &token.symbol {
                        println!("symbol: {}", symbol);
                    }
                    if let Some(creator) = &token.creator {
                        println!("creator: {}", creator);
                    }
                    if let Some(sol) = token.virtual_sol_reserves {
                        println!("initial liquidity: {:.4} SOL", sol as f64 / 1e9);
                    }
                }
            }
            _ = sleep(Duration::from_secs(60)) => {
                println!("No new launches for 60s...");
            }
        }
    }
}

pub async fn get(&self, key: &str) -> Option<T>

pub async fn all(&self) -> HashMap<String, T>

pub async fn all_vec(&self) -> Vec<T>

pub fn mode(&self) -> &Mode

Trait Implementations

impl<T> Clone for EntityStore<T>

where T: Serialize + DeserializeOwned + Clone + Send + Sync + 'static,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Default for EntityStore<T>

where T: Serialize + DeserializeOwned + Clone + Send + Sync + 'static,

fn default() -> Self

Returns the “default value” for a type.