Examples

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}`);
}

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}")

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}`);

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}")

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);

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)

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);

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)

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);

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()

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);
}

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)

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"

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"