Querying DEX Pool Reserves

const MINSWAP_V2_ADDRESS = 'addr1z84q0denmyep98ph3tmzwsmw0j7zau9ljmsqx6a4rvaau66j2c79gy9l76sdg0xwhd7r0c0kna0tycz4y5s6mlenh8pq777e2a';
const MIN_POLICY = '29d222ce763455e3d7a09a665ce554f00ac89d2e99a1a83d267170c6';

async function getMinAdaPool() {
const response = await fetch('https://api.nacho.builders/v1/ogmios', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'apikey': process.env.NACHO_API_KEY
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'queryLedgerState/utxo',
    params: {
      addresses: [MINSWAP_V2_ADDRESS],
      assets: [{ policyId: MIN_POLICY }]  // Server-side filter!
    },
    id: 1
  })
});

const { result: utxos } = await response.json();

if (utxos.length === 0) {
  throw new Error('MIN/ADA pool not found');
}

const pool = utxos[0];
const adaReserve = pool.value.ada.lovelace;
const minReserve = Object.values(pool.value[MIN_POLICY])[0];
const price = (adaReserve / 1e6) / (minReserve / 1e6);

return {
  txHash: pool.transaction.id,
  index: pool.index,
  adaReserve,
  minReserve,
  price
};
}

// Usage - instant response from prewarmed cache
const pool = await getMinAdaPool();
console.log(`MIN/ADA price: ${pool.price.toFixed(8)} ADA per MIN`);

const MINSWAP_V2_ADDRESS = 'addr1z84q0denmyep98ph3tmzwsmw0j7zau9ljmsqx6a4rvaau66j2c79gy9l76sdg0xwhd7r0c0kna0tycz4y5s6mlenh8pq777e2a';
const LP_POLICY = 'f5808c2c990d86da54bfc97d89cee6efa20cd8461616359478d96b4c';

async function getMinswapPools() {
const query = `
  query MinswapPools($address: String!) {
    tx_out(
      where: { address: { _eq: $address } }
      order_by: { id: desc }
      limit: 100
    ) {
      id
      value
      multi_assets {
        quantity
        asset {
          policy
          name
          fingerprint
        }
      }
    }
  }
`;

const response = await fetch('https://api.nacho.builders/v1/graphql', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'apikey': process.env.NACHO_API_KEY
  },
  body: JSON.stringify({
    query,
    variables: { address: MINSWAP_V2_ADDRESS }
  })
});

const { data } = await response.json();
return parsePoolOutputs(data.tx_out);
}

function parsePoolOutputs(outputs) {
const pools = new Map();

for (const output of outputs) {
  const adaAmount = BigInt(output.value);
  const tokens = [];

  for (const ma of output.multi_assets || []) {
    const policy = ma.asset.policy.replace('\\x', '');
    const name = ma.asset.name.replace('\\x', '');

    // Skip LP tokens
    if (policy === LP_POLICY) continue;

    tokens.push({
      policy,
      name,
      quantity: BigInt(ma.quantity),
      ticker: decodeAssetName(name)
    });
  }

  if (tokens.length === 1) {
    const token = tokens[0];
    const poolKey = token.policy + token.name;

    // Keep most recent output per token pair
    if (!pools.has(poolKey)) {
      pools.set(poolKey, {
        adaReserve: adaAmount,
        tokenReserve: token.quantity,
        tokenTicker: token.ticker,
        price: Number(adaAmount) / 1e6 / (Number(token.quantity) / 1e6)
      });
    }
  }
}

return Array.from(pools.values())
  .sort((a, b) => Number(b.adaReserve - a.adaReserve));
}

function decodeAssetName(hex) {
try {
  const decoded = Buffer.from(hex, 'hex').toString('utf8');
  return /^[a-zA-Z0-9]+$/.test(decoded) ? decoded : hex.slice(0, 8);
} catch {
  return hex.slice(0, 8);
}
}

// Usage
const pools = await getMinswapPools();
pools.slice(0, 10).forEach(pool => {
console.log(`ADA/${pool.tokenTicker}: 1 ${pool.tokenTicker} = ${pool.price.toFixed(6)} ADA`);
});

const MINSWAP_V2_ADDRESS = 'addr1z84q0denmyep98ph3tmzwsmw0j7zau9ljmsqx6a4rvaau66j2c79gy9l76sdg0xwhd7r0c0kna0tycz4y5s6mlenh8pq777e2a';
const LP_POLICY = 'f5808c2c990d86da54bfc97d89cee6efa20cd8461616359478d96b4c';

async function getMinswapPoolsRealtime() {
const response = await fetch('https://api.nacho.builders/v1/ogmios', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'apikey': process.env.NACHO_API_KEY
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'queryLedgerState/utxo',
    params: { addresses: [MINSWAP_V2_ADDRESS] },
    id: 1
  })
});

const { result: utxos } = await response.json();
return parsePoolUtxos(utxos);
}

function parsePoolUtxos(utxos) {
const pools = [];

for (const utxo of utxos) {
  const txHash = utxo.transaction.id;
  const index = utxo.index;
  const adaAmount = BigInt(utxo.value.ada.lovelace);

  const tokens = [];
  for (const [policyId, assets] of Object.entries(utxo.value)) {
    if (policyId === 'ada') continue;
    if (policyId === LP_POLICY) continue; // Skip LP tokens

    for (const [assetName, quantity] of Object.entries(assets)) {
      tokens.push({
        policyId,
        assetName,
        quantity: BigInt(quantity),
        ticker: decodeAssetName(assetName)
      });
    }
  }

  if (tokens.length === 1) {
    const token = tokens[0];
    pools.push({
      txHash,
      index,
      adaReserve: adaAmount,
      tokenReserve: token.quantity,
      tokenTicker: token.ticker,
      price: Number(adaAmount) / 1e6 / (Number(token.quantity) / 1e6)
    });
  }
}

return pools.sort((a, b) => Number(b.adaReserve - a.adaReserve));
}

// Usage
console.log('Querying pools (this may take 30-60 seconds)...');
const pools = await getMinswapPoolsRealtime();
console.log(`Found ${pools.length} pools`);

pools.slice(0, 10).forEach(pool => {
console.log(`ADA/${pool.tokenTicker}: ${pool.price.toFixed(6)} ADA`);
});