Build a trading bot

npm i @kashdao/sdk
export KASH_API_KEY="kash_test_…"        # staging key
export KASH_WEBHOOK_SECRET="whsec_…"     # from the app, for step 6

import { KashClient } from '@kashdao/sdk';

const kash = new KashClient({ apiKey: process.env.KASH_API_KEY! });
// kash_test_* → https://api-staging.kash.bot/v1  (Solana devnet)
// kash_live_* → https://api.kash.bot/v1          (Solana mainnet)

const { data: markets } = await kash.markets.list({ status: 'ACTIVE' });
const market = markets[0];

const quote = await kash.quotes.buy({
  marketId: market.id,
  outcomeIndex: 0,
  amountUsdcAtomic: 10_000_000n,   // 10 USDC into outcome 0
});

// quote.tokensOut = outcome tokens you'd receive (WAD); quote.pAfter = post-trade prices (WAD)
console.log('would receive', quote.tokensOut, 'tokens at', quote.effectivePrice);

import { randomUUID } from 'node:crypto';

const trade = await kash.trades.create(
  { marketId: market.id, outcomeIndex: 0, side: 'buy', amount: '10' },
  { idempotencyKey: randomUUID() },
);

console.log(trade.id, trade.status, trade.idempotent ? '(replayed)' : '(new)');

if (trade.confirmation) {
  // trade.confirmation = { token, expiresAt } — shown once, valid for 60 seconds.
  await kash.trades.confirm(trade.id, { token: trade.confirmation.token });
}

import express from 'express';

const app = express();

// IMPORTANT: verify against the RAW body, so capture bytes, don't pre-JSON-parse.
app.post('/webhooks/kash', express.raw({ type: 'application/json' }), async (req, res) => {
  const raw = req.body.toString('utf8');
  const signature = req.header('X-Kash-Signature') ?? '';
  const eventId = req.header('X-Kash-Event-Id') ?? '';

  let event;
  try {
    // Verifies the HMAC signature + 5-minute timestamp window, then parses. Throws on a bad signature.
    event = await kash.webhooks.constructEvent(raw, signature, process.env.KASH_WEBHOOK_SECRET!);
  } catch (err) {
    return res.status(400).send('invalid signature');
  }

  if (alreadyProcessed(eventId)) return res.status(200).send('dup');  // your idempotency store

  switch (event.type) {
    case 'trade.completed': /* event.data.txHash = Solana signature */ break;
    case 'trade.failed':
    case 'trade.rejected': /* surface + retry policy */ break;
    case 'trade.confirmation-required': /* call kash.trades.confirm */ break;
  }
  res.status(200).send('ok');   // 2xx fast; do slow work out of band
});

const settled = await kash.trades.waitForCompletion(trade.id);   // polls every 2s, up to 60s by default
console.log(settled.status, settled.txHash);   // 'completed' | 'failed' | 'rejected'

const summary = await kash.portfolio.get();                               // account-wide
const positions = await kash.portfolio.positions({ marketId: market.id }); // PositionResource[]

import { KashConflictError, KashNotFoundError } from '@kashdao/sdk';

try {
  const redemption = await kash.redemptions.create({ marketId: market.id, outcomeIndex: 0 });
  // { id, marketId, outcomeIndex, kind: 'resolved' | 'cancelled', sharesWad, status, idempotent }
  console.log(redemption.kind, redemption.sharesWad, redemption.status);
} catch (err) {
  if (err instanceof KashConflictError && err.code === 'POSITION_NOT_CLAIMABLE') {
    // not settled yet, losing outcome, or already redeemed
  } else if (err instanceof KashNotFoundError && err.code === 'REDEMPTIONS_NOT_ENABLED') {
    // self-service redemption is switched off
  } else {
    throw err;
  }
}

import {
  KashRateLimitError,
  KashAuthorizationError,
  KashValidationError,
  KashConflictError,
  KashMaintenanceError,
} from '@kashdao/sdk';

try {
  await kash.trades.create(/* … */);
} catch (err) {
  if (err instanceof KashRateLimitError) {
    await sleep((err.retryAfterSeconds ?? 1) * 1000);   // seconds; undefined if no Retry-After
  } else if (err instanceof KashConflictError) {
    // e.g. duplicate idempotency key with a different body, or already-claimed
  } else if (err instanceof KashAuthorizationError) {
    // missing scope / IP not allowed — fix the key, don't retry
  } else if (err instanceof KashMaintenanceError) {
    // 503 — trading temporarily unavailable; back off for err.retryAfterSeconds
  } else if (err instanceof KashValidationError) {
    // 400 — bad input; inspect err.issues and fix the request
  } else {
    throw err;
  }
}