@runesx/api-client 0.0.2 → 0.0.4

package/README.md

@@ -44,4 +44,483 @@ async function main() {
 }
 
 main();
-```
+```
+
+2. Accessing Store Data
+Retrieve data from the internal stores for pools, coins, wallets, and user shares.
+
+### Get All Pools
+```javascript
+const pools = client.getPools();
+console.log('Available pools:', pools.map(pool => ({
+  id: pool.id,
+  pair: `${pool.coinA.ticker}/${pool.coinB.ticker}`,
+  reserveA: pool.reserveA,
+  reserveB: pool.reserveB,
+})));
+```
+
+### Get a Specific Pool
+```javascript
+const pool = client.getPool(1);
+console.log('Pool 1:', pool ? {
+  pair: `${pool.coinA.ticker}/${pool.coinB.ticker}`,
+  reserveA: pool.reserveA,
+  reserveB: pool.reserveB,
+} : 'Pool not found');
+```
+
+### Get All Coins
+```javascript
+const coins = client.getCoins();
+console.log('Available coins:', coins.map(coin => ({
+  ticker: coin.ticker,
+  projectName: coin.projectName,
+  status: coin.status,
+})));
+```
+
+### Get a Coin by Ticker
+```javascript
+const coin = client.getCoinByTicker('xRUNES');
+console.log('xRUNES coin:', coin ? {
+  ticker: coin.ticker,
+  dp: coin.dp,
+  projectName: coin.projectName,
+} : 'Coin not found');
+```
+
+### Get All Wallets
+```javascript
+const wallets = client.getWallets();
+console.log('Wallets:', wallets.map(wallet => ({
+  ticker: wallet.ticker,
+  available: wallet.available,
+  locked: wallet.locked,
+})));
+```
+
+### Get a Wallet by Ticker
+```javascript
+const wallet = client.getWalletByTicker('xRUNES');
+console.log('xRUNES wallet:', wallet ? {
+  ticker: wallet.ticker,
+  available: wallet.available,
+} : 'Wallet not found');
+```
+
+### Get All User Shares
+```javascript
+const userShares = client.getUserShares();
+console.log('User shares:', userShares.map(share => ({
+  poolId: share.poolId,
+  shares: share.shares,
+})));
+```
+
+### Get User Shares by Pool ID
+```javascript
+const share = client.getUserShareByPoolId(1);
+console.log('Shares for pool 1:', share ? {
+  poolId: share.poolId,
+  shares: share.shares,
+} : 'No shares found');
+```
+
+3. Estimating and Executing a Swap
+Estimate and execute a swap between two tokens, such as 0.1 xRUNES to XLM, with slippage tolerance.
+
+```javascript
+import { BigNumber } from 'bignumber.js';
+
+async function executeSwap() {
+  try {
+    const inputCoin = client.getCoinByTicker('xRUNES');
+    const outputCoin = client.getCoinByTicker('XLM');
+    if (!inputCoin || !outputCoin) {
+      throw new Error('Required coins not found');
+    }
+
+    const amountIn = '0.1'; // 0.1 xRUNES
+    const maxHops = 6;
+    const algorithm = 'dfs';
+    const slippageTolerance = '1'; // 1%
+
+    // Estimate swap
+    const swapEstimate = await client.estimateSwap(inputCoin, outputCoin, amountIn, maxHops, algorithm);
+    console.log('Swap estimate:', {
+      input: swapEstimate.input,
+      output: swapEstimate.output,
+      priceImpact: `${(swapEstimate.slippage.priceImpact * 100).toFixed(2)}%`,
+      path: swapEstimate.path,
+    });
+
+    // Calculate minimum output with slippage
+    const amountOutBN = new BigNumber(swapEstimate.output.amount);
+    const minAmountOut = amountOutBN
+      .times(new BigNumber(1).minus(new BigNumber(slippageTolerance).div(100)))
+      .toFixed(outputCoin.dp, BigNumber.ROUND_DOWN);
+
+    // Check wallet balance
+    const wallet = client.getWalletByTicker(inputCoin.ticker);
+    if (!wallet || new BigNumber(wallet.available).lt(amountIn)) {
+      throw new Error(`Insufficient balance for ${inputCoin.ticker}: ${wallet?.available || 0}`);
+    }
+
+    // Execute swap
+    const swap = await client.postSwap({
+      amountIn,
+      path: swapEstimate.path,
+      minAmountOut,
+    });
+    console.log('Swap executed:', swap.data);
+  } catch (error) {
+    console.error('Swap failed:', error.message);
+  }
+}
+
+executeSwap();
+```
+
+4. Managing Liquidity
+Deposit and withdraw liquidity for a trading pair, such as RUNES/XLM.
+
+
+```javascript
+import { BigNumber } from 'bignumber.js';
+
+async function manageLiquidity() {
+  try {
+    const coinA = client.getCoinByTicker('RUNES');
+    const coinB = client.getCoinByTicker('XLM');
+    if (!coinA || !coinB) {
+      throw new Error('Required coins not found');
+    }
+
+    // Check RUNES compliance
+    const { isCompliant, warnings } = client.checkRunesLiquidityFrontend(coinA, coinB);
+    if (!isCompliant) {
+      console.error('Cannot deposit liquidity:', warnings);
+      return;
+    }
+
+    // Estimate liquidity amounts
+    const amountA = '1'; // 1 RUNES
+    const estimate = await client.estimateLiquidityFrontend({
+      coinA,
+      coinB,
+      amountA,
+      amountB: null,
+      pools: client.getPools(),
+      coins: client.getCoins(),
+    });
+    console.log('Liquidity estimate:', {
+      amountA: estimate.amountA,
+      amountB: estimate.amountB,
+      pair: `${estimate.coinA.ticker}/${estimate.coinB.ticker}`,
+      isPoolEmpty: estimate.isPoolEmpty,
+      flipped: estimate.flipped,
+    });
+
+    // Validate wallet balances
+    const walletA = client.getWalletByTicker(coinA.ticker);
+    const walletB = client.getWalletByTicker(coinB.ticker);
+    if (!walletA || new BigNumber(walletA.available).lt(estimate.amountA)) {
+      throw new Error(`Insufficient balance for ${coinA.ticker}: ${walletA?.available || 0}`);
+    }
+    if (!walletB || new BigNumber(walletB.available).lt(estimate.amountB)) {
+      throw new Error(`Insufficient balance for ${coinB.ticker}: ${walletB?.available || 0}`);
+    }
+
+    // Deposit liquidity
+    const depositParams = {
+      coinA: { ticker: estimate.coinA.ticker },
+      coinB: { ticker: estimate.coinB.ticker },
+      amountA: estimate.amountA,
+      amountB: estimate.amountB,
+    };
+    const depositResult = await client.depositLiquidity(depositParams);
+    console.log('Liquidity deposited:', {
+      pair: `${depositResult.coinA.ticker}/${depositResult.coinB.ticker}`,
+      amountA: depositResult.amountA,
+      amountB: depositResult.amountB,
+      shares: depositResult.shares,
+      uid: depositResult.uid,
+    });
+
+    // Wait for user shares update
+    await new Promise(resolve => setTimeout(resolve, 5000));
+
+    // Calculate and withdraw shares
+    const updatedUserShares = client.getUserShares();
+    const calculatedShares = client.calculateShareAmounts();
+    const share = calculatedShares.find(
+      s => s.coinA.ticker === depositParams.coinA.ticker && s.coinB.ticker === depositParams.coinB.ticker
+    );
+
+    if (!share) {
+      throw new Error('No shares found for the deposited pool');
+    }
+
+    const sharesToWithdraw = new BigNumber(share.shares).div(2).integerValue(BigNumber.ROUND_DOWN).toString();
+    const withdrawResult = await client.withdrawLiquidity({
+      coinA: { ticker: share.coinA.ticker },
+      coinB: { ticker: share.coinB.ticker },
+      shares: sharesToWithdraw,
+    });
+    console.log('Liquidity withdrawn:', {
+      pair: `${withdrawResult.coinA.ticker}/${withdrawResult.coinB.ticker}`,
+      amountA: withdrawResult.amountA,
+      amountB: withdrawResult.amountB,
+      shares: withdrawResult.shares,
+      uid: withdrawResult.uid,
+    });
+  } catch (error) {
+    console.error('Liquidity operation failed:', error.message);
+  }
+}
+
+manageLiquidity();
+```
+
+5. Monitoring Pools, Wallets, and User Shares
+Set up periodic monitoring for pools, wallets, and user shares, and listen for WebSocket updates.
+
+### Monitor a Specific Pool
+```javascript
+client.monitorPool(1, 10000); // Monitor pool ID 1 every 10 seconds
+```
+
+### Monitor Wallets
+```javascript
+function monitorWallets(interval = 10000) {
+  setInterval(() => {
+    const wallets = client.getWallets();
+    console.log('Wallets:', wallets.length > 0
+      ? wallets.map(wallet => ({
+          ticker: wallet.ticker,
+          available: wallet.available,
+          locked: wallet.locked,
+          updatedAt: wallet.updatedAt,
+        }))
+      : 'No wallets available');
+  }, interval);
+}
+
+monitorWallets();
+```
+
+### Monitor User Shares
+```javascript
+function monitorUserShares(interval = 10000) {
+  setInterval(() => {
+    const userShares = client.getUserShares();
+    console.log('User shares:', userShares.length > 0
+      ? userShares.map(share => ({
+          poolId: share.poolId,
+          shares: share.shares,
+          updatedAt: share.updatedAt,
+        }))
+      : 'No user shares available');
+  }, interval);
+}
+
+monitorUserShares();
+```
+
+### Listen for WebSocket Updates
+```javascript
+const socket = client.getSocket();
+
+socket.on('pools_updated', ({ isInitial }) => {
+  if (isInitial) {
+    const pools = client.getPools();
+    console.log('Initial pools:', pools.map(pool => ({
+      id: pool.id,
+      pair: `${pool.coinA.ticker}/${pool.coinB.ticker}`,
+      reserveA: pool.reserveA,
+      reserveB: pool.reserveB,
+      totalShares: pool.totalShares,
+    })));
+  }
+});
+
+socket.on('coins_updated', ({ isInitial }) => {
+  if (isInitial) {
+    const coins = client.getCoins();
+    console.log('Initial coins:', coins.map(coin => ({
+      ticker: coin.ticker,
+      projectName: coin.projectName,
+      status: coin.status,
+    })));
+  }
+});
+
+socket.on('wallets_updated', ({ isInitial }) => {
+  if (isInitial) {
+    const wallets = client.getWallets();
+    console.log('Initial wallets:', wallets.map(wallet => ({
+      ticker: wallet.ticker,
+      available: wallet.available,
+      locked: wallet.locked,
+    })));
+  }
+});
+
+socket.on('user_shares_updated', ({ isInitial }) => {
+  if (isInitial) {
+    const userShares = client.getUserShares();
+    console.log('Initial user shares:', userShares.map(share => ({
+      poolId: share.poolId,
+      shares: share.shares,
+    })));
+  }
+});
+```
+
+6. Cleaning Up
+Disconnect the WebSocket when done to free resources.
+
+```javascript
+client.disconnect();
+```
+
+7. Handling Process Termination
+Gracefully handle process termination to ensure cleanup.
+
+```javascript
+process.on('SIGINT', () => {
+  console.log('Shutting down...');
+  client.disconnect();
+  process.exit(0);
+});
+```
+
+
+## API Reference
+
+### `createRunesXClient(options)`
+Creates a client instance.
+- **Parameters**:
+  - `options.apiKey` (string): RunesX API key.
+  - `options.apiUrl` (string, optional): API endpoint (default: `http://localhost:3010`).
+  - `options.socketUrl` (string, optional): WebSocket endpoint (default: `http://localhost:3010`).
+- **Returns**: Object with client methods.
+
+### `initialize()`
+Initializes the client, connecting to the WebSocket and fetching initial data.
+- **Returns**: Promise resolving to `{ pools, coins, wallets, userShares }`.
+
+### `getSocket()`
+Returns the Socket.IO instance.
+- **Returns**: Socket.IO client instance.
+
+### `getPools()`
+Returns all liquidity pools.
+- **Returns**: Array of pool objects.
+
+### `getPool(poolId)`
+Returns a specific pool by ID.
+- **Parameters**:
+  - `poolId` (number): Pool ID.
+- **Returns**: Pool object or undefined.
+
+### `getCoins()`
+Returns all coins.
+- **Returns**: Array of coin objects.
+
+### `getCoinByTicker(ticker)`
+Returns a coin by its ticker.
+- **Parameters**:
+  - `ticker` (string): Coin ticker (e.g., `xRUNES`).
+- **Returns**: Coin object or undefined.
+
+### `getWallets()`
+Returns all wallets.
+- **Returns**: Array of wallet objects.
+
+### `getWalletByTicker(ticker)`
+Returns a wallet by coin ticker.
+- **Parameters**:
+  - `ticker` (string): Coin ticker.
+- **Returns**: Wallet object or undefined.
+
+### `getUserShares()`
+Returns all user shares.
+- **Returns**: Array of user share objects.
+
+### `getUserShareByPoolId(poolId)`
+Returns user shares for a specific pool.
+- **Parameters**:
+  - `poolId` (number): Pool ID.
+- **Returns**: User share object or undefined.
+
+### `postSwap(params)`
+Executes a swap.
+- **Parameters**:
+  - `params.amountIn` (string): Input amount.
+  - `params.path` (array): Array of `{ from, to }` objects defining the swap path.
+  - `params.minAmountOut` (string): Minimum output amount.
+- **Returns**: Promise resolving to swap response.
+
+### `depositLiquidity(params)`
+Deposits liquidity to a pool.
+- **Parameters**:
+  - `params.coinA` (object): `{ ticker }` of first coin.
+  - `params.coinB` (object): `{ ticker }` of second coin.
+  - `params.amountA` (string): Amount of first coin.
+  - `params.amountB` (string): Amount of second coin.
+- **Returns**: Promise resolving to deposit response.
+
+### `withdrawLiquidity(params)`
+Withdraws liquidity from a pool.
+- **Parameters**:
+  - `params.coinA` (object): `{ ticker }` of first coin.
+  - `params.coinB` (object): `{ ticker }` of second coin.
+  - `params.shares` (string): Number of shares to withdraw.
+- **Returns**: Promise resolving to withdrawal response.
+
+### `getWalletsApi()`
+Fetches wallet data via the API.
+- **Returns**: Promise resolving to wallet data.
+
+### `estimateSwap(inputCoin, outputCoin, amountIn, maxHops, algorithm)`
+Estimates a swap outcome.
+- **Parameters**:
+  - `inputCoin` (object): Input coin object.
+  - `outputCoin` (object): Output coin object.
+  - `amountIn` (string): Input amount.
+  - `maxHops` (number, optional): Maximum hops (default: 6).
+  - `algorithm` (string, optional): Pathfinding algorithm (`dfs` or `bfs`, default: `dfs`).
+- **Returns**: Promise resolving to swap estimate.
+
+### `estimateLiquidityFrontend(params)`
+Estimates liquidity amounts for a pool.
+- **Parameters**:
+  - `params.coinA` (object): First coin.
+  - `params.coinB` (object): Second coin.
+  - `params.amountA` (string, optional): Amount of first coin.
+  - `params.amountB` (string, optional): Amount of second coin.
+  - `params.pools` (array): Array of pools.
+  - `params.coins` (array): Array of coins.
+- **Returns**: Liquidity estimate object.
+
+### `checkRunesLiquidityFrontend(coinA, coinB)`
+Checks RUNES compliance for a trading pair.
+- **Parameters**:
+  - `coinA` (object): First coin.
+  - `coinB` (object): Second coin.
+- **Returns**: `{ isCompliant, warnings }`.
+
+### `calculateShareAmounts()`
+Calculates amounts for user shares.
+- **Returns**: Array of share objects with calculated amounts.
+
+### `monitorPool(poolId, interval)`
+Monitors a pool periodically.
+- **Parameters**:
+  - `poolId` (number): Pool ID.
+  - `interval` (number, optional): Interval in milliseconds (default: 10000).
+
+### `disconnect()`
+Disconnects the WebSocket.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runesx/api-client",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A Node.js client for interacting with the RunesX platform API and WebSocket",
   "main": "src/index.mjs",
   "type": "module",

package/src/index.mjs

@@ -9,6 +9,7 @@ import { getUserShares, getUserShareByPoolId } from './store/userSharesStore.mjs
 import { waitForStores } from './waitForStores.mjs';
 import { estimateLiquidityFrontend, checkRunesLiquidityFrontend, calculateShareAmounts } from './utils/liquidityUtils.mjs';
 import { estimateSwap } from './utils/swapUtils.mjs';
+import { createPriceUtils } from './utils/priceUtils.mjs';
 
 export function createRunesXClient(options = {}) {
   const config = createConfig(options);
@@ -71,6 +72,9 @@ export function createRunesXClient(options = {}) {
         }
       }, interval);
     },
+    utils: {
+      ...createPriceUtils(),
+    },
     disconnect: () => {
       if (socket) {
         socket.disconnect();

package/src/socket.mjs

@@ -19,11 +19,8 @@ export function setupSocket(config) {
   const errorCount = { count: 0 }; // Track connection errors
 
   socket.on('connect', () => {
-    console.log('Connected to Socket.IO server');
     socket.emit('join_public');
-    console.log('Joined public room');
     socket.emit('join_private');
-    console.log('Joined private room');
     errorCount.count = 0;
   });
 
@@ -51,11 +48,8 @@ export function setupSocket(config) {
   });
 
   socket.on('reconnect', () => {
-    console.log('Reconnected to Socket.IO server');
     socket.emit('join_public');
-    console.log('Rejoined public room');
     socket.emit('join_private');
-    console.log('Rejoined private room');
     resetPools();
     resetCoins();
     resetWallets();
@@ -78,7 +72,7 @@ export function setupSocket(config) {
   });
 
   socket.on('pools_updated', ({ pools, isInitial }) => {
-    console.log('Received pools_updated:', { pools, isInitial });
+    // console.log('Received pools_updated:', { pools, isInitial });
     if (isInitial) {
       setInitialPools(pools);
     } else {
@@ -87,7 +81,7 @@ export function setupSocket(config) {
   });
 
   socket.on('coins_updated', ({ coins, isInitial }) => {
-    console.log('Received coins_updated:', { coins, isInitial });
+    // console.log('Received coins_updated:', { coins, isInitial });
     if (isInitial) {
       setInitialCoins(coins);
     } else {
@@ -96,7 +90,7 @@ export function setupSocket(config) {
   });
 
   socket.on('wallets_updated', ({ wallets, isInitial }) => {
-    console.log('Received wallets_updated:', { wallets, isInitial });
+    // console.log('Received wallets_updated:', { wallets, isInitial });
     if (isInitial) {
       setInitialWallets(wallets);
     } else {
@@ -105,7 +99,7 @@ export function setupSocket(config) {
   });
 
   socket.on('user_shares_updated', ({ userShares, isInitial }) => {
-    console.log('Received user_shares_updated:', { userShares, isInitial });
+    // console.log('Received user_shares_updated:', { userShares, isInitial });
     if (isInitial) {
       setInitialUserShares(userShares);
     } else {
@@ -114,30 +108,30 @@ export function setupSocket(config) {
   });
 
   socket.on('volumeUpdate', ({ type, poolId, timestamp, volume }) => {
-    console.log('Volume update:', { type, poolId, timestamp, volume });
+    // console.log('Volume update:', { type, poolId, timestamp, volume });
   });
 
   socket.on('operationUpdate', (operation) => {
-    console.log('Operation update:', operation);
+    // console.log('Operation update:', operation);
     // Assuming operation includes liquidity deposit/withdraw results
-    if (operation.type === 'liquidity_deposit' || operation.type === 'liquidity_withdraw') {
-      console.log(`Liquidity operation ${operation.type} completed:`, {
-        uid: operation.uid,
-        coinA: operation.coinA,
-        coinB: operation.coinB,
-        amountA: operation.amountA,
-        amountB: operation.amountB,
-        shares: operation.shares,
-        status: operation.status,
-      });
-    }
+    // if (operation.type === 'liquidity_deposit' || operation.type === 'liquidity_withdraw') {
+    //   console.log(`Liquidity operation ${operation.type} completed:`, {
+    //     uid: operation.uid,
+    //     coinA: operation.coinA,
+    //     coinB: operation.coinB,
+    //     amountA: operation.amountA,
+    //     amountB: operation.amountB,
+    //     shares: operation.shares,
+    //     status: operation.status,
+    //   });
+    // }
   });
   socket.on('status_updated', (data) => {
-    console.log('Status update:', data);
+    // console.log('Status update:', data);
   });
 
   socket.on('deposit_address_generated', ({ requestId, chainId, address, memo }) => {
-    console.log('Deposit address generated:', { requestId, chainId, address, memo });
+    // console.log('Deposit address generated:', { requestId, chainId, address, memo });
   });
 
   socket.on('deposit_processed', (data) => {
@@ -192,31 +186,31 @@ export function setupSocket(config) {
   // });
 
   socket.on('yard_message', (message) => {
-    console.log('New chat message:', {
-      username: message.username,
-      text: message.text,
-      role: message.role,
-      timestamp: new Date(message.timestamp).toLocaleString(),
-    });
+    // console.log('New chat message:', {
+    //   username: message.username,
+    //   text: message.text,
+    //   role: message.role,
+    //   timestamp: new Date(message.timestamp).toLocaleString(),
+    // });
   });
 
   socket.on('message_deleted', ({ messageId }) => {
-    console.log('Message deleted:', { messageId });
+    // console.log('Message deleted:', { messageId });
   });
 
   socket.on('banned', ({ reason, bannedUntil }) => {
-    console.log('Banned from yard:', {
-      reason,
-      bannedUntil: new Date(bannedUntil).toLocaleString(),
-    });
+    // console.log('Banned from yard:', {
+    //   reason,
+    //   bannedUntil: new Date(bannedUntil).toLocaleString(),
+    // });
   });
 
   socket.on('withdrawal_updated', ({ pendingWithdrawalId, expiresAt, stage }) => {
-    console.log('Withdrawal updated:', { pendingWithdrawalId, expiresAt, stage });
+    // console.log('Withdrawal updated:', { pendingWithdrawalId, expiresAt, stage });
   });
 
   socket.on('withdrawal_expired', ({ pendingWithdrawalId, ticker, amount }) => {
-    console.log('Withdrawal expired:', { pendingWithdrawalId, ticker, amount });
+    // console.log('Withdrawal expired:', { pendingWithdrawalId, ticker, amount });
   });
 
   socket.on('pong', () => {
@@ -238,9 +232,9 @@ export function setupSocket(config) {
   });
 
   socket.on('connect', () => {
-    socket.emit('yard_message', {
-      text: 'Hello from RunesX API Key Example Bot!!',
-    });
+    // socket.emit('yard_message', {
+    //   text: 'Hello from RunesX API Key Example Bot!!',
+    // });
   });
 
   return { socket };

package/src/store/coinStore.mjs

@@ -22,11 +22,9 @@ const setInitialCoins = (coins) => {
     });
   });
   coinStore.isInitialReceived = true;
-  console.log(`Initialized with ${coins.length} coins`);
 
   // Process buffered updates
   if (coinStore.pendingUpdates.length > 0) {
-    console.log(`Processing ${coinStore.pendingUpdates.length} buffered coin updates`);
     coinStore.pendingUpdates.forEach(({ coins }) => {
       coins.forEach(coin => updateCoin(coin));
     });
@@ -37,7 +35,6 @@ const setInitialCoins = (coins) => {
 // Update a single coin
 const updateCoin = (coin) => {
   if (!coinStore.isInitialReceived) {
-    console.log('Buffering coin update, initial data not yet received:', coin);
     coinStore.pendingUpdates.push({ coins: [coin] });
     return;
   }
@@ -48,19 +45,9 @@ const updateCoin = (coin) => {
   if (existingCoin) {
     const existingUpdatedAt = new Date(existingCoin.updatedAt).getTime();
     if (incomingUpdatedAt <= existingUpdatedAt) {
-      console.log(`Skipping stale update for coin ${coin.id}`);
       return;
     }
 
-    console.log(`Updating coin ${coin.id} (${coin.ticker}):`, {
-      ticker: coin.ticker,
-      dp: coin.dp,
-      projectName: coin.projectName,
-      status: coin.status,
-      runesComplianceRequirement: coin.runesComplianceRequirement,
-      CoinChains: coin.CoinChains,
-    });
-
     Object.assign(existingCoin, {
       ticker: coin.ticker,
       dp: coin.dp,
@@ -71,7 +58,6 @@ const updateCoin = (coin) => {
       CoinChains: coin.CoinChains || existingCoin.CoinChains,
     });
   } else if (coin.ticker && coin.status && new BigNumber(coin.dp || 0).gte(0)) {
-    console.log(`Adding new coin ${coin.id}:`, coin);
     coinStore.coins.set(coin.id, {
       id: coin.id,
       ticker: coin.ticker,

package/src/store/poolStore.mjs

@@ -26,11 +26,9 @@ const setInitialPools = (pools) => {
     });
   });
   poolStore.isInitialReceived = true;
-  console.log(`Initialized with ${pools.length} pools`);
 
   // Process buffered updates
   if (poolStore.pendingUpdates.length > 0) {
-    console.log(`Processing ${poolStore.pendingUpdates.length} buffered pool updates`);
     poolStore.pendingUpdates.forEach(({ pools }) => {
       pools.forEach(pool => updatePool(pool));
     });
@@ -41,7 +39,6 @@ const setInitialPools = (pools) => {
 // Update a single pool
 const updatePool = (pool) => {
   if (!poolStore.isInitialReceived) {
-    console.log('Buffering pool update, initial data not yet received:', pool);
     poolStore.pendingUpdates.push({ pools: [pool] });
     return;
   }
@@ -52,17 +49,9 @@ const updatePool = (pool) => {
   if (existingPool) {
     const existingUpdatedAt = new Date(existingPool.updatedAt).getTime();
     if (incomingUpdatedAt <= existingUpdatedAt) {
-      console.log(`Skipping stale update for pool ${pool.id}`);
       return;
     }
 
-    console.log(`Updating pool ${pool.id}:`, {
-      reserveA: pool.reserveA,
-      reserveB: pool.reserveB,
-      totalShares: pool.totalShares,
-      activeLiquidityProviders: pool.activeLiquidityProviders,
-    });
-
     Object.assign(existingPool, {
       reserveA: pool.reserveA,
       reserveB: pool.reserveB,
@@ -91,11 +80,9 @@ const updatePool = (pool) => {
     });
 
     if (new BigNumber(existingPool.totalShares).isZero()) {
-      console.log(`Removing pool ${pool.id} with zero totalShares`);
       poolStore.pools.delete(pool.id);
     }
   } else if (pool.coinA && pool.coinB && new BigNumber(pool.totalShares).gt(0)) {
-    console.log(`Adding new pool ${pool.id}:`, pool);
     poolStore.pools.set(pool.id, {
       id: pool.id,
       reserveA: pool.reserveA,

package/src/store/userSharesStore.mjs

@@ -30,7 +30,6 @@ const setInitialUserShares = (userShares) => {
 
 const updateUserShare = (share) => {
   if (!userSharesStore.isInitialReceived) {
-    console.log('Buffering user share update, initial data not yet received:', share);
     userSharesStore.pendingUpdates.push({ userShares: [share] });
     return;
   }
@@ -41,22 +40,15 @@ const updateUserShare = (share) => {
   if (existingShare) {
     const existingUpdatedAt = new Date(existingShare.updatedAt).getTime();
     if (incomingUpdatedAt <= existingUpdatedAt) {
-      console.log(`Skipping stale update for user share in pool ${share.poolId}`);
       return;
     }
 
-    console.log(`Updating user share for pool ${share.poolId}:`, {
-      shares: share.shares,
-      updatedAt: share.updatedAt,
-    });
-
     userSharesStore.userShares.set(share.poolId, {
       poolId: share.poolId,
       shares: new BigNumber(share.shares).toString(),
       updatedAt: share.updatedAt,
     });
   } else if (share.poolId && new BigNumber(share.shares).gt(0)) {
-    console.log(`Adding new user share for pool ${share.poolId}:`, share);
     userSharesStore.userShares.set(share.poolId, {
       poolId: share.poolId,
       shares: new BigNumber(share.shares).toString(),
@@ -67,7 +59,6 @@ const updateUserShare = (share) => {
   }
 
   if (existingShare && new BigNumber(share.shares).isZero()) {
-    console.log(`Removing user share for pool ${share.poolId} with zero shares`);
     userSharesStore.userShares.delete(share.poolId);
   }
 };

package/src/store/walletStore.mjs

@@ -19,11 +19,9 @@ const setInitialWallets = (wallets) => {
     });
   });
   walletStore.isInitialReceived = true;
-  console.log(`Initialized with ${wallets.length} wallets`);
 
   // Process buffered updates
   if (walletStore.pendingUpdates.length > 0) {
-    console.log(`Processing ${walletStore.pendingUpdates.length} buffered wallet updates`);
     walletStore.pendingUpdates.forEach(({ wallets }) => {
       wallets.forEach(wallet => updateWallet(wallet));
     });
@@ -34,7 +32,6 @@ const setInitialWallets = (wallets) => {
 // Update a single wallet
 const updateWallet = (wallet) => {
   if (!walletStore.isInitialReceived) {
-    console.log('Buffering wallet update, initial data not yet received:', wallet);
     walletStore.pendingUpdates.push({ wallets: [wallet] });
     return;
   }
@@ -45,16 +42,9 @@ const updateWallet = (wallet) => {
   if (existingWallet) {
     const existingUpdatedAt = new Date(existingWallet.updatedAt).getTime();
     if (incomingUpdatedAt <= existingUpdatedAt) {
-      console.log(`Skipping stale update for wallet ${wallet.ticker}`);
       return;
     }
 
-    console.log(`Updating wallet ${wallet.ticker}:`, {
-      available: wallet.available,
-      locked: wallet.locked,
-      updatedAt: wallet.updatedAt,
-    });
-
     walletStore.wallets.set(wallet.ticker, {
       ...existingWallet,
       available: new BigNumber(wallet.available).toString(),
@@ -62,7 +52,6 @@ const updateWallet = (wallet) => {
       updatedAt: wallet.updatedAt,
     });
   } else if (wallet.ticker && new BigNumber(wallet.available).gte(0) && new BigNumber(wallet.locked).gte(0)) {
-    console.log(`Adding new wallet ${wallet.ticker}:`, wallet);
     walletStore.wallets.set(wallet.ticker, {
       id: wallet.id,
       ticker: wallet.ticker,
@@ -90,7 +79,6 @@ const resetWallets = () => {
   walletStore.wallets.clear();
   walletStore.isInitialReceived = false;
   walletStore.pendingUpdates = [];
-  console.log('Reset wallet state due to disconnect or error');
 };
 
 export { walletStore, setInitialWallets, updateWallet, getWallets, getWalletByTicker, resetWallets };

package/src/utils/liquidityUtils.mjs

@@ -1,6 +1,8 @@
 // src/utils/liquidityUtils.mjs
 import { BigNumber } from 'bignumber.js';
 
+import { getRunesPriceUSD, getTokenPriceInRunes } from './swapUtils';
+
 export function normalizeTokenPairFrontend(coinA, coinB, pools) {
   if (!coinA || !coinB || !coinA.ticker || !coinB.ticker) {
     throw new Error('Invalid token objects');
@@ -210,4 +212,43 @@ export function calculateShareAmounts({ userShares, pools }) {
       pair: `${pool.coinA.ticker}/${pool.coinB.ticker}`,
     };
   });
-}
+}
+
+export const getPoolLiquidityUSD = (pool, coins, pools) => {
+  if (!pool || !coins || !pools || !pool.runesCompliant) {
+    return { value: '0', error: 'Pool or coin data missing or not RUNES compliant' };
+  }
+
+  const coinA = coins.find((c) => c.ticker === pool.coinA.ticker);
+  const coinB = coins.find((c) => c.ticker === pool.coinB.ticker);
+  if (!coinA || !coinB) {
+    return { value: '0', error: `Coins not found: ${pool.coinA.ticker}/${pool.coinB.ticker}` };
+  }
+
+  const reserveA = new BigNumber(pool.reserveA).shiftedBy(-pool.coinA.dp);
+  const reserveB = new BigNumber(pool.reserveB).shiftedBy(-pool.coinB.dp);
+
+  if (reserveA.isZero() || reserveB.isZero()) {
+    return { value: '0', error: 'Zero reserves in pool' };
+  }
+
+  const runesPriceUSD = getRunesPriceUSD(pools);
+  const priceAInRunes = new BigNumber(getTokenPriceInRunes(coinA, pools) || '0');
+  const priceBInRunes = new BigNumber(getTokenPriceInRunes(coinB, pools) || '0');
+
+  const valueA = priceAInRunes.times(runesPriceUSD).times(reserveA);
+  const valueB = priceBInRunes.times(runesPriceUSD).times(reserveB);
+
+  if (valueA.isNaN() || valueB.isNaN() || priceAInRunes.isZero() || priceBInRunes.isZero()) {
+    return {
+      value: '0',
+      error: 'Invalid liquidity data (NaN or zero price)',
+    };
+  }
+
+  const poolValue = valueA.plus(valueB);
+  return {
+    value: poolValue.toString(),
+    error: null,
+  };
+};

package/src/utils/priceUtils.mjs

@@ -0,0 +1,122 @@
+// src/utils/priceUtils.mjs
+import { BigNumber } from 'bignumber.js';
+
+import { getPools } from '../store/poolStore.mjs';
+import { getCoinByTicker } from '../store/coinStore.mjs';
+
+export function createPriceUtils() {
+  const getRunesPriceUSD = () => {
+    const pools = getPools();
+
+    const runesUsdcPool = pools.find((p) =>
+      (p.coinA.ticker === 'RUNES' && p.coinB.ticker === 'USDC') ||
+      (p.coinA.ticker === 'USDC' && p.coinB.ticker === 'RUNES')
+    );
+
+    if (!runesUsdcPool) {
+      console.warn('RUNES/USDC pool not found, using fallback price of $0.01');
+      return '0.01';
+    }
+
+    const reserveA = new BigNumber(runesUsdcPool.reserveA).shiftedBy(-runesUsdcPool.coinA.dp);
+    const reserveB = new BigNumber(runesUsdcPool.reserveB).shiftedBy(-runesUsdcPool.coinB.dp);
+
+    if (reserveA.isZero() || reserveB.isZero()) {
+      console.warn('RUNES/USDC pool has zero reserves, using fallback price of $0.01');
+      return '0.01';
+    }
+
+    const runesPriceUSD = runesUsdcPool.coinA.ticker === 'RUNES'
+      ? reserveB.div(reserveA)
+      : reserveA.div(reserveB);
+
+    if (runesPriceUSD.isNaN() || runesPriceUSD.lte(0)) {
+      console.warn('Invalid RUNES/USDC price calculated, using fallback price of $0.01');
+      return '0.01';
+    }
+
+    return runesPriceUSD.toString();
+  };
+
+  const getTokenPriceInRunes = (ticker) => {
+    ensureInitialized();
+    if (ticker === 'RUNES') {return '1';}
+
+    const pools = getPools();
+    const pool = pools.find(
+      (p) =>
+        (p.coinA.ticker === 'RUNES' && p.coinB.ticker === ticker) ||
+        (p.coinB.ticker === 'RUNES' && p.coinA.ticker === ticker)
+    );
+
+    if (!pool || new BigNumber(pool.reserveA).isZero() || new BigNumber(pool.reserveB).isZero()) {
+      return '0';
+    }
+
+    const reserveA = new BigNumber(pool.reserveA).shiftedBy(-pool.coinA.dp);
+    const reserveB = new BigNumber(pool.reserveB).shiftedBy(-pool.coinB.dp);
+
+    const priceInRunes = pool.coinA.ticker === 'RUNES'
+      ? reserveA.div(reserveB)
+      : reserveB.div(reserveA);
+
+    return priceInRunes.toString();
+  };
+
+  const getTokenPriceUSD = (ticker) => {
+    ensureInitialized();
+    if (ticker === 'USDC') {return '1';}
+
+    const coin = getCoinByTicker(ticker);
+    if (!coin) {
+      console.warn(`Coin not found for ticker ${ticker}`);
+      return '0';
+    }
+
+    const runesPriceUSD = getRunesPriceUSD();
+    const priceInRunes = getTokenPriceInRunes(ticker);
+
+    if (priceInRunes === '0') {return '0';}
+
+    return new BigNumber(priceInRunes).multipliedBy(runesPriceUSD).toString();
+  };
+
+  const getPrices = (tickers) => {
+    const prices = {};
+    for (const ticker of tickers) {
+      try {
+        prices[ticker] = getTokenPriceUSD(ticker);
+      } catch (e) {
+        console.warn(`Failed to get price for ${ticker}:`, e.message);
+        prices[ticker] = null;
+      }
+    }
+    return prices;
+  };
+
+  const calculateUSDValue = (amount, ticker, decimals = null) => {
+    try {
+      const priceUSD = getTokenPriceUSD(ticker);
+      if (priceUSD === '0' || !priceUSD) {return '0.00';}
+
+      let valueBN = new BigNumber(amount).multipliedBy(priceUSD);
+
+      if (decimals !== null) {
+        valueBN = valueBN.dp(decimals, BigNumber.ROUND_DOWN);
+      }
+
+      return valueBN.toString();
+    } catch (error) {
+      console.warn(`Failed to calculate USD value for ${amount} ${ticker}:`, error.message);
+      return '0.00';
+    }
+  };
+
+  return {
+    getRunesPriceUSD,
+    getTokenPriceInRunes,
+    getTokenPriceUSD,
+    getPrices,
+    calculateUSDValue,
+  };
+}

package/src/waitForStores.mjs

@@ -9,7 +9,6 @@ export function waitForStores(socket) {
     return new Promise((resolve, reject) => {
       if (poolStore.isInitialReceived) {
         const pools = getPools();
-        console.log('Initial pool data already received:', pools.length, 'pools', pools);
         resolve(pools);
         return;
       }
@@ -19,10 +18,8 @@ export function waitForStores(socket) {
       }, 30000); // 30-second timeout
 
       socket.on('pools_updated', ({ isInitial, pools }) => {
-        console.log('Received pools_updated:', { isInitial, pools });
         if (isInitial) {
           const pools = getPools();
-          console.log('Initial pool data received:', pools.length, 'pools', pools);
           clearTimeout(timeout);
           resolve(pools);
         }
@@ -47,7 +44,6 @@ export function waitForStores(socket) {
     return new Promise((resolve, reject) => {
       if (coinStore.isInitialReceived) {
         const coins = getCoins();
-        console.log('Initial coin data already received:', coins.length, 'coins', coins);
         resolve(coins);
         return;
       }
@@ -57,10 +53,8 @@ export function waitForStores(socket) {
       }, 30000); // 30-second timeout
 
       socket.on('coins_updated', ({ isInitial, coins }) => {
-        console.log('Received coins_updated:', { isInitial, coins });
         if (isInitial) {
           const coins = getCoins();
-          console.log('Initial coin data received:', coins.length, 'coins', coins);
           clearTimeout(timeout);
           resolve(coins);
         }
@@ -85,7 +79,6 @@ export function waitForStores(socket) {
     return new Promise((resolve, reject) => {
       if (walletStore.isInitialReceived) {
         const wallets = getWallets();
-        console.log('Initial wallet data already received:', wallets.length, 'wallets', wallets);
         resolve(wallets);
         return;
       }
@@ -95,10 +88,8 @@ export function waitForStores(socket) {
       }, 30000); // 30-second timeout
 
       socket.on('wallets_updated', ({ isInitial, wallets }) => {
-        console.log('Received wallets_updated:', { isInitial, wallets });
         if (isInitial) {
           const wallets = getWallets();
-          console.log('Initial wallet data received:', wallets.length, 'wallets', wallets);
           clearTimeout(timeout);
           resolve(wallets);
         }
@@ -123,7 +114,6 @@ export function waitForStores(socket) {
     return new Promise((resolve, reject) => {
       if (userSharesStore.isInitialReceived) {
         const userShares = getUserShares();
-        console.log('Initial user shares data already received:', userShares.length, 'user shares', userShares);
         resolve(userShares);
         return;
       }
@@ -133,10 +123,8 @@ export function waitForStores(socket) {
       }, 30000); // 30-second timeout
 
       socket.on('user_shares_updated', ({ isInitial, userShares }) => {
-        console.log('Received user_shares_updated:', { isInitial, userShares });
         if (isInitial) {
           const userShares = getUserShares();
-          console.log('Initial user shares data received:', userShares.length, 'user shares', userShares);
           clearTimeout(timeout);
           resolve(userShares);
         }