# Get Pool Burn Percentage

The best way to check if a token is trying to rug your or not is to see how much <mark style="color:yellow;">liquidity</mark> is locked inside the token's pool. Whenever liquidity is added to a pool on Raydium, <mark style="color:yellow;">lpMint</mark> tokens are minted to the liquidity provider.

If anyone wants to remove the liquidity, they need the orginal minted <mark style="color:yellow;">lpMint</mark> tokens. If those lpMint tokens are <mark style="color:yellow;">burnt</mark>, then it means the liquidity is locked inside the pool and cannot be withdrawn. We can see how easy it is to fetch this info with GraphQL APIs and RPC calls.

```typescript
import { gql, GraphQLClient } from "graphql-request";
import * as solana from '@solana/web3.js';

const gqlEndpoint = `https://programs.shyft.to/v0/graphql/?api_key=YOUR-KEY`;
const rpcEndpoint = `https://rpc.shyft.to/?api_key=YOUR-KEY`

const graphQLClient = new GraphQLClient(gqlEndpoint, {
  method: `POST`,
  jsonSerializer: {
    parse: JSON.parse,
    stringify: JSON.stringify,
  },
});

const connection = new solana.Connection(rpcEndpoint);

async function queryLpMintInfo(address: string) {
  // See how we are only querying what we need
  const query = gql`
    query MyQuery ($where: Raydium_LiquidityPoolv4_bool_exp) {
  Raydium_LiquidityPoolv4(
    where: $where
  ) {
    baseMint
    lpMint
    lpReserve
  }
}`;

  const variables = {
    where: {
      pubkey: {
        _eq: address,
      },
    },
  };

  return await graphQLClient.request(query, variables);
}

/*
This is taken from Raydium's FE code
https://github.com/raydium-io/raydium-frontend/blob/572e4973656e899d04e30bfad1f528efbf79f975/src/pages/liquidity/add.tsx#L646
*/
function getBurnPercentage(lpReserve: number, actualSupply: number): number {
  const maxLpSupply = Math.max(actualSupply, (lpReserve - 1));
  const burnAmt = (maxLpSupply - actualSupply)
  console.log(`burn amt: ${burnAmt}`)
  return (burnAmt / maxLpSupply) * 100;
}

//This is Jup-Sol pool addres
const info = await queryLpMintInfo("7RJ5qmsgmvUKK5QtCLT9qHpQMegkiULppHRBNuWso12E");
const lpMint = info.Raydium_LiquidityPoolv4[0].lpMint


//Once we have the lpMint address, we need to fetch the current token supply and decimals
const parsedAccInfo = await connection.getParsedAccountInfo(new solana.PublicKey(lpMint));
const mintInfo = parsedAccInfo?.value?.data?.parsed?.info

//We divide the values based on the mint decimals
const lpReserve = info.Raydium_LiquidityPoolv4[0].lpReserve / Math.pow(10, mintInfo?.decimals)
const actualSupply = mintInfo?.supply / Math.pow(10, mintInfo?.decimals)
console.log(`lpMint: ${lpMint}, Reserve: ${lpReserve}, Actual Supply: ${actualSupply}`);

//Calculate burn percentage
const burnPct = getBurnPercentage(lpReserve, actualSupply)
console.log(`${burnPct} LP burned`);


```

In order to find LP burned for a token, instead of fetching by pool's <mark style="color:yellow;">pubkey</mark> you can fetch pools by <mark style="color:yellow;">baseMint,</mark> and then follow the above outlined approach.

[get-pools-by-token-address](https://docs.shyft.to/solana-indexers/case-studies/raydium/get-pools-by-token-address "mention")