Quickstart

pip install kashdao-protocol-sdk

import asyncio
import os

from kashdao_protocol_sdk import create_solana_client


async def main() -> None:
    async with create_solana_client(rpc_url=os.environ["SOLANA_RPC_URL"]) as kash:  # mainnet-beta
        config = await kash.protocol.config()
        print(f"protocol fee {config.default_protocol_fee_bps} bps")

        # By numeric market id, or by the market account address
        # (the REST API's `contractAddress` for a Solana market).
        market = await kash.markets.get(5)
        print(market.status, market.num_outcomes)
        for k, p in enumerate(market.probabilities_wad):
            print(f"outcome {k}: {p / 10**16:.2f}%")


asyncio.run(main())

# What would 5 USDC of outcome 0 buy?
buy = await kash.markets.quote_buy(market=5, outcome=0, amount_usdc=5_000_000)
print(f"{buy.tokens_out_wad} WAD, fee {buy.protocol_fee_usdc} atomic USDC")

# What would selling 0.1 token of outcome 1 pay? Only tokens traders hold can
# be sold, so a sell quote larger than that raises KashValidationError (ExceedsSupply).
sell = await kash.markets.quote_sell(market=5, outcome=1, tokens_in_wad=10**17)
print(f"{sell.amount_out_usdc} atomic USDC")

from solders.keypair import Keypair

from kashdao_protocol_sdk import keypair_signer

keypair = Keypair.from_base58_string(os.environ["SOLANA_SECRET_KEY"])
# or, for a solana-keygen JSON file's byte array:
# keypair = Keypair.from_bytes(bytes(json.loads(...)))
signer = keypair_signer(keypair)

print(f"USDC: {await kash.account.usdc_balance(keypair.pubkey())} (atomic)")

# Buy 1 USDC of outcome 0, accepting at most 1% below the quote.
# The first buy also opens the position account in the same transaction.
bought = await kash.trades.buy(
    market=5,
    outcome=0,
    amount_usdc=1_000_000,
    max_slippage_bps=100,
    signer=signer,
    compute_unit_price_micro_lamports=10_000,  # optional priority fee
)
print(f"bought: {bought.signature} (floor {bought.plan.min_tokens_out_wad} WAD)")

# Sell the whole position back.
position = await kash.account.position(market=5, outcome=0, owner=keypair.pubkey())
sold = await kash.trades.sell(
    market=5,
    outcome=0,
    tokens_in_wad=position.balance_wad,
    max_slippage_bps=100,
    signer=signer,
)
print(f"sold: {sold.signature} for at least {sold.plan.min_amount_out_usdc} atomic USDC")

plan = await kash.trades.build_buy(
    market=5,
    outcome=0,
    amount_usdc=1_000_000,
    max_slippage_bps=100,
    trader=keypair.pubkey(),
)
simulation = await kash.trades.simulate(plan, payer=keypair.pubkey())
if simulation.error is not None:
    raise SystemExit(f"refused: {simulation.error.name or simulation.error.raw}")

result = await kash.trades.send(plan, signer=signer)
print(result.signature)

market = await kash.markets.get(5)
redeem = kash.trades.redeem if market.status == "resolved" else kash.trades.redeem_cancelled

# amount_wad defaults to the whole position. A losing outcome pays zero.
redeemed = await redeem(market=5, outcome=0, max_slippage_bps=50, signer=signer)
print(f"redeemed: {redeemed.signature}")

closed = await kash.trades.close_position(market=5, outcome=0, signer=signer)
print(f"rent returned to {closed.plan.rent_recipient}")

from kashdao_protocol_sdk import (
    KashSimulationRevertedError,
    KashTransactionExpiredError,
    KashTransactionOutcomeUnknownError,
    KashValidationError,
)

try:
    await kash.trades.buy(
        market=5, outcome=0, amount_usdc=1_000_000, max_slippage_bps=100, signer=signer
    )
except KashValidationError as err:
    print(f"refused before signing: {err.program_error or err}")
except KashSimulationRevertedError as err:
    print(f"preflight refused: {(err.context or {}).get('program_error') or err}")
except KashTransactionOutcomeUnknownError as err:
    # May have landed: look the signature up before retrying.
    print(f"outcome unknown: {err.signature}")
except KashTransactionExpiredError:
    pass  # did not land: safe to rebuild with a fresh quote and resend