dexbot 1.4.12 → 1.4.13

package/claw/modules/feed_price_source.ts

@@ -0,0 +1,134 @@
+/**
+ * Feed Price Source
+ *
+ * Fetches the on-chain settlement feed price for an MPA and provides it
+ * in a form the trend analyzer can consume.
+ *
+ * Also fetches a market price (mid-price from order book) to pair with
+ * the feed for a complete trend analyzer update.
+ */
+
+
+import { getAsset, getBackingAsset, getBitassetData, dbCall } from './chain_queries.js';
+import { loadDexbotOrderUtils } from './dexbot_bridge.js';
+import { roundTo } from '../../modules/utils/math_utils.js';
+'use strict';
+
+
+function getBlockchainToFloat() {
+  return loadDexbotOrderUtils().blockchainToFloat;
+}
+
+/**
+ * Extract BTS-per-MPA from the settlement price object.
+ * Replicates the logic in position_manager (computeBtsPerMpaFromSettlement)
+ * but as a standalone utility.
+ */
+function parseBtsPerMpa(settlementPrice: any, mpaAsset: any, backingAsset: any) {
+  const base = settlementPrice?.base;
+  const quote = settlementPrice?.quote;
+  if (!base || !quote) return null;
+
+  const blockchainToFloat = getBlockchainToFloat();
+  const baseAmount = blockchainToFloat(
+    base.amount,
+    base.asset_id === mpaAsset.id ? mpaAsset.precision : backingAsset.precision
+  );
+  const quoteAmount = blockchainToFloat(
+    quote.amount,
+    quote.asset_id === mpaAsset.id ? mpaAsset.precision : backingAsset.precision
+  );
+  if (!baseAmount || !quoteAmount) return null;
+
+  // BTS per MPA
+  if (base.asset_id === backingAsset.id && quote.asset_id === mpaAsset.id) {
+    return baseAmount / quoteAmount;
+  }
+  if (base.asset_id === mpaAsset.id && quote.asset_id === backingAsset.id) {
+    return quoteAmount / baseAmount;
+  }
+  return null;
+}
+
+/**
+ * Fetch the current feed price for an MPA.
+ *
+ * @param {string} mpaSymbol – e.g. 'HONEST.USD'
+ * @returns {Object} { feedPrice, mpaSymbol, mpaAssetId, backingSymbol, publicationTime }
+ *   feedPrice is in BTS-per-MPA units.
+ */
+async function fetchFeedPrice(mpaSymbol: string) {
+  const mpaAsset = await getAsset(mpaSymbol);
+  if (!mpaAsset) throw new Error(`Asset not found: ${mpaSymbol}`);
+
+  const backingAsset = await getBackingAsset(mpaSymbol);
+  if (!backingAsset) throw new Error(`Backing asset not found for: ${mpaSymbol}`);
+
+  const bitassetData = await getBitassetData(mpaSymbol);
+  if (!bitassetData) throw new Error(`Not an MPA: ${mpaSymbol}`);
+
+  const settlement = bitassetData?.current_feed?.settlement_price;
+  const feedPrice = parseBtsPerMpa(settlement, mpaAsset, backingAsset);
+
+  return {
+    feedPrice,
+    mpaSymbol: mpaAsset.symbol,
+    mpaAssetId: mpaAsset.id,
+    backingSymbol: backingAsset.symbol,
+    publicationTime: bitassetData?.current_feed_publication_time || null,
+  };
+}
+
+/**
+ * Fetch the mid-price from the order book for a market pair.
+ *
+ * @param {string} baseSymbol  – e.g. 'BTS'
+ * @param {string} quoteSymbol – e.g. 'HONEST.USD'
+ * @param {number} [depth=1]   – Order book depth to fetch
+ * @returns {number|null} Mid-price (average of best bid and best ask) in base-per-quote,
+ *          or null if no orders exist.
+ */
+async function fetchMidPrice(baseSymbol: string, quoteSymbol: string, depth: number = 1) {
+  const baseAsset = await getAsset(baseSymbol);
+  const quoteAsset = await getAsset(quoteSymbol);
+  if (!baseAsset || !quoteAsset) return null;
+
+  const orderBook = await dbCall('get_order_book', [baseAsset.symbol, quoteAsset.symbol, depth]);
+  if (!orderBook) return null;
+
+  const bestBid = orderBook?.bids?.[0]?.price;
+  const bestAsk = orderBook?.asks?.[0]?.price;
+
+  if (!Number.isFinite(Number(bestBid)) || !Number.isFinite(Number(bestAsk))) return null;
+
+  return (Number(bestBid) + Number(bestAsk)) / 2;
+}
+
+/**
+ * Fetch both feed price and market mid-price for a trend analyzer update.
+ *
+ * @param {string} mpaSymbol – e.g. 'HONEST.USD'
+ * @returns {Object} { marketPrice, feedPrice, premium, mpaSymbol, publicationTime }
+ *   Both prices in BTS-per-MPA units.
+ *   premium = ((market - feed) / feed) * 100
+ */
+async function fetchTrendInput(mpaSymbol: string) {
+  const feedData = await fetchFeedPrice(mpaSymbol);
+  const marketPrice = await fetchMidPrice('BTS', mpaSymbol);
+
+  let premium: number | null = null;
+  if (marketPrice != null && feedData.feedPrice != null && Number.isFinite(marketPrice) && Number.isFinite(feedData.feedPrice) && feedData.feedPrice > 0) {
+    premium = ((marketPrice - feedData.feedPrice) / feedData.feedPrice) * 100;
+  }
+
+  return {
+    marketPrice,
+    feedPrice: feedData.feedPrice,
+    premium: premium !== null ? roundTo(premium, 10000) : null,
+    mpaSymbol: feedData.mpaSymbol,
+    publicationTime: feedData.publicationTime,
+  };
+}
+
+export { fetchFeedPrice, fetchMidPrice, fetchTrendInput, parseBtsPerMpa }
+

package/claw/modules/honest_ecosystem.ts

@@ -0,0 +1,337 @@
+
+
+import { getAsset, getBackingAsset, getBitassetData, getCallOrders, getObjects, listAssets } from './chain_queries.js';
+import { derivePoolPrice } from './liquidity_pools.js';
+import { clone } from './utils.js';
+const REFERENCE_SYMBOL = 'HONEST.MONEY';
+const CORE_SYMBOL = 'BTS';
+const DEFAULT_PREFIX = 'HONEST.';
+// Fallback HONEST.MONEY/BTS pool values used when the live LP pool query fails.
+// Last verified: pool 1.19.305 — refresh by running `npm run report:honest-assets` on a live node.
+const HARDCODED_POOL_ID = '1.19.305';
+const HARDCODED_HONEST_MONEY_BTS_POOL = {
+  assetA: {
+    amount: 29854.8782,
+    symbol: CORE_SYMBOL
+  },
+  assetB: {
+    amount: 70846.22383703,
+    symbol: REFERENCE_SYMBOL
+  },
+  id: HARDCODED_POOL_ID,
+  poolSymbol: 'honest.BTSMONEY',
+  takerFeePercent: 0.4,
+  withdrawalFeePercent: 0
+};
+
+
+function isMpa(asset: any) {
+  return Boolean(asset && asset.bitasset_data_id);
+}
+
+function isHonestAsset(asset: any) {
+  return typeof asset?.symbol === 'string' && asset.symbol.startsWith(DEFAULT_PREFIX);
+}
+
+async function fetchLivePoolReserves(poolId: string = HARDCODED_POOL_ID) {
+  try {
+    const objects = await getObjects([poolId]);
+    const pool = objects && objects[0];
+    if (!pool || pool.asset_a == null || pool.asset_b == null) return null;
+
+    const [assetAObj, assetBObj] = await Promise.all([
+      getAsset(pool.asset_a),
+      getAsset(pool.asset_b)
+    ]);
+
+    const precisionA = assetAObj?.precision ?? 0;
+    const precisionB = assetBObj?.precision ?? 0;
+    const balanceA = Number(pool.balance_a) || 0;
+    const balanceB = Number(pool.balance_b) || 0;
+
+    return {
+      assetA: {
+        amount: precisionA > 0 ? balanceA / Math.pow(10, precisionA) : balanceA,
+        symbol: assetAObj?.symbol || CORE_SYMBOL
+      },
+      assetB: {
+        amount: precisionB > 0 ? balanceB / Math.pow(10, precisionB) : balanceB,
+        symbol: assetBObj?.symbol || REFERENCE_SYMBOL
+      },
+      id: poolId,
+      poolSymbol: pool.share_asset || HARDCODED_HONEST_MONEY_BTS_POOL.poolSymbol,
+      takerFeePercent: pool.taker_fee_percent ?? HARDCODED_HONEST_MONEY_BTS_POOL.takerFeePercent,
+      withdrawalFeePercent: pool.withdrawal_fee_percent ?? HARDCODED_HONEST_MONEY_BTS_POOL.withdrawalFeePercent,
+      source: 'live-liquidity-pool'
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function getHonestMoneyBridge() {
+  const live = await fetchLivePoolReserves();
+  if (live) {
+    const core = live.assetA.symbol === CORE_SYMBOL ? live.assetA : live.assetB;
+    const honestMoney = live.assetA.symbol === REFERENCE_SYMBOL ? live.assetA : live.assetB;
+    const latestHonestMoneyPerBts = Number(core.amount) > 0 ? honestMoney.amount / core.amount : null;
+    return {
+      liquidityPool: { ...live, reserves: [live.assetA, live.assetB] },
+      latestHonestMoneyPerBts,
+      market: `${REFERENCE_SYMBOL}/${CORE_SYMBOL}`,
+      source: live.source
+    };
+  }
+  return getHardcodedHonestMoneyBridge();
+}
+
+function getHardcodedHonestMoneyBridge() {
+  const core = HARDCODED_HONEST_MONEY_BTS_POOL.assetA;
+  const honestMoney = HARDCODED_HONEST_MONEY_BTS_POOL.assetB;
+  const latestHonestMoneyPerBts = Number(core.amount) > 0 ? honestMoney.amount / core.amount : null;
+
+  return {
+    liquidityPool: {
+      id: HARDCODED_HONEST_MONEY_BTS_POOL.id,
+      poolSymbol: HARDCODED_HONEST_MONEY_BTS_POOL.poolSymbol,
+      reserves: [
+        clone(HARDCODED_HONEST_MONEY_BTS_POOL.assetA),
+        clone(HARDCODED_HONEST_MONEY_BTS_POOL.assetB)
+      ],
+      source: 'hardcoded-liquidity-pool',
+      takerFeePercent: HARDCODED_HONEST_MONEY_BTS_POOL.takerFeePercent,
+      withdrawalFeePercent: HARDCODED_HONEST_MONEY_BTS_POOL.withdrawalFeePercent
+    },
+    latestHonestMoneyPerBts,
+    market: `${REFERENCE_SYMBOL}/${CORE_SYMBOL}`,
+    source: 'hardcoded-liquidity-pool'
+  };
+}
+
+function isHardcodedHonestMoneyBtsPair(assetA: any, assetB: any) {
+  const assetASymbol = assetA && typeof assetA === 'object' ? assetA.symbol : assetA;
+  const assetBSymbol = assetB && typeof assetB === 'object' ? assetB.symbol : assetB;
+
+  return (
+    (assetASymbol === REFERENCE_SYMBOL && assetBSymbol === CORE_SYMBOL) ||
+    (assetASymbol === CORE_SYMBOL && assetBSymbol === REFERENCE_SYMBOL)
+  );
+}
+
+async function resolveHardcodedHonestMoneyPrice(assetA: any, assetB: any) {
+  const assetASymbol = assetA && typeof assetA === 'object' ? assetA.symbol : assetA;
+  const assetBSymbol = assetB && typeof assetB === 'object' ? assetB.symbol : assetB;
+
+  const bridge = await getHonestMoneyBridge();
+  const bridgePrice = bridge.latestHonestMoneyPerBts;
+
+  if (bridgePrice === null || !Number.isFinite(bridgePrice) || bridgePrice <= 0) {
+    return null;
+  }
+
+  if (assetASymbol === REFERENCE_SYMBOL && assetBSymbol === CORE_SYMBOL) {
+    return bridgePrice;
+  }
+
+  if (assetASymbol === CORE_SYMBOL && assetBSymbol === REFERENCE_SYMBOL) {
+    return 1 / bridgePrice;
+  }
+
+  return null;
+}
+
+async function resolveHonestPairPrice(assetA: any, assetB: any, options: Record<string, any> = {}) {
+  const hardcoded = await resolveHardcodedHonestMoneyPrice(assetA, assetB);
+  if (hardcoded !== null) {
+    return hardcoded;
+  }
+
+  return derivePoolPrice(assetA, assetB, options);
+}
+
+async function resolveHonestPairContext(assetA: any, assetB: any, options: Record<string, any> = {}) {
+  const pairPrice = await resolveHonestPairPrice(assetA, assetB, options).catch(() => null);
+  const assetASymbol = assetA && typeof assetA === 'object' ? assetA.symbol : assetA;
+  const assetBSymbol = assetB && typeof assetB === 'object' ? assetB.symbol : assetB;
+
+  if (!isHardcodedHonestMoneyBtsPair(assetA, assetB)) {
+    return {
+      assetA: {
+        symbol: assetASymbol
+      },
+      assetB: {
+        symbol: assetBSymbol
+      },
+      priceBPerA: pairPrice,
+      source: pairPrice === null ? 'unresolved' : 'dexbot2-derivePoolPrice'
+    };
+  }
+
+  const bridge = await getHonestMoneyBridge();
+  const assetAEntry = bridge.liquidityPool.reserves.find((entry) => entry.symbol === assetASymbol) || null;
+  const assetBEntry = bridge.liquidityPool.reserves.find((entry) => entry.symbol === assetBSymbol) || null;
+
+  return {
+    assetA: {
+      id: assetASymbol === CORE_SYMBOL ? '1.3.0' : null,
+      precision: null,
+      symbol: assetASymbol
+    },
+    assetB: {
+      id: assetBSymbol === CORE_SYMBOL ? '1.3.0' : null,
+      precision: null,
+      symbol: assetBSymbol
+    },
+    pool: {
+      ...bridge.liquidityPool,
+      source: 'hardcoded-liquidity-pool'
+    },
+    priceBPerA: pairPrice,
+    reserveA: assetAEntry ? assetAEntry.amount : null,
+    reserveB: assetBEntry ? assetBEntry.amount : null,
+    source: 'hardcoded-liquidity-pool'
+  };
+}
+
+async function loadHonestAssets({ prefix = DEFAULT_PREFIX, batchSize = 100, maxPages = 100, startSymbol = DEFAULT_PREFIX }: Record<string, any> = {}) {
+  const all = [];
+  let lowerBound = startSymbol;
+  let previousLastSymbol = null;
+
+  for (let page = 0; page < maxPages; page += 1) {
+    const batch = await listAssets(lowerBound, batchSize);
+    if (!Array.isArray(batch) || batch.length === 0) {
+      break;
+    }
+
+    let pageItems = batch.filter(Boolean);
+    if (previousLastSymbol && pageItems[0]?.symbol === previousLastSymbol) {
+      pageItems = pageItems.slice(1);
+    }
+
+    if (pageItems.length === 0) {
+      break;
+    }
+
+    const matching = pageItems.filter((asset) => isHonestAsset(asset) && asset.symbol.startsWith(prefix));
+    all.push(...matching);
+
+    previousLastSymbol = pageItems[pageItems.length - 1].symbol;
+    lowerBound = previousLastSymbol;
+
+    if (batch.length < batchSize) {
+      break;
+    }
+  }
+
+  const mpas = [];
+  for (const asset of all) {
+    if (!isMpa(asset)) {
+      continue;
+    }
+
+    const backingAsset = await getBackingAsset(asset.id).catch(() => null);
+    const callOrders = await getCallOrders(asset.id, 20).catch(() => []);
+    const bitassetData = await getBitassetData(asset.id).catch(() => null);
+    mpas.push({
+      backingAsset: backingAsset ? {
+        id: backingAsset.id,
+        precision: backingAsset.precision,
+        symbol: backingAsset.symbol
+      } : null,
+      callOrdersCount: Array.isArray(callOrders) ? callOrders.length : 0,
+      currentFeedPublicationTime: bitassetData?.current_feed_publication_time || null,
+      id: asset.id,
+      precision: asset.precision,
+      symbol: asset.symbol
+    });
+  }
+
+  return {
+    assets: all,
+    mpas
+  };
+}
+
+async function buildHonestEcosystemContext(options: Record<string, any> = {}) {
+  const prefix = options.prefix || DEFAULT_PREFIX;
+  const [coreAsset, referenceAsset] = await Promise.all([
+    getAsset(CORE_SYMBOL),
+    getAsset(REFERENCE_SYMBOL)
+  ]);
+
+  if (!coreAsset || !referenceAsset) {
+    throw new Error(`Could not resolve ${CORE_SYMBOL} or ${REFERENCE_SYMBOL}`);
+  }
+
+  const honestAssets = await loadHonestAssets({
+    batchSize: options.batchSize,
+    maxPages: options.maxPages,
+    prefix,
+    startSymbol: options.startSymbol || prefix
+  });
+
+  const requestedPairs = Array.isArray(options.discoverPairs) ? options.discoverPairs : [];
+  const pairContexts = [];
+  for (const pair of requestedPairs) {
+    if (!Array.isArray(pair) || pair.length !== 2) {
+      continue;
+    }
+
+    const context = await resolveHonestPairContext(pair[0], pair[1], options).catch(() => null);
+    if (context) {
+      pairContexts.push(context);
+    }
+  }
+
+  return {
+    assets: honestAssets.assets.map((asset) => ({
+      id: asset.id,
+      precision: asset.precision,
+      symbol: asset.symbol,
+      type: isMpa(asset) ? 'MPA' : 'ASSET'
+    })),
+    bridge: await getHonestMoneyBridge(),
+    pairContexts,
+    mpas: honestAssets.mpas,
+    referenceAsset: {
+      id: referenceAsset.id,
+      precision: referenceAsset.precision,
+      symbol: referenceAsset.symbol
+    },
+    scope: {
+      prefix
+    },
+    summary: {
+      assetCount: honestAssets.assets.length,
+      pairContextCount: pairContexts.length,
+      mpaCount: honestAssets.mpas.length
+    }
+  };
+}
+
+function createHonestEcosystemAdapter(options: Record<string, any> = {}) {
+  return {
+    buildContext: (contextOptions = {}) => buildHonestEcosystemContext({
+      ...options,
+      ...contextOptions
+    }),
+    getHardcodedHonestMoneyBridge,
+    loadAssets: (assetOptions = {}) => loadHonestAssets({
+      ...options,
+      ...assetOptions
+    }),
+    resolvePairContext: (assetA: any, assetB: any, contextOptions = {}) => resolveHonestPairContext(assetA, assetB, {
+      ...options,
+      ...contextOptions
+    }),
+    resolvePairPrice: (assetA: any, assetB: any, priceOptions = {}) => resolveHonestPairPrice(assetA, assetB, {
+      ...options,
+      ...priceOptions
+    }),
+    resolveHardcodedHonestMoneyPrice
+  };
+}
+
+export { CORE_SYMBOL, DEFAULT_PREFIX, REFERENCE_SYMBOL, buildHonestEcosystemContext, createHonestEcosystemAdapter, getHardcodedHonestMoneyBridge, loadHonestAssets, isHardcodedHonestMoneyBtsPair, resolveHardcodedHonestMoneyPrice, resolveHonestPairContext, resolveHonestPairPrice }
+

package/claw/modules/kibana_price_source.ts

@@ -0,0 +1,133 @@
+/**
+ * Kibana Price Source
+ *
+ * Claw-facing module that provides historical price data from Kibana
+ * for trend analysis, backtesting, and market evaluation.
+ *
+ * Two data sources:
+ *   - Order book fills (fill_order, op_type 4) → MPA/BTS market candles
+ *   - LP pool swaps (liquidity_pool_exchange, op_type 63) → LP price candles
+ *
+ * This module resolves asset objects from chain and delegates to the
+ * market_adapter/core/ modules for the actual Kibana queries.
+ */
+
+
+import { getMarketCandles, getMarketClosePrices } from '../../market_adapter/core/kibana_market_candles.js';
+import { getLpCandlesForPool, getLpClosePricesForPool, discoverPoolAssets } from '../../market_adapter/inputs/kibana_source.js';
+import { getAsset } from './chain_queries.js';
+'use strict';
+
+
+/**
+ * Resolve a symbol or asset ID to a { id, precision, symbol } object.
+ */
+async function resolveAsset(symbolOrId: string) {
+  const asset = await getAsset(symbolOrId);
+  if (!asset) throw new Error(`Asset not found: ${symbolOrId}`);
+  return { id: asset.id, precision: asset.precision, symbol: asset.symbol };
+}
+
+// ─── Order Book Candles (fill_order) ─────────────────────────────────────────
+
+/**
+ * Fetch historical OHLCV candles from order book fills for an MPA/BTS market.
+ *
+ * @param {string} mpaSymbol – e.g. 'HONEST.USD'
+ * @param {Object} [config]
+ * @param {number} [config.intervalSeconds=3600]  – Candle size (1h default)
+ * @param {number} [config.lookbackHours=500]     – How far back
+ * @returns {Promise<Array>} OHLCV candles [[ts, o, h, l, c, vol], ...]
+ *   Price in BTS-per-MPA units.
+ */
+async function fetchMarketCandles(mpaSymbol: string, config: Record<string, any> = {}) {
+  const btsAsset = await resolveAsset('BTS');
+  const mpaAsset = await resolveAsset(mpaSymbol);
+  return getMarketCandles(btsAsset, mpaAsset, config);
+}
+
+/**
+ * Fetch close prices only from order book fills.
+ *
+ * @param {string} mpaSymbol – e.g. 'HONEST.USD'
+ * @param {Object} [config]
+ * @returns {Promise<number[]>} Array of close prices (BTS-per-MPA)
+ */
+async function fetchMarketClosePrices(mpaSymbol: string, config: Record<string, any> = {}) {
+  const btsAsset = await resolveAsset('BTS');
+  const mpaAsset = await resolveAsset(mpaSymbol);
+  return getMarketClosePrices(btsAsset, mpaAsset, config);
+}
+
+// ─── LP Pool Candles (liquidity_pool_exchange) ───────────────────────────────
+
+/**
+ * Fetch historical OHLCV candles from LP pool swaps.
+ *
+ * @param {string|number} poolId      – e.g. '1.19.305' or 305
+ * @param {string}        assetASymbol – e.g. 'BTS'
+ * @param {string}        assetBSymbol – e.g. 'HONEST.MONEY'
+ * @param {Object}        [config]
+ * @returns {Promise<Array>} OHLCV candles [[ts, o, h, l, c, vol], ...]
+ */
+async function fetchLpCandles(poolId: any, assetASymbol: string, assetBSymbol: string, config: Record<string, any> = {}) {
+  const assetA = await resolveAsset(assetASymbol);
+  const assetB = await resolveAsset(assetBSymbol);
+  return getLpCandlesForPool(poolId, assetA, assetB, config);
+}
+
+/**
+ * Fetch close prices only from LP pool swaps.
+ *
+ * @param {string|number} poolId      – e.g. '1.19.305' or 305
+ * @param {string}        assetASymbol – e.g. 'BTS'
+ * @param {string}        assetBSymbol – e.g. 'HONEST.MONEY'
+ * @param {Object}        [config]
+ * @returns {Promise<Object>} LP close prices
+ */
+async function fetchLpClosePrices(poolId: any, assetASymbol: string, assetBSymbol: string, config: Record<string, any> = {}) {
+  const assetA = await resolveAsset(assetASymbol);
+  const assetB = await resolveAsset(assetBSymbol);
+  return getLpClosePricesForPool(poolId, assetA, assetB, config);
+}
+
+/**
+ * Discover which asset pair a pool trades.
+ *
+ * @param {string|number} poolId
+ * @param {Object}        [config]
+ * @returns {Promise<string[]>} Array of asset IDs in the pool
+ */
+async function fetchPoolAssets(poolId: any, config: Record<string, any> = {}) {
+  return discoverPoolAssets(poolId, config);
+}
+
+// ─── Combined: Market + Feed for Trend Analysis ─────────────────────────────
+
+/**
+ * Fetch historical market candles and extract close prices for trend analysis.
+ *
+ * Returns candles with their close prices — suitable for
+ * initializing a TrendAnalyzer with historical context before switching
+ * to live feed_price_source updates.
+ *
+ * @param {string} mpaSymbol – e.g. 'HONEST.USD'
+ * @param {Object} [config]
+ * @returns {Promise<Object>} { candles, closePrices, candleCount, mpaSymbol, intervalSeconds, lookbackHours }
+ */
+async function fetchTrendHistoryCandles(mpaSymbol: string, config: Record<string, any> = {}) {
+  const candles: any = await fetchMarketCandles(mpaSymbol, config);
+  const closePrices = candles.map(([, , , , close]: [number, number, number, number, number]) => close);
+
+  return {
+    candles,
+    closePrices,
+    candleCount: candles.length,
+    mpaSymbol,
+    intervalSeconds: config.intervalSeconds || 3600,
+    lookbackHours: config.lookbackHours || 500,
+  };
+}
+
+export { fetchMarketCandles, fetchMarketClosePrices, fetchLpCandles, fetchLpClosePrices, fetchPoolAssets, fetchTrendHistoryCandles }
+