> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kaleidoswap.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Examples

> Common integration examples for the Kaleido SDK

## Market Data

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { KaleidoClient } from 'kaleido-sdk';

  const client = KaleidoClient.create({
    baseUrl: 'https://api.regtest.kaleidoswap.com',
  });

  const [assets, pairs] = await Promise.all([
    client.maker.listAssets(),
    client.maker.listPairs(),
  ]);

  console.log(`Assets: ${assets.assets.length}`);
  console.log(`Pairs: ${pairs.pairs.length}`);

  for (const pair of pairs.pairs.slice(0, 5)) {
    console.log(`${pair.base.ticker}/${pair.quote.ticker}`);
  }
  ```

  ```python Python theme={null}
  from kaleido_sdk import KaleidoClient

  client = KaleidoClient.create(
      base_url="https://api.regtest.kaleidoswap.com"
  )

  assets = await client.maker.list_assets()
  pairs = await client.maker.list_pairs()

  print(f"Assets: {len(assets.assets)}")
  print(f"Pairs: {len(pairs.pairs)}")

  for pair in pairs.pairs[:5]:
      print(f"{pair.base.ticker}/{pair.quote.ticker}")
  ```
</CodeGroup>

## Request a Quote

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { KaleidoClient, Layer } from 'kaleido-sdk';

  const client = KaleidoClient.create();

  const quote = await client.maker.getQuote({
    from_asset: { asset_id: 'BTC', layer: Layer.BTC_LN, amount: 100000 },
    to_asset: { asset_id: 'USDT', layer: Layer.RGB_LN },
  });

  console.log(`RFQ ID: ${quote.rfq_id}`);
  console.log(`Price: ${quote.price}`);
  console.log(`From: ${quote.from_asset.amount} ${quote.from_asset.ticker}`);
  console.log(`To: ${quote.to_asset.amount} ${quote.to_asset.ticker}`);
  ```

  ```python Python theme={null}
  from kaleido_sdk import KaleidoClient, Layer, PairQuoteRequest, SwapLegInput

  client = KaleidoClient.create()

  quote = await client.maker.get_quote(
      PairQuoteRequest(
          from_asset=SwapLegInput(asset_id="BTC", layer=Layer.BTC_LN, amount=100000),
          to_asset=SwapLegInput(asset_id="USDT", layer=Layer.RGB_LN),
      )
  )

  print(f"RFQ ID: {quote.rfq_id}")
  print(f"Price: {quote.price}")
  print(f"From: {quote.from_asset.amount} {quote.from_asset.ticker}")
  print(f"To: {quote.to_asset.amount} {quote.to_asset.ticker}")
  ```
</CodeGroup>

## Create a Swap Order

This mirrors the order-based flow that is implemented in the SDK today: request a quote, create an order, then poll for status.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { KaleidoClient, Layer, ReceiverAddressFormat } from 'kaleido-sdk';

  const client = KaleidoClient.create();

  const quote = await client.maker.getQuote({
    from_asset: { asset_id: 'BTC', layer: Layer.BTC_LN, amount: 100000 },
    to_asset: { asset_id: 'USDT', layer: Layer.RGB_LN },
  });

  const order = await client.maker.createSwapOrder({
    rfq_id: quote.rfq_id,
    from_asset: quote.from_asset,
    to_asset: quote.to_asset,
    receiver_address: {
      address: 'demo-receiver-address',
      format: ReceiverAddressFormat.BOLT11,
    },
  });

  const finalOrder = await client.maker.waitForSwapCompletion(order.id, {
    accessToken: order.access_token,
    timeout: 300000,
    pollInterval: 2000,
    onStatusUpdate: (status) => console.log(`Status: ${status}`),
  });

  console.log(finalOrder.status);
  ```

  ```python Python theme={null}
  from kaleido_sdk import (
      CreateSwapOrderRequest,
      KaleidoClient,
      Layer,
      PairQuoteRequest,
      ReceiverAddressFormat,
      SwapCompletionOptions,
      SwapLegInput,
  )

  client = KaleidoClient.create()

  quote = await client.maker.get_quote(
      PairQuoteRequest(
          from_asset=SwapLegInput(asset_id="BTC", layer=Layer.BTC_LN, amount=100000),
          to_asset=SwapLegInput(asset_id="USDT", layer=Layer.RGB_LN),
      )
  )

  order = await client.maker.create_swap_order(
      CreateSwapOrderRequest(
          rfq_id=quote.rfq_id,
          from_asset=quote.from_asset,
          to_asset=quote.to_asset,
          receiver_address={
              "address": "demo-receiver-address",
              "format": ReceiverAddressFormat.BOLT11,
          },
      )
  )

  final_order = await client.maker.wait_for_swap_completion(
      order.id,
      SwapCompletionOptions(
          timeout=300.0,
          poll_interval=2.0,
          on_status_update=lambda status: print(f"Status: {status}"),
      ),
  )

  print(final_order.status)
  ```
</CodeGroup>

## Atomic Swap Initialization

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { KaleidoClient, Layer } from 'kaleido-sdk';

  const client = KaleidoClient.create({
    baseUrl: 'https://api.signet.kaleidoswap.com',
  });

  const quote = await client.maker.getQuote({
    from_asset: { asset_id: 'BTC', layer: Layer.BTC_LN, amount: 4100000 },
    to_asset: { asset_id: 'USDT', layer: Layer.RGB_LN },
  });

  const swap = await client.maker.initSwap({
    rfq_id: quote.rfq_id,
    from_asset: quote.from_asset.asset_id,
    from_amount: quote.from_asset.amount,
    to_asset: quote.to_asset.asset_id,
    to_amount: quote.to_asset.amount,
  });

  console.log(swap.payment_hash);
  console.log(swap.swapstring);
  ```

  ```python Python theme={null}
  from kaleido_sdk import KaleidoClient, Layer, PairQuoteRequest, SwapLegInput, SwapRequest

  client = KaleidoClient.create(
      base_url="https://api.signet.kaleidoswap.com"
  )

  quote = await client.maker.get_quote(
      PairQuoteRequest(
          from_asset=SwapLegInput(asset_id="BTC", layer=Layer.BTC_LN, amount=4_100_000),
          to_asset=SwapLegInput(asset_id="USDT", layer=Layer.RGB_LN),
      )
  )

  swap = await client.maker.init_swap(
      SwapRequest(
          rfq_id=quote.rfq_id,
          from_asset=quote.from_asset.asset_id,
          from_amount=quote.from_asset.amount,
          to_asset=quote.to_asset.asset_id,
          to_amount=quote.to_asset.amount,
      )
  )

  print(swap.payment_hash)
  print(swap.swapstring)
  ```
</CodeGroup>

## WebSocket Streaming

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { KaleidoClient } from 'kaleido-sdk';

  const client = KaleidoClient.create({
    baseUrl: 'https://api.signet.kaleidoswap.com',
  });

  client.maker.enableWebSocket('wss://api.signet.kaleidoswap.com/ws/my-client-id');

  const stop = await client.maker.streamQuotesByTicker(
    'BTC',
    'USDT',
    100000,
    (quote) => console.log(quote.price),
    { pollInterval: 2000 }
  );

  setTimeout(() => stop(), 10000);
  ```

  ```python Python theme={null}
  from kaleido_sdk import KaleidoClient

  client = KaleidoClient.create(
      base_url="https://api.signet.kaleidoswap.com"
  )

  client.maker.enable_websocket("wss://api.signet.kaleidoswap.com/ws/my-client-id")

  stop = await client.maker.stream_quotes_by_ticker(
      "BTC",
      "USDT",
      100000,
      lambda quote: print(quote.price),
      poll_interval=2.0,
  )

  stop()
  ```
</CodeGroup>

## RLN Operations

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { KaleidoClient } from 'kaleido-sdk';

  const client = KaleidoClient.create({
    nodeUrl: 'http://localhost:3001',
  });

  if (client.hasNode()) {
    const nodeInfo = await client.rln.getNodeInfo();
    const balance = await client.rln.getBtcBalance();

    console.log(nodeInfo.pubkey);
    console.log(balance);
  }
  ```

  ```python Python theme={null}
  from kaleido_sdk import KaleidoClient

  client = KaleidoClient.create(
      node_url="http://localhost:3001"
  )

  if client.has_node():
      node_info = await client.rln.get_node_info()
      balance = await client.rln.get_btc_balance()

      print(node_info.pubkey)
      print(balance)
  ```
</CodeGroup>

## Utilities

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { toSmallestUnits, toDisplayUnits, getSdkName, getVersion } from 'kaleido-sdk';

  console.log(toSmallestUnits(0.001, 8)); // 100000
  console.log(toDisplayUnits(100000, 8)); // 0.001
  console.log(getSdkName());              // "kaleido-sdk"
  console.log(getVersion());              // "0.1.5"
  ```

  ```python Python theme={null}
  from kaleido_sdk import to_smallest_units, to_display_units, get_sdk_name, get_version

  print(to_smallest_units(0.001, 8))  # 100000
  print(to_display_units(100000, 8))  # 0.001
  print(get_sdk_name())               # "kaleido-sdk"
  print(get_version())                # "0.1.5"
  ```
</CodeGroup>