Curated Packs

import os
import time
from limitless_sdk import (
    Client, HMACCredentials, PackBuyParams, PackQuoteParams,
    pack_min_payout, classify_pack_error,
)

def create_client() -> Client:
    return Client(hmac_credentials=HMACCredentials(
        token_id=os.environ["LMTS_TOKEN_ID"],
        secret=os.environ["LMTS_TOKEN_SECRET"],
    ))

async def browse(client: Client):
    return await client.packs.list()
    # Also: await client.packs.search("football"), await client.packs.get(pack_id)

async def check_vault_approval(client: Client, profile_id: int):
    state = await client.partner_accounts.check_allowances(profile_id)
    vault = next((
        target for target in state.targets
        if target.type == "USDC_ALLOWANCE"
        and target.label == "parlay-treasury-vault"
    ), None)
    if vault is None or not vault.confirmed or vault.status != "confirmed":
        raise RuntimeError("Confirm the Pack vault allowance before preparing a buy")
    return state.wallet_address

async def prepare_purchase(
    client: Client, profile_id: int, pack_id: str, purchase_key: str,
) -> PackBuyParams:
    await check_vault_approval(client, profile_id)
    quote = await client.packs.quote(PackQuoteParams(
        pack_id=pack_id, stake_amount="10000000",
    ))
    if not quote.eligible:
        raise ValueError(f"Ineligible: {quote.ineligible_reasons}")
    if quote.potential_payout is None:
        raise ValueError("Missing quoted payout")
    return PackBuyParams(
        on_behalf_of=profile_id,
        pack_id=pack_id,
        stake_amount="10000000",  # 10 USDC
        min_payout_amount=pack_min_payout(quote.potential_payout, 100),
        deadline=str(int(time.time()) + 120),
        idempotency_key=purchase_key,
    )

async def submit_saved_purchase(client: Client, saved: PackBuyParams):
    buy = await client.packs.buy(saved)
    return await client.packs.wait_for_position(
        saved.on_behalf_of, buy.position.id, max_attempts=60, interval=5,
    )

async def read_positions(client: Client, profile_id: int):
    return await client.packs.list_positions(profile_id, limit=20, offset=0)

async def claim_winning_position(client: Client, profile_id: int, position_id: str):
    position = await client.packs.get_position(profile_id, position_id)
    if position.status != "WON":
        raise ValueError("Position is not WON")
    claim = await client.packs.claim(
        profile_id, position_id, max_attempts=60, interval=5,
    )
    return {"wallet": position.wallet, "tx_hash": claim.tx_hash}

async def recover_claim(
    client: Client, profile_id: int, position_id: str, redemption_tx_hash: str,
):
    return await client.packs.confirm_claim(
        profile_id, position_id, redemption_tx_hash,
    )