WebSocket 实时报价推送

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

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

const unsubscribe = await client.maker.streamQuotesByTicker(
  'BTC',           // fromTicker
  'USDT',          // toTicker
  100000,          // amount
  (quote) => {     // 回调
    console.log(`Price: ${quote.price}, RFQ: ${quote.rfq_id}`);
  },
  {                // options（可选）
    preferredFromLayer: 'BTC_LN',
    preferredToLayer: 'RGB_LN',
    pollInterval: 3000
  }
);

// 完成后停止推送
unsubscribe();

from kaleido_sdk import Layer

unsubscribe = await client.maker.stream_quotes_by_ticker(
    from_ticker="BTC",
    to_ticker="USDT",
    amount=100000,
    on_update=lambda quote: print(f"Price: {quote['price']}, RFQ: {quote['rfq_id']}"),
    preferred_from_layer=Layer.BTC_LN,
    preferred_to_layer=Layer.RGB_LN,
    poll_interval=3.0,
)

# 完成后停止推送
unsubscribe()

const unsubscribe = await client.maker.streamQuotes(
  'BTC',           // from_asset 代码
  'USDT',          // to_asset 代码
  100000,          // from_amount（或 null）
  'BTC_LN',        // from_layer（或 null）
  'RGB_LN',        // to_layer（或 null）
  (quote) => {
    console.log(`${quote.from_asset.amount} -> ${quote.to_asset.amount}`);
  }
);

unsubscribe = await client.maker.stream_quotes(
    from_asset="BTC",
    to_asset="USDT",
    from_amount=100000,
    from_layer=Layer.BTC_LN,
    to_layer=Layer.RGB_LN,
    on_update=lambda quote: print(f"{quote['from_asset']['amount']} -> {quote['to_asset']['amount']}")
)

const unsubscribers = await client.maker.streamQuotesForAllRoutes(
  'BTC', 'USDT', 100000,
  (route, quote) => {
    console.log(`Route ${route}: price=${quote.price}`);
  }
);
// 返回：Map<string, () => void>
// 调用其中任一取消函数即可停止，或遍历后全部调用

unsubscribers = await client.maker.stream_quotes_for_all_routes(
    from_ticker="BTC",
    to_ticker="USDT",
    amount=100000,
    on_update=lambda route, quote: print(f"Route {route}: price={quote['price']}")
)
# 返回：dict[str, Callable]

const routes = await client.maker.getAvailableRoutes('BTC', 'USDT');
// 返回：Array<{ from_layer: string; to_layer: string }>
for (const route of routes) {
  console.log(`${route.from_layer} -> ${route.to_layer}`);
}

routes = await client.maker.get_available_routes("BTC", "USDT")
for route in routes:
    print(f"{route['from_layer']} -> {route['to_layer']}")

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

await ws.connect();
console.log(`Connected: ${ws.isConnected()}`);

// 完成后
ws.disconnect();

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

await ws.connect()
print(f"Connected: {ws.is_connected()}")

# 完成后
ws.disconnect()

ws.on('connected', () => console.log('Connected'));
ws.on('disconnected', () => console.log('Disconnected'));
ws.on('reconnecting', (attempt) => console.log(`Reconnecting: attempt ${attempt}`));
ws.on('quoteResponse', (quote) => console.log(`Quote: ${quote.price}`));
ws.on('error', (error) => console.error(`Error: ${error.message}`));
ws.on('maxReconnectExceeded', () => console.log('Max reconnects exceeded'));

// 取消订阅
const handler = (quote) => { /* ... */ };
ws.on('quoteResponse', handler);
ws.off('quoteResponse', handler);

ws.on("connected", lambda: print("Connected"))
ws.on("disconnected", lambda: print("Disconnected"))
ws.on("reconnecting", lambda attempt: print(f"Reconnecting: attempt {attempt}"))
ws.on("quote_response", lambda quote: print(f"Quote: {quote['price']}"))
ws.on("error", lambda err: print(f"Error: {err}"))
ws.on("max_reconnect_exceeded", lambda: print("Max reconnects exceeded"))

# 取消订阅
handler = lambda quote: ...
ws.on("quote_response", handler)
ws.off("quote_response", handler)

ws.requestQuote({
  from_asset: 'BTC',
  to_asset: 'USDT',
  from_amount: 100000,
  from_layer: 'BTC_LN',
  to_layer: 'RGB_LN'
});

ws.request_quote({
    "from_asset": "BTC",
    "to_asset": "USDT",
    "from_amount": 100000,
    "from_layer": "BTC_LN",
    "to_layer": "RGB_LN"
})

ws.ping();

ws.ping()