TypeScript SDK

pnpm add @kashdao/sdk
# or: npm install @kashdao/sdk
# or: yarn add @kashdao/sdk
# or: bun add @kashdao/sdk

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

const kash = new KashClient({
  apiKey: process.env.KASH_API_KEY!,     // 'kash_live_...' or 'kash_test_...'
  // Everything below is optional:
  timeoutMs: 30_000,                     // per request, default 30s
  maxRetries: 3,                         // default 3, exponential backoff + jitter
  userAgentSuffix: 'acme-trader/1.4.2',  // appended to the User-Agent
});

const page = await kash.markets.list({ status: 'ACTIVE', limit: 50 });
const market = await kash.markets.get(page.data[0].id);

// Recent trades against a market, newest first:
const feed = await kash.markets.predictions(market.id, { side: 'buy', outcomeIndex: 0 });

const buy = await kash.quotes.buy({
  marketId:         market.id,
  outcomeIndex:     0,
  amountUsdcAtomic: 10_000_000n,           // 10 USDC
});
console.log(buy.tokensOut, buy.effectivePrice, buy.impliedProbability);

const sell = await kash.quotes.sell({
  marketId:     market.id,
  outcomeIndex: 0,
  tokensInWad:  '1000000000000000000',     // 1 outcome token
});
console.log(sell.usdcOut);

const trade = await kash.trades.create({
  marketId:     market.id,
  outcomeIndex: 0,
  amount:       '100',                     // USDC decimal string, up to 6 fractional digits
  side:         'buy',
  metadata:     { strategy: 'momentum-v2', cohort: 'beta' },
}, { idempotencyKey: crypto.randomUUID() });

console.log(trade.id, trade.status, trade.idempotent);

if (trade.confirmation) {
  // High-value gate hit. The token is returned once and expires 60 seconds after issue.
  await kash.trades.confirm(trade.id, { token: trade.confirmation.token });
}

// Poll until completed / failed / rejected
const final = await kash.trades.waitForCompletion(trade.id, {
  pollIntervalMs: 2_000,                   // default 2s
  timeoutMs:      60_000,                  // default 60s
});

console.log(final.status, final.txHash, final.tokensOut);

const redemption = await kash.redemptions.create({ marketId: market.id, outcomeIndex: 0 });
console.log(redemption.kind, redemption.sharesWad, redemption.status, redemption.idempotent);

const summary   = await kash.portfolio.get();                            // { smartAccountAddress, activePositions, totalCostBasisAtomic }
const positions = await kash.portfolio.positions({ marketId: market.id }); // PositionResource[], not paginated

// Yield positions now, then again whenever they change:
const controller = new AbortController();
for await (const current of kash.portfolio.watchPositions({ signal: controller.signal })) {
  rebalance(current);
}

const page = await kash.trades.list({ limit: 25, status: 'completed' });

// First page only
console.log(page.data.length, page.hasMore, page.nextCursor);

// Or walk every trade across every page
for await (const trade of page) {
  console.log(trade.id, trade.txHash);
}

// Or step manually
const next = await page.getNextPage(); // Page<T> | null

import express from 'express';

app.post('/webhooks/kash',
  express.raw({ type: 'application/json' }),   // verify against the RAW body
  async (req, res) => {
    let event;
    try {
      event = await kash.webhooks.constructEvent(
        req.body.toString('utf8'),
        req.header('x-kash-signature') ?? '',
        process.env.KASH_WEBHOOK_SECRET!
      );
    } catch (err) {
      // KashWebhookSignatureError: bad, expired or malformed signature
      return res.sendStatus(400);
    }

    switch (event.type) {
      case 'trade.completed':
        await onTradeCompleted(event.data);    // typed: TradeCompletedPayload
        break;
      case 'trade.failed':
      case 'trade.rejected':
        await onTradeFailed(event.data);       // carries errorCode + errorMessage
        break;
      case 'trade.confirmation-required':
        await onConfirmationRequired(event.data);
        break;
    }
    res.sendStatus(200);
  }
);

import {
  KashError,
  KashAuthenticationError,    // 401
  KashAuthorizationError,     // 403 (INSUFFICIENT_SCOPE, IP_NOT_ALLOWED)
  KashNotFoundError,          // 404
  KashConflictError,          // 409, and 410 for an expired idempotency key
  KashRateLimitError,         // 429
  KashMaintenanceError,       // 503 temporarily unavailable (API_TRADE_PROCESSING_HALTED, ROUTE_DISABLED)
  KashServerError,            // other 5xx
  KashValidationError,        // 400 / 422, or a response that failed schema validation
  KashNetworkError,
  KashTimeoutError,
  KashAbortedError,           // your AbortSignal fired
  KashWebhookSignatureError,
  KashConfigurationError,
} from '@kashdao/sdk';

try {
  await kash.trades.create(body);
} catch (err) {
  if (err instanceof KashRateLimitError) {
    console.log(`Back off for ${err.retryAfterSeconds ?? 1}s`);
  } else if (err instanceof KashAuthorizationError && err.code === 'INSUFFICIENT_SCOPE') {
    console.log('Re-issue the key with trades:write');
  } else if (KashError.isKashError(err)) {
    // Cross-realm-safe brand check (works across worker / iframe boundaries)
    console.log(err.code, err.statusCode, err.requestId);
  } else {
    throw err;
  }
}

const kash = new KashClient({
  apiKey,
  hooks: {
    onRequest:  (e) => log.info('kash.request',  { method: e.method, url: e.url, attempt: e.attempt }),
    onResponse: (e) => log.info('kash.response', { status: e.status, durationMs: e.durationMs, rateLimit: e.rateLimit }),
    onRetry:    (e) => log.warn('kash.retry',    { attempt: e.attempt, reason: e.reason, delayMs: e.delayMs }),
    onError:    (e) => log.error('kash.error',   { code: e.code, status: e.status, attempt: e.attempt }),
  },
});

const readOnly = new KashClient({ apiKey: process.env.KASH_READ_KEY! });
const trading  = readOnly.withConfig({ apiKey: process.env.KASH_TRADE_KEY! });
const slow     = readOnly.withConfig({ timeoutMs: 120_000 });

import { createMockKashClient, DEFAULT_TRADE } from '@kashdao/sdk/testing';

const mock = createMockKashClient({
  // Override specific methods; everything else returns a default
  trades: {
    create: async () => ({ ...DEFAULT_TRADE, status: 'pending', idempotent: false }),
  },
});

// Inject into your code under test
const result = await yourTradingBot.run(mock);

const kash = new KashClient({
  apiKey:     process.env.KASH_API_KEY!,
  apiVersion: '2026-04-29',
});