@kamino-finance/kliquidity-sdk
Version:
Typescript SDK for interacting with the Kamino Liquidity (kliquidity) protocol
222 lines • 10.9 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RaydiumService = void 0;
const accounts_1 = require("../@codegen/raydium/accounts");
const decimal_js_1 = __importDefault(require("decimal.js"));
const utils_1 = require("../utils");
const axios_1 = __importDefault(require("axios"));
const CreationParameters_1 = require("../utils/CreationParameters");
const programId_1 = require("../@codegen/raydium/programId");
const raydium_1 = require("../utils/raydium");
const lib_1 = require("@raydium-io/raydium-sdk-v2/lib");
class RaydiumService {
_rpc;
_legacyConnection;
_raydiumProgramId;
constructor(rpc, legacyConnection, raydiumProgramId = programId_1.PROGRAM_ID) {
this._rpc = rpc;
this._legacyConnection = legacyConnection;
this._raydiumProgramId = raydiumProgramId;
}
getRaydiumProgramId() {
return this._raydiumProgramId;
}
async getRaydiumWhirlpools() {
return (await axios_1.default.get(`https://api.kamino.finance/v2/raydium/ammPools`)).data;
}
async getRaydiumPoolInfo(poolPubkey) {
const raydiumLoadParams = { connection: this._legacyConnection };
const raydium = await lib_1.Raydium.load(raydiumLoadParams);
const rayClmm = new lib_1.Clmm({ scope: raydium, moduleName: '' });
const otherPoolInfo = await rayClmm.getPoolInfoFromRpc(poolPubkey.toString());
console.log('otherPoolInfo', otherPoolInfo);
return otherPoolInfo.poolInfo;
}
async getRaydiumPoolLiquidityDistribution(pool, keepOrder = true, lowestTick, highestTick) {
const raydiumLiqDistribution = (await axios_1.default.get(`https://api.kamino.finance/v2/raydium/positionLine/${pool.toString()}`)).data;
const poolState = await accounts_1.PoolState.fetch(this._rpc, pool);
if (!poolState) {
throw Error(`Raydium pool state ${pool} does not exist`);
}
const poolPrice = lib_1.SqrtPriceMath.sqrtPriceX64ToPrice(poolState.sqrtPriceX64, poolState.mintDecimals0, poolState.mintDecimals1);
const liqDistribution = {
currentPrice: poolPrice,
currentTickIndex: poolState.tickCurrent,
distribution: [],
};
raydiumLiqDistribution.data.forEach((entry) => {
const tickIndex = (0, raydium_1.priceToTickIndexWithRounding)(entry.price);
if ((lowestTick && tickIndex < lowestTick) || (highestTick && tickIndex > highestTick)) {
return;
}
// if the prevoious entry has the same tick index, add to it
if (liqDistribution.distribution.length > 0 &&
liqDistribution.distribution[liqDistribution.distribution.length - 1].tickIndex === tickIndex) {
liqDistribution.distribution[liqDistribution.distribution.length - 1].liquidity = liqDistribution.distribution[liqDistribution.distribution.length - 1].liquidity.add(new decimal_js_1.default(entry.liquidity));
}
else {
let priceWithOrder = new decimal_js_1.default(entry.price);
if (!keepOrder) {
priceWithOrder = new decimal_js_1.default(1).div(priceWithOrder);
}
const liq = {
price: new decimal_js_1.default(priceWithOrder),
liquidity: new decimal_js_1.default(entry.liquidity),
tickIndex,
};
liqDistribution.distribution.push(liq);
}
});
return liqDistribution;
}
getStrategyWhirlpoolPoolAprApy = async (strategy, pools) => {
const position = await accounts_1.PersonalPositionState.fetch(this._rpc, strategy.position);
if (!position) {
throw Error(`Position ${strategy.position} does not exist`);
}
const poolState = await accounts_1.PoolState.fetch(this._rpc, strategy.pool);
if (!poolState) {
throw Error(`Raydium pool state ${strategy.pool} does not exist`);
}
if (!pools) {
({ data: pools } = await this.getRaydiumWhirlpools());
}
if (!pools || pools.length === 0) {
throw Error(`Could not get Raydium amm pools from Raydium API`);
}
const raydiumPool = pools.filter((d) => d.id === position.poolId.toString()).shift();
if (!raydiumPool) {
throw Error(`Could not get find Raydium amm pool ${strategy.pool} from Raydium API`);
}
const priceRange = (0, utils_1.getStrategyPriceRangeRaydium)(position.tickLowerIndex, position.tickUpperIndex, Number(poolState.tickCurrent.toString()), Number(strategy.tokenAMintDecimals.toString()), Number(strategy.tokenBMintDecimals.toString()));
if (priceRange.strategyOutOfRange) {
return {
...priceRange,
rewardsApy: [],
rewardsApr: [],
feeApy: utils_1.ZERO,
feeApr: utils_1.ZERO,
totalApy: utils_1.ZERO,
totalApr: utils_1.ZERO,
};
}
const raydiumPoolInfo = await this.getRaydiumPoolInfo(strategy.pool);
console.log('raydiumPoolInfo', raydiumPoolInfo);
const params = {
poolInfo: raydiumPoolInfo,
aprType: 'day',
positionTickLowerIndex: position.tickLowerIndex,
positionTickUpperIndex: position.tickUpperIndex,
};
const { apr, feeApr, rewardsApr } = lib_1.PoolUtils.estimateAprsForPriceRangeMultiplier(params);
const totalApr = new decimal_js_1.default(apr).div(100);
const fee = new decimal_js_1.default(feeApr).div(100);
const rewards = rewardsApr.map((reward) => new decimal_js_1.default(reward).div(100));
return {
totalApr,
totalApy: (0, utils_1.aprToApy)(totalApr, 365),
feeApr: fee,
feeApy: (0, utils_1.aprToApy)(fee, 365),
rewardsApr: rewards,
rewardsApy: rewards.map((x) => (0, utils_1.aprToApy)(x, 365)),
...priceRange,
};
};
getRaydiumPositionAprApy = async (poolPubkey, priceLower, priceUpper, pools) => {
const poolState = await accounts_1.PoolState.fetch(this._rpc, poolPubkey);
if (!poolState) {
throw Error(`Raydium pool state ${poolPubkey} does not exist`);
}
if (!pools) {
({ data: pools } = await this.getRaydiumWhirlpools());
}
if (!pools || pools.length === 0) {
throw Error(`Could not get Raydium amm pools from Raydium API`);
}
const raydiumPool = pools.filter((d) => d.id === poolPubkey.toString()).shift();
if (!raydiumPool) {
throw Error(`Could not get find Raydium amm pool ${poolPubkey.toString()} from Raydium API`);
}
const tickLowerIndex = lib_1.TickMath.getTickWithPriceAndTickspacing(priceLower, poolState.tickSpacing, poolState.mintDecimals0, poolState.mintDecimals1);
const tickUpperIndex = lib_1.TickMath.getTickWithPriceAndTickspacing(priceUpper, poolState.tickSpacing, poolState.mintDecimals0, poolState.mintDecimals1);
const priceRange = (0, utils_1.getStrategyPriceRangeRaydium)(tickLowerIndex, tickUpperIndex, Number(poolState.tickCurrent.toString()), raydiumPool.mintDecimalsA, raydiumPool.mintDecimalsB);
if (priceRange.strategyOutOfRange) {
return {
...priceRange,
rewardsApy: [],
rewardsApr: [],
feeApy: utils_1.ZERO,
feeApr: utils_1.ZERO,
totalApy: utils_1.ZERO,
totalApr: utils_1.ZERO,
};
}
const poolInfo = await this.getRaydiumPoolInfo(poolPubkey);
const params = {
poolInfo,
aprType: 'day',
positionTickLowerIndex: tickLowerIndex,
positionTickUpperIndex: tickUpperIndex,
};
const { apr, feeApr, rewardsApr } = lib_1.PoolUtils.estimateAprsForPriceRangeMultiplier(params);
const totalApr = new decimal_js_1.default(apr).div(100);
const fee = new decimal_js_1.default(feeApr).div(100);
const rewards = rewardsApr.map((reward) => new decimal_js_1.default(reward).div(100));
return {
totalApr,
totalApy: (0, utils_1.aprToApy)(totalApr, 365),
feeApr: fee,
feeApy: (0, utils_1.aprToApy)(fee, 365),
rewardsApr: rewards,
rewardsApy: rewards.map((x) => (0, utils_1.aprToApy)(x, 365)),
...priceRange,
};
};
async getGenericPoolInfo(poolPubkey, pools) {
const poolState = await accounts_1.PoolState.fetch(this._rpc, poolPubkey);
if (!poolState) {
throw Error(`Raydium pool state ${poolPubkey} does not exist`);
}
if (!pools) {
({ data: pools } = await this.getRaydiumWhirlpools());
}
if (!pools || pools.length === 0) {
throw Error(`Could not get Raydium amm pools from Raydium API`);
}
const raydiumPool = pools.filter((d) => d.id === poolPubkey.toString()).shift();
if (!raydiumPool) {
throw Error(`Could not get find Raydium amm pool ${poolPubkey.toString()} from Raydium API`);
}
const poolInfo = {
dex: 'RAYDIUM',
address: poolPubkey,
tokenMintA: poolState.tokenMint0,
tokenMintB: poolState.tokenMint1,
price: new decimal_js_1.default(raydiumPool.price),
feeRate: new decimal_js_1.default(raydiumPool.ammConfig.tradeFeeRate).div(new decimal_js_1.default(CreationParameters_1.FullPercentage)),
volumeOnLast7d: new decimal_js_1.default(raydiumPool.week.volume),
tvl: new decimal_js_1.default(raydiumPool.tvl),
tickSpacing: new decimal_js_1.default(raydiumPool.ammConfig.tickSpacing),
// todo(Silviu): get real amount of positions
positions: new decimal_js_1.default(0),
};
return poolInfo;
}
async getPositionsCountByPool(pool) {
const positions = await this._rpc
.getProgramAccounts(this._raydiumProgramId, {
commitment: 'confirmed',
filters: [
{ dataSize: BigInt(lib_1.PositionInfoLayout.span) },
{ memcmp: { bytes: pool, offset: BigInt(lib_1.PositionInfoLayout.offsetOf('poolId')), encoding: 'base58' } },
],
})
.send();
return positions.length;
}
}
exports.RaydiumService = RaydiumService;
//# sourceMappingURL=RaydiumService.js.map