@runesx/api-client 0.0.1

package/src/store/poolStore.mjs

@@ -0,0 +1,136 @@
+import { BigNumber } from 'bignumber.js';
+
+const poolStore = {
+  pools: new Map(), // Store pool data by pool ID
+  isInitialReceived: false, // Track if initial pool data is received
+  pendingUpdates: [], // Buffer for updates before initial data
+};
+
+// Initialize pools with initial data
+const setInitialPools = (pools) => {
+  poolStore.pools.clear();
+  pools.forEach(pool => {
+    poolStore.pools.set(pool.id, {
+      id: pool.id,
+      reserveA: pool.reserveA,
+      reserveB: pool.reserveB,
+      totalShares: pool.totalShares,
+      activeLiquidityProviders: pool.activeLiquidityProviders || 0,
+      runesCompliant: pool.runesCompliant || false,
+      lpFeeRate: pool.lpFeeRate || 30,
+      treasuryFeeRate: pool.treasuryFeeRate || 5,
+      coinA: pool.coinA,
+      coinB: pool.coinB,
+      liquidityShares: pool.liquidityShares || [],
+      updatedAt: pool.updatedAt,
+    });
+  });
+  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));
+    });
+    poolStore.pendingUpdates = [];
+  }
+};
+
+// 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;
+  }
+
+  const existingPool = poolStore.pools.get(pool.id);
+  const incomingUpdatedAt = new Date(pool.updatedAt).getTime();
+
+  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,
+      updatedAt: pool.updatedAt,
+      ...(pool.totalShares !== undefined && { totalShares: pool.totalShares }),
+      ...(pool.activeLiquidityProviders !== undefined && { activeLiquidityProviders: pool.activeLiquidityProviders }),
+      ...(pool.runesCompliant !== undefined && { runesCompliant: pool.runesCompliant }),
+      ...(pool.lpFeeRate !== undefined && { lpFeeRate: pool.lpFeeRate }),
+      ...(pool.treasuryFeeRate !== undefined && { treasuryFeeRate: pool.treasuryFeeRate }),
+      ...(pool.coinA && { coinA: pool.coinA }),
+      ...(pool.coinB && { coinB: pool.coinB }),
+      ...(pool.liquidityShares && {
+        liquidityShares: pool.liquidityShares.reduce((acc, newShare) => {
+          if (new BigNumber(newShare.shares).isZero()) {
+            return acc.filter(share => share.id !== newShare.id);
+          }
+          const existingShareIndex = acc.findIndex(share => share.id === newShare.id);
+          if (existingShareIndex >= 0) {
+            acc[existingShareIndex] = newShare;
+          } else {
+            acc.push(newShare);
+          }
+          return acc;
+        }, [...(existingPool.liquidityShares || [])]),
+      }),
+    });
+
+    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,
+      reserveB: pool.reserveB,
+      totalShares: pool.totalShares,
+      runesCompliant: pool.runesCompliant || false,
+      lpFeeRate: pool.lpFeeRate || 30,
+      treasuryFeeRate: pool.treasuryFeeRate || 5,
+      coinA: pool.coinA,
+      coinB: pool.coinB,
+      activeLiquidityProviders: pool.activeLiquidityProviders || 0,
+      liquidityShares: pool.liquidityShares || [],
+      updatedAt: pool.updatedAt,
+    });
+  } else {
+    console.warn(`Ignoring update for unknown pool ${pool.id} without full data or zero totalShares`);
+  }
+};
+
+// Get all pools
+const getPools = () => {
+  return Array.from(poolStore.pools.values());
+};
+
+// Get a specific pool by ID
+const getPool = (poolId) => {
+  return poolStore.pools.get(poolId);
+};
+
+// Reset store on disconnect or error
+const resetPools = () => {
+  poolStore.pools.clear();
+  poolStore.isInitialReceived = false;
+  poolStore.pendingUpdates = [];
+  console.log('Reset pool state due to disconnect or error');
+};
+
+export { poolStore, setInitialPools, updatePool, getPools, getPool, resetPools };

package/src/store/userSharesStore.mjs

@@ -0,0 +1,90 @@
+// src/store/userSharesStore.mjs
+import { BigNumber } from 'bignumber.js';
+
+const userSharesStore = {
+  userShares: new Map(),
+  isInitialReceived: false,
+  pendingUpdates: [],
+};
+
+const setInitialUserShares = (userShares) => {
+  userSharesStore.userShares.clear();
+  userShares.forEach(share => {
+    userSharesStore.userShares.set(share.poolId, {
+      poolId: share.poolId,
+      shares: new BigNumber(share.shares).toString(),
+      updatedAt: share.updatedAt,
+    });
+  });
+  userSharesStore.isInitialReceived = true;
+  console.log(`Initialized with ${userShares.length} user shares`);
+
+  if (userSharesStore.pendingUpdates.length > 0) {
+    console.log(`Processing ${userSharesStore.pendingUpdates.length} buffered user share updates`);
+    userSharesStore.pendingUpdates.forEach(({ userShares }) => {
+      userShares.forEach(share => updateUserShare(share));
+    });
+    userSharesStore.pendingUpdates = [];
+  }
+};
+
+const updateUserShare = (share) => {
+  if (!userSharesStore.isInitialReceived) {
+    console.log('Buffering user share update, initial data not yet received:', share);
+    userSharesStore.pendingUpdates.push({ userShares: [share] });
+    return;
+  }
+
+  const existingShare = userSharesStore.userShares.get(share.poolId);
+  const incomingUpdatedAt = new Date(share.updatedAt).getTime();
+
+  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(),
+      updatedAt: share.updatedAt,
+    });
+  } else {
+    console.warn(`Ignoring update for user share in pool ${share.poolId} with zero or negative shares`);
+  }
+
+  if (existingShare && new BigNumber(share.shares).isZero()) {
+    console.log(`Removing user share for pool ${share.poolId} with zero shares`);
+    userSharesStore.userShares.delete(share.poolId);
+  }
+};
+
+const getUserShares = () => {
+  return Array.from(userSharesStore.userShares.values());
+};
+
+const getUserShareByPoolId = (poolId) => {
+  return userSharesStore.userShares.get(poolId);
+};
+
+const resetUserShares = () => {
+  userSharesStore.userShares.clear();
+  userSharesStore.isInitialReceived = false;
+  userSharesStore.pendingUpdates = [];
+  console.log('Reset user shares state due to disconnect or error');
+};
+
+export { userSharesStore, setInitialUserShares, updateUserShare, getUserShares, getUserShareByPoolId, resetUserShares };

package/src/store/walletStore.mjs

@@ -0,0 +1,96 @@
+import { BigNumber } from 'bignumber.js';
+
+const walletStore = {
+  wallets: new Map(), // Store wallet data by ticker
+  isInitialReceived: false, // Track if initial wallet data is received
+  pendingUpdates: [], // Buffer for updates before initial data
+};
+
+// Initialize wallets with initial data
+const setInitialWallets = (wallets) => {
+  walletStore.wallets.clear();
+  wallets.forEach(wallet => {
+    walletStore.wallets.set(wallet.ticker, {
+      id: wallet.id,
+      ticker: wallet.ticker,
+      available: new BigNumber(wallet.available).toString(),
+      locked: new BigNumber(wallet.locked).toString(),
+      updatedAt: wallet.updatedAt,
+    });
+  });
+  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));
+    });
+    walletStore.pendingUpdates = [];
+  }
+};
+
+// 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;
+  }
+
+  const existingWallet = walletStore.wallets.get(wallet.ticker);
+  const incomingUpdatedAt = new Date(wallet.updatedAt).getTime();
+
+  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(),
+      locked: new BigNumber(wallet.locked).toString(),
+      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,
+      available: new BigNumber(wallet.available).toString(),
+      locked: new BigNumber(wallet.locked).toString(),
+      updatedAt: wallet.updatedAt,
+    });
+  } else {
+    console.warn(`Ignoring update for unknown wallet ${wallet.ticker} with incomplete data`);
+  }
+};
+
+// Get all wallets
+const getWallets = () => {
+  return Array.from(walletStore.wallets.values());
+};
+
+// Get a specific wallet by ticker
+const getWalletByTicker = (ticker) => {
+  return walletStore.wallets.get(ticker);
+};
+
+// Reset store on disconnect or error
+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

@@ -0,0 +1,213 @@
+// src/utils/liquidityUtils.mjs
+import { BigNumber } from 'bignumber.js';
+
+export function normalizeTokenPairFrontend(coinA, coinB, pools) {
+  if (!coinA || !coinB || !coinA.ticker || !coinB.ticker) {
+    throw new Error('Invalid token objects');
+  }
+
+  if (coinA.ticker === 'RUNES') {
+    return { tokenA: coinA, tokenB: coinB, flipped: false };
+  }
+  if (coinB.ticker === 'RUNES') {
+    return { tokenA: coinB, tokenB: coinA, flipped: true };
+  }
+
+  const pool = pools.find(
+    (p) =>
+      (p.coinA.ticker === coinA.ticker && p.coinB.ticker === coinB.ticker) ||
+      (p.coinB.ticker === coinA.ticker && p.coinA.ticker === coinB.ticker)
+  );
+
+  if (pool) {
+    if (pool.coinA.ticker === coinA.ticker && pool.coinB.ticker === coinB.ticker) {
+      return { tokenA: coinA, tokenB: coinB, flipped: false };
+    }
+    return { tokenA: coinB, tokenB: coinA, flipped: true };
+  }
+
+  return { tokenA: coinA, tokenB: coinB, flipped: false };
+}
+
+export function checkRunesLiquidityFrontend(tokenA, tokenB, pools, coins) {
+  if (tokenA.ticker === 'RUNES' || tokenB.ticker === 'RUNES') {
+    return { isCompliant: true, warnings: [] };
+  }
+
+  const runesCoin = coins.find((c) => c.ticker === 'RUNES');
+  if (!runesCoin) {
+    return {
+      isCompliant: false,
+      warnings: [{ message: 'RUNES coin not found', isListItem: true }],
+    };
+  }
+
+  const tokensToCheck = [
+    { ticker: tokenA.ticker, coin: coins.find((c) => c.ticker === tokenA.ticker) },
+    { ticker: tokenB.ticker, coin: coins.find((c) => c.ticker === tokenB.ticker) },
+  ];
+
+  const warnings = [];
+
+  for (const { ticker, coin } of tokensToCheck) {
+    if (!coin) {
+      warnings.push({ message: `Token ${ticker} not found`, isListItem: true });
+      continue;
+    }
+
+    const runesPool = pools.find(
+      (p) => p.coinA.ticker === 'RUNES' && p.coinB.ticker === ticker
+    );
+    const requiredRunes = new BigNumber(coin.runesComplianceRequirement || '100000000000');
+    if (!runesPool || new BigNumber(runesPool.reserveA).isZero()) {
+      warnings.push({
+        message: `A RUNES/${ticker} pool with at least ${requiredRunes
+          .shiftedBy(-runesCoin.dp)
+          .dp(runesCoin.dp)
+          .toString()} RUNES liquidity is required`,
+        isListItem: true,
+      });
+      continue;
+    }
+
+    const actualRunes = new BigNumber(runesPool.reserveA);
+    if (actualRunes.lt(requiredRunes)) {
+      warnings.push({
+        message: `A RUNES/${ticker} pool with at least ${requiredRunes
+          .shiftedBy(-runesCoin.dp)
+          .dp(runesCoin.dp)
+          .toString()} RUNES liquidity is required`,
+        isListItem: true,
+      });
+    }
+  }
+
+  if (warnings.length > 0) {
+    warnings.push({
+      message: 'Pools are periodically checked, and non-compliant pools will be disabled for trading.',
+      isListItem: false,
+    });
+    return { isCompliant: false, warnings };
+  }
+
+  return { isCompliant: true, warnings: [] };
+}
+
+export function getPoolRatioFrontend(pool) {
+  if (!pool || !pool.reserveA || !pool.reserveB || !pool.coinA || !pool.coinB) {
+    return null;
+  }
+
+  const reserveABN = new BigNumber(pool.reserveA);
+  const reserveBBN = new BigNumber(pool.reserveB);
+  if (!reserveABN.isFinite() || !reserveBBN.isFinite() || reserveABN.isZero() || reserveBBN.isZero()) {
+    return null;
+  }
+
+  const reserveADecimal = reserveABN.shiftedBy(-pool.coinA.dp);
+  const reserveBDecimal = reserveBBN.shiftedBy(-pool.coinB.dp);
+  return reserveADecimal.div(reserveBDecimal);
+}
+
+export function estimateLiquidityFrontend({ coinA, coinB, amountA, amountB, pools, coins }) {
+  if ((amountA === null && amountB === null) || (amountA !== null && amountB !== null)) {
+    throw new Error('Provide either amountA or amountB, but not both or neither');
+  }
+  if (amountA !== null && new BigNumber(amountA).lte(0)) {
+    throw new Error(`${coinA.ticker} amount must be positive`);
+  }
+  if (amountB !== null && new BigNumber(amountB).lte(0)) {
+    throw new Error(`${coinB.ticker} amount must be positive`);
+  }
+
+  const { tokenA, tokenB, flipped } = normalizeTokenPairFrontend(coinA, coinB, pools);
+  let adjustedAmountA = amountA;
+  let adjustedAmountB = amountB;
+  if (flipped) {
+    adjustedAmountA = amountB;
+    adjustedAmountB = amountA;
+  }
+
+  const pool = pools.find(
+    (p) =>
+      (p.coinA.ticker === tokenA.ticker && p.coinB.ticker === tokenB.ticker) ||
+      (p.coinB.ticker === tokenA.ticker && p.coinA.ticker === coinB.ticker)
+  );
+
+  let amountAOut;
+  let amountBOut;
+
+  if (!pool || (new BigNumber(pool.reserveA).isZero() && new BigNumber(pool.reserveB).isZero())) {
+    if (adjustedAmountA === null || adjustedAmountB === null) {
+      return {
+        coinA: { ticker: tokenA.ticker, dp: tokenA.dp, projectName: tokenA.projectName },
+        coinB: { ticker: tokenB.ticker, dp: tokenB.dp, projectName: tokenB.projectName },
+        isPoolEmpty: true,
+        flipped,
+      };
+    }
+    amountAOut = new BigNumber(adjustedAmountA).decimalPlaces(tokenA.dp, BigNumber.ROUND_DOWN);
+    amountBOut = new BigNumber(adjustedAmountB).decimalPlaces(tokenB.dp, BigNumber.ROUND_DOWN);
+  } else {
+    const currentRatio = getPoolRatioFrontend(pool);
+    if (!currentRatio || currentRatio.isZero() || !currentRatio.isFinite()) {
+      throw new Error('Invalid pool ratio');
+    }
+    if (adjustedAmountA !== null) {
+      amountAOut = new BigNumber(adjustedAmountA).decimalPlaces(tokenA.dp, BigNumber.ROUND_DOWN);
+      amountBOut = amountAOut.div(currentRatio).decimalPlaces(tokenB.dp, BigNumber.ROUND_DOWN);
+    } else {
+      amountBOut = new BigNumber(adjustedAmountB).decimalPlaces(tokenB.dp, BigNumber.ROUND_DOWN);
+      amountAOut = amountBOut.times(currentRatio).decimalPlaces(tokenA.dp, BigNumber.ROUND_DOWN);
+    }
+  }
+
+  return {
+    amountA: amountAOut.toString(),
+    amountB: amountBOut.toString(),
+    coinA: { ticker: tokenA.ticker, dp: tokenA.dp, projectName: tokenA.projectName },
+    coinB: { ticker: tokenB.ticker, dp: tokenB.dp, projectName: tokenB.projectName },
+    isPoolEmpty: !pool || (new BigNumber(pool.reserveA).isZero() && new BigNumber(pool.reserveB).isZero()),
+    flipped,
+  };
+}
+
+export function calculateShareAmounts({ userShares, pools }) {
+  return userShares.map(share => {
+    const pool = pools.find(p => p.id === share.poolId);
+    if (!pool || !pool.totalShares || new BigNumber(pool.totalShares).isZero()) {
+      return {
+        ...share,
+        amountA: '0',
+        amountB: '0',
+        totalShares: '0',
+        reserveA: '0',
+        reserveB: '0',
+        coinA: { ticker: 'Unknown', dp: 0, projectName: 'Unknown' },
+        coinB: { ticker: 'Unknown', dp: 0, projectName: 'Unknown' },
+        pair: 'Unknown/Unknown',
+      };
+    }
+
+    const sharesBN = new BigNumber(share.shares);
+    const totalSharesBN = new BigNumber(pool.totalShares);
+    const reserveABN = new BigNumber(pool.reserveA);
+    const reserveBBN = new BigNumber(pool.reserveB);
+
+    const shareRatio = sharesBN.div(totalSharesBN);
+    const amountA = shareRatio.times(reserveABN).decimalPlaces(pool.coinA.dp, BigNumber.ROUND_DOWN).toString();
+    const amountB = shareRatio.times(reserveBBN).decimalPlaces(pool.coinB.dp, BigNumber.ROUND_DOWN).toString();
+
+    return {
+      ...share,
+      amountA,
+      amountB,
+      totalShares: pool.totalShares,
+      reserveA: pool.reserveA,
+      reserveB: pool.reserveB,
+      coinA: pool.coinA,
+      coinB: pool.coinB,
+      pair: `${pool.coinA.ticker}/${pool.coinB.ticker}`,
+    };
+  });
+}