Curated Packs

use std::time::{SystemTime, UNIX_EPOCH};
use limitless_exchange_rust_sdk::{
    Client, HmacCredentials, PackBuyParams, PackQuoteParams, PackPosition,
    PackClaimResponse, PackPollOptions, pack_min_payout,
};

type ExampleResult<T> = Result<T, Box<dyn std::error::Error>>;

fn create_client() -> ExampleResult<Client> {
    let http = Client::builder()
        .hmac_credentials(HmacCredentials {
            token_id: std::env::var("LMTS_TOKEN_ID")?,
            secret: std::env::var("LMTS_TOKEN_SECRET")?,
        })
        .build()?;
    Ok(Client::from_http_client(http)?)
}

async fn check_vault_approval(client: &Client, profile_id: i32) -> ExampleResult<()> {
    let state = client.partner_accounts.check_allowances(profile_id).await?;
    let confirmed = state.targets.iter().any(|target| {
        target.target_type == "USDC_ALLOWANCE"
            && target.label == "parlay-treasury-vault"
            && target.confirmed && target.status == "confirmed"
    });
    if !confirmed {
        return Err("Confirm the Pack vault allowance before preparing a buy".into());
    }
    Ok(())
}

async fn prepare_purchase(
    client: &Client, profile_id: i32, pack_id: &str, purchase_key: &str,
) -> ExampleResult<PackBuyParams> {
    check_vault_approval(client, profile_id).await?;
    let quote = client.packs.quote(&PackQuoteParams {
        pack_id: pack_id.into(),
        stake_amount: "10000000".into(),
    }).await?;
    if !quote.eligible {
        return Err(format!("Ineligible: {:?}", quote.ineligible_reasons).into());
    }
    let payout = quote.potential_payout.as_deref().ok_or("Missing quoted payout")?;
    let now = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
    Ok(PackBuyParams {
        on_behalf_of: profile_id,
        pack_id: pack_id.into(),
        stake_amount: "10000000".into(), // 10 USDC
        min_payout_amount: pack_min_payout(payout, 100)?,
        deadline: (now + 120).to_string(),
        idempotency_key: purchase_key.into(),
    })
}

async fn submit_saved_purchase(
    client: &Client, saved: &PackBuyParams,
) -> ExampleResult<PackPosition> {
    let buy = client.packs.buy(saved).await?;
    Ok(client.packs.wait_for_position(
        saved.on_behalf_of, &buy.position.id, PackPollOptions::default(),
    ).await?)
}

async fn claim_winning_position(
    client: &Client, profile_id: i32, position_id: &str,
) -> ExampleResult<PackClaimResponse> {
    let position = client.packs.get_position(profile_id, position_id).await?;
    if position.status != "WON" {
        return Err("Position is not WON".into());
    }
    Ok(client.packs.claim(
        profile_id, position_id, PackPollOptions::default(),
    ).await?)
}