KaleidoSDK 最佳实践

// lib/kaleido.ts
import { KaleidoClient } from 'kaleido-sdk';

let client: KaleidoClient | null = null;

export function getClient(): KaleidoClient {
  if (!client) {
    client = KaleidoClient.create({
      baseUrl: process.env.KALEIDO_API_URL!,
    });
  }
  return client;
}

# lib/kaleido.py
import os

from kaleido_sdk import KaleidoClient

_client = None

def get_client() -> KaleidoClient:
    global _client
    if _client is None:
        _client = KaleidoClient.create(
            base_url=os.environ["KALEIDO_API_URL"]
        )
    return _client

import { KaleidoError, NetworkError, QuoteExpiredError } from 'kaleido-sdk';

try {
  const quote = await client.maker.getQuote({ /* ... */ });
} catch (error) {
  if (error instanceof QuoteExpiredError) {
    // 用新报价重试
  } else if (error instanceof NetworkError && error.isRetryable()) {
    // 延迟一段时间后重试
  } else if (error instanceof KaleidoError) {
    // 记录日志并优雅处理
    console.error(`[${error.code}] ${error.message}`);
  }
}

from kaleido_sdk import KaleidoError, NetworkError, QuoteExpiredError, PairQuoteRequest

try:
    quote = await client.maker.get_quote(PairQuoteRequest(...))
except QuoteExpiredError:
    # 用新报价重试
    pass
except NetworkError as e:
    if e.is_retryable():
        # 延迟一段时间后重试
        pass
except KaleidoError as e:
    print(f"[{e.code}] {e}")

// 校验金额是否在该层的交易限额之内
const pairs = await client.maker.listPairs();
const pair = pairs.pairs.find(p =>
  p.base.ticker === 'BTC' && p.quote.ticker === 'USDT'
);

const limits = pair?.base.endpoints?.find(e => e.layer === 'BTC_LN');
if (limits && (amount < limits.min_amount || amount > limits.max_amount)) {
  throw new Error(`Amount must be between ${limits.min_amount} and ${limits.max_amount}`);
}

pairs = await client.maker.list_pairs()
pair = next(
    (p for p in pairs.pairs
     if p.base.ticker == "BTC" and p.quote.ticker == "USDT"),
    None
)

limits = next(
    (e for e in (pair.base.endpoints or []) if e.layer == "BTC_LN"),
    None,
) if pair else None

if limits and not (limits.min_amount <= amount <= limits.max_amount):
    raise ValueError(
        f"Amount must be between {limits.min_amount} and {limits.max_amount}"
    )

import type { TradingPairsResponse } from 'kaleido-sdk';

let cachedPairs: TradingPairsResponse | null = null;
let cacheTime = 0;

async function getPairs() {
  const now = Date.now();
  if (!cachedPairs || now - cacheTime > 60000) {  // 缓存 60 秒
    cachedPairs = await client.maker.listPairs();
    cacheTime = now;
  }
  return cachedPairs;
}

import time

_cached_pairs = None
_cache_time = 0

async def get_pairs():
    global _cached_pairs, _cache_time
    now = time.time()
    if _cached_pairs is None or now - _cache_time > 60:
        _cached_pairs = await client.maker.list_pairs()
        _cache_time = now
    return _cached_pairs