Types

interface OneSwapConfig {
  apiKey: string                          // 'sk_live_...' — sent as the x-sdk-key header
  environment?: 'mainnet' | 'devnet'      // default 'mainnet'; the SDK resolves the URL itself
  timeout?: number                        // per-request timeout in ms (default 30000)
}

interface CreateSwapArgs {
  userRef: string      // your stable id for the end-user (one open swap per userRef at a time)
  inSymbol: string     // token the user deposits, e.g. 'CBTC'
  amountIn: number     // decimal amount of inSymbol to swap
  outSymbol: string    // token to return to the user, e.g. 'HTEST'
  poolId?: string      // pin the pool returned by a quote (SDK 1.3.0+)
  minOut?: number      // optional hard floor on output; below it the swap is refunded
  slippageBps?: number // optional; default 200 (2%)
}

interface WaitForSwapOptions {
  pollMs?: number    // default 3000
  timeoutMs?: number // default 900000 (15 min)
}

type SwapStatus =
  | 'awaiting_deposit'
  | 'deposit_detected'
  | 'swapping'
  | 'recovering'
  | 'needs_review'
  | 'returned'
  | 'refunded'
  | 'expired'
  | 'failed'
  | 'cancelled'

interface Swap {
  id: string                    // 'esc_...'
  status: SwapStatus
  poolId: string
  inSymbol: string
  outSymbol: string
  amountIn: number
  minOut: number | null
  depositParty: string          // the Canton party id the end-user must fund
  deadline: string              // ISO timestamp; deposit must arrive before this
  amountOut?: number | null     // set once returned
  senderParty?: string | null   // the party that funded (output is returned here)
  error?: string | null
}

interface GetQuoteArgs {
  from: string      // symbol of the token you pay with, e.g. 'CC'
  to: string        // symbol of the token you receive, e.g. 'CBTC'
  amount: number    // amount of `from` to swap (positive)
  poolId?: string   // pin a pool instead of resolving from symbols
  walletId?: string // custodial wallet id — adds walletBalanceIn/sufficientBalance
}

interface Quote {
  amountOut: number            // expected output in the `to` token
  priceImpactPct: number       // price impact of this trade size, in percent
  networkFeeIn: number         // per-swap network fee carved from the input. Priced with the
                               // settlement fee model when quoting with your SDK key
                               // (feeModel 'deposit'); 0 under the 'prepaid' model
  swapFeeBps: number           // the pool's configured fee, in basis points
  effFeeBps: number            // effective fee after any discount
  discountBps: number          // discount applied to the platform slice, in bps
  newReserveX: number          // pool reserve X after this swap
  newReserveY: number          // pool reserve Y after this swap
  effInput: number             // input actually swapped (amount − networkFeeIn)
  inputCredit: number          // input credited to the pool reserve (effInput − platformFee)
  platformFee: number          // platform slice of the pool fee, in the input token
  lpFee: number                // LP slice of the pool fee, in the input token
  inSym: string                // symbol of the input token
  lpShare: number              // LP share of the pool fee (fraction)
  platformShare: number        // platform share of the pool fee (fraction)
  effectiveFeeRate: number     // effFeeBps as a fraction
  chargedPlatformRate: number  // platform rate actually charged, as a fraction
  walletBalanceIn?: number     // only when walletId was passed: spendable input balance
  sufficientBalance?: boolean  // only when walletId was passed: balance covers `amount`
  feeModel?: 'deposit' | 'prepaid' // how the network fee was priced: 'deposit' (carved from
                               // the input — the model your SDK-keyed quotes use, matching
                               // settlement) or 'prepaid' (fee charged outside the input)
}

interface QuoteResult extends Quote {
  poolId: string  // the pool the pair resolved to
  xToY: boolean   // direction within that pool (true = paying with assetX)
}

interface Token {
  symbol: string       // display symbol, e.g. 'CC'
  admin: string        // on-ledger instrument admin party
  id: string           // on-ledger instrument id, e.g. 'Amulet'
  registryUrl?: string // registrar base URL, when the token needs a dedicated one
}

interface PoolAsset {
  symbol: string
  admin: string
  id: string
}

interface Pool {
  id: string                        // 'rt-...'
  name: string | null
  assetX: PoolAsset
  assetY: PoolAsset
  reserveX: number                  // live reserve of assetX
  reserveY: number                  // live reserve of assetY
  feeBps: number                    // total swap fee in basis points
  totalLpTokens: number
  visible?: boolean
  swapsEnabled?: boolean            // false = liquidity-only mode (quotes/swaps rejected)
  asyncSettlement?: boolean
  lpFeeShare?: number | null
  platformFeeShare?: number | null
  createdAt?: string
  primary?: boolean                 // pools.list() only: the operator-designated default pool
  swaps?: number                    // pools.list() only: settled-swap count
}

interface PoolDetail {
  pool: Pool
  swaps: PoolSwap[]  // full settled-swap history, oldest first
}

// A settled swap as recorded by the backend. Wire shape is the raw ledger row:
// snake_case keys, numeric columns serialized as strings.
interface PoolSwap {
  id: string
  pool_id: string
  at: string              // ISO timestamp
  update_id: string | null
  trader: string
  x_to_y: boolean
  amount_in: string
  amount_out: string
  network_fee_in: string
  swap_fee: string
  new_reserve_x: string
  new_reserve_y: string
}

interface PoolTicker {
  poolId: string
  pair: string           // e.g. 'CC/CBTC' — assetX/assetY as configured on the pool
  base: string | null    // the asset being priced (e.g. 'CBTC'); null when un-priceable
  pricedVia: string      // how the USD value was derived (e.g. 'CC/USDCx')
  price: { usd: string | null }
  priceChange24h: {
    pct: string | null   // percent change vs ~24h ago; null during warm-up
    from: string | null  // USD price ~24h ago
    to: string | null    // USD price now
  }
  volume24h: {
    usd: string | null   // 24h volume at current USD prices
    swaps: number        // number of swaps in the window
  }
  asOf: string           // ISO timestamp the ticker was computed
}

interface PoolPairCandidate {
  poolId: string
  name: string | null
  assetX: string  // symbol
  assetY: string  // symbol
}