@runesx/api-client 0.3.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runesx/api-client",
-  "version": "0.3.0",
+  "version": "0.5.1",
   "description": "A Node.js client for interacting with the RunesX platform API and WebSocket",
   "main": "src/index.mjs",
   "type": "module",
@@ -13,23 +13,23 @@
     "test": "jest"
   },
   "dependencies": {
-    "axios": "^1.13.5",
-    "bignumber.js": "^9.1.2",
+    "axios": "^1.13.6",
+    "bignumber.js": "^10.0.2",
     "socket.io-client": "^4.8.3"
   },
   "devDependencies": {
     "@eslint/js": "^9.11.1",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/npm": "^13.1.4",
+    "@semantic-release/npm": "^13.1.5",
     "dotenv": "^17.3.1",
     "eslint": "^9.11.1",
     "eslint-plugin-import": "^2.30.0",
     "eslint-plugin-n": "^17.24.0",
     "eslint-plugin-promise": "^7.1.0",
-    "globals": "^17.3.0",
-    "jest": "^30.2.0",
-    "nodemon": "^3.1.11",
+    "globals": "^17.4.0",
+    "jest": "^30.3.0",
+    "nodemon": "^3.1.14",
     "semantic-release": "^25.0.3"
   },
   "files": [

package/src/api.mjs

@@ -12,6 +12,154 @@ export function createApi(config) {
     },
   });
 
+  // ---- Public endpoints (no auth required) ----
+
+  async function getStatus() {
+    try {
+      const response = await api.get('/status');
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch status');
+    }
+  }
+
+  async function getCoins() {
+    try {
+      const response = await api.get('/coins');
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch coins');
+    }
+  }
+
+  async function getCoin(ticker) {
+    try {
+      const response = await api.get(`/coins/${encodeURIComponent(ticker)}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch coin');
+    }
+  }
+
+  async function getPools() {
+    try {
+      const response = await api.get('/pools');
+      return response.data.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch pools');
+    }
+  }
+
+  async function getPoolByPair(tickerA, tickerB) {
+    try {
+      const response = await api.get(`/pools/${encodeURIComponent(tickerA)}/${encodeURIComponent(tickerB)}`);
+      return response.data.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch pool');
+    }
+  }
+
+  async function getPoolLiquidityShares(poolId) {
+    try {
+      const response = await api.get(`/pools/liquidity-shares/${encodeURIComponent(poolId)}`);
+      return response.data.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch pool liquidity shares');
+    }
+  }
+
+  async function getPrices() {
+    try {
+      const response = await api.get('/price');
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch prices');
+    }
+  }
+
+  async function getPrice(ticker) {
+    try {
+      const response = await api.get(`/price/${encodeURIComponent(ticker)}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch price');
+    }
+  }
+
+  async function getCandlesticks(poolId, timeframe, from, to) {
+    try {
+      const response = await api.get(`/candlesticks/${encodeURIComponent(poolId)}/${encodeURIComponent(timeframe)}/${encodeURIComponent(from)}/${encodeURIComponent(to)}`);
+      return response.data.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch candlesticks');
+    }
+  }
+
+  async function getVolumeTotal() {
+    try {
+      const response = await api.get('/volume/total');
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch total volume');
+    }
+  }
+
+  async function getVolumePool(poolId) {
+    try {
+      const response = await api.get(`/volume/pool/${encodeURIComponent(poolId)}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch pool volume');
+    }
+  }
+
+  async function getBucketsPools() {
+    try {
+      const response = await api.get('/buckets/pools');
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch pool buckets');
+    }
+  }
+
+  async function getRecentOperations({ operationType, limit } = {}) {
+    try {
+      const params = {};
+      if (operationType) { params.operationType = operationType; }
+      if (limit) { params.limit = limit; }
+      const response = await api.get('/operations/recent', { params });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch recent operations');
+    }
+  }
+
+  async function getPoolOperations(poolId, { operationType, limit } = {}) {
+    try {
+      const params = {};
+      if (operationType) { params.operationType = operationType; }
+      if (limit) { params.limit = limit; }
+      const response = await api.get(`/operations/pool/${encodeURIComponent(poolId)}`, { params });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch pool operations');
+    }
+  }
+
+  async function getYardMessages({ before, limit } = {}) {
+    try {
+      const params = {};
+      if (before) { params.before = before; }
+      if (limit) { params.limit = limit; }
+      const response = await api.get('/yard/messages', { params });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch yard messages');
+    }
+  }
+
+  // ---- Private endpoints (auth required) ----
+
   async function getWallets() {
     try {
       const response = await api.get('/wallets');
@@ -21,6 +169,15 @@ export function createApi(config) {
     }
   }
 
+  async function getLiquidityShares() {
+    try {
+      const response = await api.get('/liquidity/shares');
+      return response.data.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch liquidity shares');
+    }
+  }
+
   async function postSwap({ amountIn, path, minAmountOut, idempotencyKey }) {
     try {
       const key = idempotencyKey || randomUUID();
@@ -66,14 +223,240 @@ export function createApi(config) {
     }
   }
 
-  async function getPools() {
+  async function getDepositAddress(chainName) {
     try {
-      const response = await api.get('/pools');
+      const response = await api.get(`/deposit/address/${encodeURIComponent(chainName)}`);
       return response.data.data;
     } catch (error) {
-      throw new Error(error.response?.data?.error || 'Failed to fetch pools');
+      throw new Error(error.response?.data?.error || 'Failed to get deposit address');
+    }
+  }
+
+  async function getAllDepositAddresses() {
+    try {
+      const response = await api.get('/deposit/all-addresses');
+      return response.data.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to get deposit addresses');
+    }
+  }
+
+  async function initiateWithdraw({ ticker, chain, address, amount, memo, idempotencyKey }) {
+    try {
+      const key = idempotencyKey || randomUUID();
+      const body = { ticker, chain, address, amount };
+      if (memo !== undefined && memo !== null) {
+        body.memo = memo;
+      }
+      const response = await api.post('/withdraw', body, {
+        headers: { 'x-idempotency-key': key },
+      });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to initiate withdrawal');
+    }
+  }
+
+  async function verifyWithdrawPin({ pendingWithdrawalId, pinCode }) {
+    try {
+      const response = await api.post('/withdraw/verify-pin', { pendingWithdrawalId, pinCode });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to verify withdrawal PIN');
+    }
+  }
+
+  async function sendWithdrawEmailPin({ pendingWithdrawalId }) {
+    try {
+      const response = await api.post('/withdraw/send-email-pin', { pendingWithdrawalId });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to send withdrawal email PIN');
+    }
+  }
+
+  async function verifyWithdrawEmailPin({ pendingWithdrawalId, emailPinCode }) {
+    try {
+      const response = await api.post('/withdraw/verify-email-pin', { pendingWithdrawalId, emailPinCode });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to verify withdrawal email PIN');
+    }
+  }
+
+  async function verifyWithdraw2FA({ pendingWithdrawalId, twoFactorToken }) {
+    try {
+      const response = await api.post('/withdraw/verify-2fa', { pendingWithdrawalId, twoFactorToken });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to verify withdrawal 2FA');
+    }
+  }
+
+  async function getPendingWithdrawals() {
+    try {
+      const response = await api.get('/withdraw/pending');
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch pending withdrawals');
+    }
+  }
+
+  async function cancelWithdrawal({ pendingWithdrawalId }) {
+    try {
+      const response = await api.post('/withdraw/cancel', { pendingWithdrawalId });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to cancel withdrawal');
+    }
+  }
+
+  async function getTransactionHistory({ page, limit, type, status } = {}) {
+    try {
+      const params = {};
+      if (page) { params.page = page; }
+      if (limit) { params.limit = limit; }
+      if (type) { params.type = type; }
+      if (status) { params.status = status; }
+      const response = await api.get('/transactions/history', { params });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch transaction history');
+    }
+  }
+
+  async function getUserOperations({ operationType, poolId, startTime, endTime, page, limit } = {}) {
+    try {
+      const params = {};
+      if (operationType) { params.operationType = operationType; }
+      if (poolId) { params.poolId = poolId; }
+      if (startTime) { params.startTime = startTime; }
+      if (endTime) { params.endTime = endTime; }
+      if (page) { params.page = page; }
+      if (limit) { params.limit = limit; }
+      const response = await api.get('/operations/user', { params });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch user operations');
+    }
+  }
+
+  // ---- Orders endpoints ----
+
+  async function placeOrder({ pair, side, price, quantity, timeInForce, inverted, idempotencyKey }) {
+    try {
+      const key = idempotencyKey || randomUUID();
+      const body = { pair, side, price, quantity, timeInForce };
+      if (inverted !== undefined && inverted !== null) {
+        body.inverted = inverted;
+      }
+      const response = await api.post('/orders', body, {
+        headers: { 'x-idempotency-key': key },
+      });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to place order');
+    }
+  }
+
+  async function cancelOrder(orderId, { idempotencyKey } = {}) {
+    try {
+      const headers = {};
+      if (idempotencyKey) {
+        headers['x-idempotency-key'] = idempotencyKey;
+      }
+      const response = await api.delete(`/orders/${encodeURIComponent(orderId)}`, { headers });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to cancel order');
+    }
+  }
+
+  async function getOrders({ pair, status, limit, offset } = {}) {
+    try {
+      const params = {};
+      if (pair) { params.pair = pair; }
+      if (status) { params.status = status; }
+      if (limit) { params.limit = limit; }
+      if (offset !== undefined && offset !== null) { params.offset = offset; }
+      const response = await api.get('/orders', { params });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch orders');
+    }
+  }
+
+  async function getOrderBookApi(pair, { levels } = {}) {
+    try {
+      const params = {};
+      if (levels) { params.levels = levels; }
+      const response = await api.get(`/orders/book/${encodeURIComponent(pair)}`, { params });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch order book');
+    }
+  }
+
+  async function getTrades(pair, { limit } = {}) {
+    try {
+      const params = {};
+      if (limit) { params.limit = limit; }
+      const response = await api.get(`/orders/trades/${encodeURIComponent(pair)}`, { params });
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to fetch trades');
+    }
+  }
+
+  async function deleteYardMessage(messageId) {
+    try {
+      const response = await api.delete(`/yard/messages/${encodeURIComponent(messageId)}`);
+      return response.data;
+    } catch (error) {
+      throw new Error(error.response?.data?.error || 'Failed to delete yard message');
     }
   }
 
-  return { getWallets, getPools, postSwap, depositLiquidity, withdrawLiquidity };
+  return {
+    // Public
+    getStatus,
+    getCoins,
+    getCoin,
+    getPools,
+    getPoolByPair,
+    getPoolLiquidityShares,
+    getPrices,
+    getPrice,
+    getCandlesticks,
+    getVolumeTotal,
+    getVolumePool,
+    getBucketsPools,
+    getRecentOperations,
+    getPoolOperations,
+    getYardMessages,
+    // Private
+    getWallets,
+    getLiquidityShares,
+    postSwap,
+    depositLiquidity,
+    withdrawLiquidity,
+    getDepositAddress,
+    getAllDepositAddresses,
+    initiateWithdraw,
+    verifyWithdrawPin,
+    sendWithdrawEmailPin,
+    verifyWithdrawEmailPin,
+    verifyWithdraw2FA,
+    getPendingWithdrawals,
+    cancelWithdrawal,
+    getTransactionHistory,
+    getUserOperations,
+    deleteYardMessage,
+    // Orders
+    placeOrder,
+    cancelOrder,
+    getOrders,
+    getOrderBookApi,
+    getTrades,
+  };
 }

package/src/index.mjs

@@ -7,6 +7,9 @@ import { getCoins, getCoinByTicker } from './store/coinStore.mjs';
 import { getChains, getChainByName } from './store/chainStore.mjs';
 import { getWallets as getWalletsStore, getWalletByTicker } from './store/walletStore.mjs';
 import { getUserShares, getUserShareByPoolId } from './store/userSharesStore.mjs';
+import { getAllOrderBooks, getOrderBook, getOrderBookPairs, getUserOrders } from './store/orderbookStore.mjs';
+import { getMarkets, getMarketByCoinKey, getMarketByCoins } from './store/marketStore.mjs';
+import { getClobFees } from './store/exchangeConfigStore.mjs';
 import { waitForStores } from './waitForStores.mjs';
 import { estimateLiquidityFrontend, checkRunesLiquidityFrontend, calculateShareAmounts, estimateDepositShares } from './utils/liquidityUtils.mjs';
 import { estimateSwap } from './utils/swapUtils.mjs';
@@ -14,7 +17,7 @@ import { createPriceUtils } from './utils/priceUtils.mjs';
 
 export function createRunesXClient(options = {}) {
   const config = createConfig(options);
-  let socket = null;
+  let socketHandler = null;
   let initialized = false;
   const api = createApi(config);
 
@@ -22,10 +25,10 @@ export function createRunesXClient(options = {}) {
     if (!config.apiKey) {
       throw new Error('API_KEY is required');
     }
-    socket = setupSocket(config).socket;
-    const { pools, coins, chains, wallets, userShares } = await waitForStores(socket);
+    socketHandler = setupSocket(config);
+    const { pools, coins, chains, wallets, userShares, orderbooks } = await waitForStores(socketHandler.socket);
     initialized = true;
-    return { pools, coins, chains, wallets, userShares };
+    return { pools, coins, chains, wallets, userShares, orderbooks };
   }
 
   function ensureInitialized() {
@@ -36,10 +39,14 @@ export function createRunesXClient(options = {}) {
 
   return {
     initialize,
+
+    // Raw socket access
     getSocket: () => {
       ensureInitialized();
-      return socket;
+      return socketHandler.socket;
     },
+
+    // ---- Store accessors (real-time data from WebSocket) ----
     getPools,
     getPool,
     getCoins,
@@ -50,20 +57,120 @@ export function createRunesXClient(options = {}) {
     getWalletByTicker,
     getUserShares,
     getUserShareByPoolId,
+    getAllOrderBooks,
+    getOrderBook,
+    getOrderBookPairs,
+    getUserOrders,
+    getMarkets,
+    getMarketByCoins,
+
+    // ---- Event callbacks ----
+    on: (event, callback) => {
+      ensureInitialized();
+      socketHandler.on(event, callback);
+    },
+    off: (event, callback) => {
+      ensureInitialized();
+      socketHandler.off(event, callback);
+    },
+
+    // ---- Socket emit convenience methods ----
+    joinCandlesticks: (poolId, timeframe) => {
+      ensureInitialized();
+      socketHandler.joinCandlesticks(poolId, timeframe);
+    },
+    leaveCandlesticks: (poolId, timeframe) => {
+      ensureInitialized();
+      socketHandler.leaveCandlesticks(poolId, timeframe);
+    },
+    sendYardMessage: (text) => {
+      ensureInitialized();
+      socketHandler.sendYardMessage(text);
+    },
+    deleteMessage: (messageId) => {
+      ensureInitialized();
+      socketHandler.deleteMessage(messageId);
+    },
+    markYardRead: () => {
+      ensureInitialized();
+      socketHandler.markYardRead();
+    },
+
+    // ---- Trading API (auth required, scope: swap) ----
     postSwap: api.postSwap,
+
+    // ---- Liquidity API (auth required, scope: liquidity_deposit/liquidity_withdraw) ----
     depositLiquidity: api.depositLiquidity,
     withdrawLiquidity: api.withdrawLiquidity,
+    getLiquidityShares: api.getLiquidityShares,
+
+    // ---- Wallet API (auth required, scope: read) ----
     getWalletsApi: api.getWallets,
+
+    // ---- Deposit API (auth required) ----
+    getDepositAddress: api.getDepositAddress,
+    getAllDepositAddresses: api.getAllDepositAddresses,
+
+    // ---- Withdrawal API (auth required, scope: wallet_withdraw) ----
+    initiateWithdraw: api.initiateWithdraw,
+    verifyWithdrawPin: api.verifyWithdrawPin,
+    sendWithdrawEmailPin: api.sendWithdrawEmailPin,
+    verifyWithdrawEmailPin: api.verifyWithdrawEmailPin,
+    verifyWithdraw2FA: api.verifyWithdraw2FA,
+    getPendingWithdrawals: api.getPendingWithdrawals,
+    cancelWithdrawal: api.cancelWithdrawal,
+
+    // ---- Transaction history (auth required, scope: read) ----
+    getTransactionHistory: api.getTransactionHistory,
+
+    // ---- Operations API (public + auth) ----
+    getRecentOperations: api.getRecentOperations,
+    getUserOperations: api.getUserOperations,
+    getPoolOperations: api.getPoolOperations,
+
+    // ---- Public market data API ----
+    getStatus: api.getStatus,
+    getCoinsApi: api.getCoins,
+    getCoinApi: api.getCoin,
+    getPoolsApi: api.getPools,
+    getPoolByPair: api.getPoolByPair,
+    getPoolLiquidityShares: api.getPoolLiquidityShares,
+    getPrices: api.getPrices,
+    getPrice: api.getPrice,
+    getCandlesticks: api.getCandlesticks,
+    getVolumeTotal: api.getVolumeTotal,
+    getVolumePool: api.getVolumePool,
+    getBucketsPools: api.getBucketsPools,
+
+    // ---- Orders API (auth required for place/cancel/getOrders, public for book/trades) ----
+    placeOrder: api.placeOrder,
+    cancelOrder: api.cancelOrder,
+    getOrders: api.getOrders,
+    getOrderBookApi: api.getOrderBookApi,
+    getTrades: api.getTrades,
+
+    // ---- Yard (chat) API ----
+    getYardMessages: api.getYardMessages,
+    deleteYardMessage: api.deleteYardMessage,
+
+    // ---- Client-side estimation utilities ----
     estimateSwap: (inputCoin, outputCoin, amountIn, maxHops = 6, algorithm = 'dfs') =>
-      estimateSwap(inputCoin, outputCoin, amountIn, getPools(), getCoins(), maxHops, algorithm),
+      estimateSwap(inputCoin, outputCoin, amountIn, getPools(), getCoins(), maxHops, algorithm, getAllOrderBooks(), getUserOrders(), getClobFees(), getMarketByCoinKey()),
     estimateLiquidityFrontend,
     estimateDepositShares: ({ pool, amountA, amountB, slippagePercent } = {}) =>
       estimateDepositShares({ pool, amountA, amountB, slippagePercent }),
     checkRunesLiquidityFrontend: (coinA, coinB) =>
       checkRunesLiquidityFrontend(coinA, coinB, getPools(), getCoins()),
     calculateShareAmounts: () => calculateShareAmounts({ userShares: getUserShares(), pools: getPools() }),
+
+    // ---- Price utilities ----
+    utils: {
+      ...createPriceUtils(),
+    },
+
+    // ---- Pool monitoring ----
     monitorPool: (poolId, interval = 10000) => {
-      setInterval(() => {
+      return setInterval(() => {
         const pool = getPool(poolId);
         if (pool) {
           console.log(`Monitoring pool ${poolId} (${pool.coinA.ticker}/${pool.coinB.ticker}):`, {
@@ -77,12 +184,11 @@ export function createRunesXClient(options = {}) {
         }
       }, interval);
     },
-    utils: {
-      ...createPriceUtils(),
-    },
+
+    // ---- Disconnect ----
     disconnect: () => {
-      if (socket) {
-        socket.disconnect();
+      if (socketHandler) {
+        socketHandler.socket.disconnect();
       }
     },
   };