@marinade.finance/kamino-sdk

import { PublicKey, Connection } from '@solana/web3.js'; import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars import * as borsh from '@project-serum/borsh'; // eslint-disable-line @typescript-eslint/no-unused-vars import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars import { PROGRAM_ID } from '../programId'; export interface PoolStateFields { /** Bump to identify PDA */ bump: number; ammConfig: PublicKey; owner: PublicKey; /** Token pair of the pool, where token_mint_0 address < token_mint_1 address */ tokenMint0: PublicKey; tokenMint1: PublicKey; /** Token pair vault */ tokenVault0: PublicKey; tokenVault1: PublicKey; /** observation account key */ observationKey: PublicKey; /** mint0 and mint1 decimals */ mintDecimals0: number; mintDecimals1: number; /** The minimum number of ticks between initialized ticks */ tickSpacing: number; /** The currently in range liquidity available to the pool. */ liquidity: BN; /** The current price of the pool as a sqrt(token_1/token_0) Q64.64 value */ sqrtPriceX64: BN; /** The current tick of the pool, i.e. according to the last tick transition that was run. */ tickCurrent: number; /** the most-recently updated index of the observations array */ observationIndex: number; observationUpdateDuration: number; /** * The fee growth as a Q64.64 number, i.e. fees of token_0 and token_1 collected per * unit of liquidity for the entire life of the pool. */ feeGrowthGlobal0X64: BN; feeGrowthGlobal1X64: BN; /** The amounts of token_0 and token_1 that are owed to the protocol. */ protocolFeesToken0: BN; protocolFeesToken1: BN; /** The amounts in and out of swap token_0 and token_1 */ swapInAmountToken0: BN; swapOutAmountToken1: BN; swapInAmountToken1: BN; swapOutAmountToken0: BN; /** * Bitwise representation of the state of the pool * bit0, 1: disable open position and increase liquidity, 0: normal * bit1, 1: disable decrease liquidity, 0: normal * bit2, 1: disable collect fee, 0: normal * bit3, 1: disable collect reward, 0: normal * bit4, 1: disable swap, 0: normal */ status: number; /** Leave blank for future use */ padding: Array<number>; rewardInfos: Array<types.RewardInfoFields>; /** Packed initialized tick array state */ tickArrayBitmap: Array<BN>; /** except protocol_fee and fund_fee */ totalFeesToken0: BN; /** except protocol_fee and fund_fee */ totalFeesClaimedToken0: BN; totalFeesToken1: BN; totalFeesClaimedToken1: BN; fundFeesToken0: BN; fundFeesToken1: BN; openTime: BN; padding1: Array<BN>; padding2: Array<BN>; } export interface PoolStateJSON { /** Bump to identify PDA */ bump: number; ammConfig: string; owner: string; /** Token pair of the pool, where token_mint_0 address < token_mint_1 address */ tokenMint0: string; tokenMint1: string; /** Token pair vault */ tokenVault0: string; tokenVault1: string; /** observation account key */ observationKey: string; /** mint0 and mint1 decimals */ mintDecimals0: number; mintDecimals1: number; /** The minimum number of ticks between initialized ticks */ tickSpacing: number; /** The currently in range liquidity available to the pool. */ liquidity: string; /** The current price of the pool as a sqrt(token_1/token_0) Q64.64 value */ sqrtPriceX64: string; /** The current tick of the pool, i.e. according to the last tick transition that was run. */ tickCurrent: number; /** the most-recently updated index of the observations array */ observationIndex: number; observationUpdateDuration: number; /** * The fee growth as a Q64.64 number, i.e. fees of token_0 and token_1 collected per * unit of liquidity for the entire life of the pool. */ feeGrowthGlobal0X64: string; feeGrowthGlobal1X64: string; /** The amounts of token_0 and token_1 that are owed to the protocol. */ protocolFeesToken0: string; protocolFeesToken1: string; /** The amounts in and out of swap token_0 and token_1 */ swapInAmountToken0: string; swapOutAmountToken1: string; swapInAmountToken1: string; swapOutAmountToken0: string; /** * Bitwise representation of the state of the pool * bit0, 1: disable open position and increase liquidity, 0: normal * bit1, 1: disable decrease liquidity, 0: normal * bit2, 1: disable collect fee, 0: normal * bit3, 1: disable collect reward, 0: normal * bit4, 1: disable swap, 0: normal */ status: number; /** Leave blank for future use */ padding: Array<number>; rewardInfos: Array<types.RewardInfoJSON>; /** Packed initialized tick array state */ tickArrayBitmap: Array<string>; /** except protocol_fee and fund_fee */ totalFeesToken0: string; /** except protocol_fee and fund_fee */ totalFeesClaimedToken0: string; totalFeesToken1: string; totalFeesClaimedToken1: string; fundFeesToken0: string; fundFeesToken1: string; openTime: string; padding1: Array<string>; padding2: Array<string>; } /** * The pool state * * PDA of `[POOL_SEED, config, token_mint_0, token_mint_1]` * */ export class PoolState { /** Bump to identify PDA */ readonly bump: number; readonly ammConfig: PublicKey; readonly owner: PublicKey; /** Token pair of the pool, where token_mint_0 address < token_mint_1 address */ readonly tokenMint0: PublicKey; readonly tokenMint1: PublicKey; /** Token pair vault */ readonly tokenVault0: PublicKey; readonly tokenVault1: PublicKey; /** observation account key */ readonly observationKey: PublicKey; /** mint0 and mint1 decimals */ readonly mintDecimals0: number; readonly mintDecimals1: number; /** The minimum number of ticks between initialized ticks */ readonly tickSpacing: number; /** The currently in range liquidity available to the pool. */ readonly liquidity: BN; /** The current price of the pool as a sqrt(token_1/token_0) Q64.64 value */ readonly sqrtPriceX64: BN; /** The current tick of the pool, i.e. according to the last tick transition that was run. */ readonly tickCurrent: number; /** the most-recently updated index of the observations array */ readonly observationIndex: number; readonly observationUpdateDuration: number; /** * The fee growth as a Q64.64 number, i.e. fees of token_0 and token_1 collected per * unit of liquidity for the entire life of the pool. */ readonly feeGrowthGlobal0X64: BN; readonly feeGrowthGlobal1X64: BN; /** The amounts of token_0 and token_1 that are owed to the protocol. */ readonly protocolFeesToken0: BN; readonly protocolFeesToken1: BN; /** The amounts in and out of swap token_0 and token_1 */ readonly swapInAmountToken0: BN; readonly swapOutAmountToken1: BN; readonly swapInAmountToken1: BN; readonly swapOutAmountToken0: BN; /** * Bitwise representation of the state of the pool * bit0, 1: disable open position and increase liquidity, 0: normal * bit1, 1: disable decrease liquidity, 0: normal * bit2, 1: disable collect fee, 0: normal * bit3, 1: disable collect reward, 0: normal * bit4, 1: disable swap, 0: normal */ readonly status: number; /** Leave blank for future use */ readonly padding: Array<number>; readonly rewardInfos: Array<types.RewardInfo>; /** Packed initialized tick array state */ readonly tickArrayBitmap: Array<BN>; /** except protocol_fee and fund_fee */ readonly totalFeesToken0: BN; /** except protocol_fee and fund_fee */ readonly totalFeesClaimedToken0: BN; readonly totalFeesToken1: BN; readonly totalFeesClaimedToken1: BN; readonly fundFeesToken0: BN; readonly fundFeesToken1: BN; readonly openTime: BN; readonly padding1: Array<BN>; readonly padding2: Array<BN>; static readonly discriminator = Buffer.from([247, 237, 227, 245, 215, 195, 222, 70]); static readonly layout = borsh.struct([ borsh.u8('bump'), borsh.publicKey('ammConfig'), borsh.publicKey('owner'), borsh.publicKey('tokenMint0'), borsh.publicKey('tokenMint1'), borsh.publicKey('tokenVault0'), borsh.publicKey('tokenVault1'), borsh.publicKey('observationKey'), borsh.u8('mintDecimals0'), borsh.u8('mintDecimals1'), borsh.u16('tickSpacing'), borsh.u128('liquidity'), borsh.u128('sqrtPriceX64'), borsh.i32('tickCurrent'), borsh.u16('observationIndex'), borsh.u16('observationUpdateDuration'), borsh.u128('feeGrowthGlobal0X64'), borsh.u128('feeGrowthGlobal1X64'), borsh.u64('protocolFeesToken0'), borsh.u64('protocolFeesToken1'), borsh.u128('swapInAmountToken0'), borsh.u128('swapOutAmountToken1'), borsh.u128('swapInAmountToken1'), borsh.u128('swapOutAmountToken0'), borsh.u8('status'), borsh.array(borsh.u8(), 7, 'padding'), borsh.array(types.RewardInfo.layout(), 3, 'rewardInfos'), borsh.array(borsh.u64(), 16, 'tickArrayBitmap'), borsh.u64('totalFeesToken0'), borsh.u64('totalFeesClaimedToken0'), borsh.u64('totalFeesToken1'), borsh.u64('totalFeesClaimedToken1'), borsh.u64('fundFeesToken0'), borsh.u64('fundFeesToken1'), borsh.u64('openTime'), borsh.array(borsh.u64(), 25, 'padding1'), borsh.array(borsh.u64(), 32, 'padding2'), ]); constructor(fields: PoolStateFields) { this.bump = fields.bump; this.ammConfig = fields.ammConfig; this.owner = fields.owner; this.tokenMint0 = fields.tokenMint0; this.tokenMint1 = fields.tokenMint1; this.tokenVault0 = fields.tokenVault0; this.tokenVault1 = fields.tokenVault1; this.observationKey = fields.observationKey; this.mintDecimals0 = fields.mintDecimals0; this.mintDecimals1 = fields.mintDecimals1; this.tickSpacing = fields.tickSpacing; this.liquidity = fields.liquidity; this.sqrtPriceX64 = fields.sqrtPriceX64; this.tickCurrent = fields.tickCurrent; this.observationIndex = fields.observationIndex; this.observationUpdateDuration = fields.observationUpdateDuration; this.feeGrowthGlobal0X64 = fields.feeGrowthGlobal0X64; this.feeGrowthGlobal1X64 = fields.feeGrowthGlobal1X64; this.protocolFeesToken0 = fields.protocolFeesToken0; this.protocolFeesToken1 = fields.protocolFeesToken1; this.swapInAmountToken0 = fields.swapInAmountToken0; this.swapOutAmountToken1 = fields.swapOutAmountToken1; this.swapInAmountToken1 = fields.swapInAmountToken1; this.swapOutAmountToken0 = fields.swapOutAmountToken0; this.status = fields.status; this.padding = fields.padding; this.rewardInfos = fields.rewardInfos.map((item) => new types.RewardInfo({ ...item })); this.tickArrayBitmap = fields.tickArrayBitmap; this.totalFeesToken0 = fields.totalFeesToken0; this.totalFeesClaimedToken0 = fields.totalFeesClaimedToken0; this.totalFeesToken1 = fields.totalFeesToken1; this.totalFeesClaimedToken1 = fields.totalFeesClaimedToken1; this.fundFeesToken0 = fields.fundFeesToken0; this.fundFeesToken1 = fields.fundFeesToken1; this.openTime = fields.openTime; this.padding1 = fields.padding1; this.padding2 = fields.padding2; } static async fetch(c: Connection, address: PublicKey): Promise<PoolState | null> { const info = await c.getAccountInfo(address); if (info === null) { return null; } if (!info.owner.equals(PROGRAM_ID)) { throw new Error("account doesn't belong to this program"); } return this.decode(info.data); } static async fetchMultiple(c: Connection, addresses: PublicKey[]): Promise<Array<PoolState | null>> { const infos = await c.getMultipleAccountsInfo(addresses); return infos.map((info) => { if (info === null) { return null; } if (!info.owner.equals(PROGRAM_ID)) { throw new Error("account doesn't belong to this program"); } return this.decode(info.data); }); } static decode(data: Buffer): PoolState { if (!data.slice(0, 8).equals(PoolState.discriminator)) { throw new Error('invalid account discriminator'); } const dec = PoolState.layout.decode(data.slice(8)); return new PoolState({ bump: dec.bump, ammConfig: dec.ammConfig, owner: dec.owner, tokenMint0: dec.tokenMint0, tokenMint1: dec.tokenMint1, tokenVault0: dec.tokenVault0, tokenVault1: dec.tokenVault1, observationKey: dec.observationKey, mintDecimals0: dec.mintDecimals0, mintDecimals1: dec.mintDecimals1, tickSpacing: dec.tickSpacing, liquidity: dec.liquidity, sqrtPriceX64: dec.sqrtPriceX64, tickCurrent: dec.tickCurrent, observationIndex: dec.observationIndex, observationUpdateDuration: dec.observationUpdateDuration, feeGrowthGlobal0X64: dec.feeGrowthGlobal0X64, feeGrowthGlobal1X64: dec.feeGrowthGlobal1X64, protocolFeesToken0: dec.protocolFeesToken0, protocolFeesToken1: dec.protocolFeesToken1, swapInAmountToken0: dec.swapInAmountToken0, swapOutAmountToken1: dec.swapOutAmountToken1, swapInAmountToken1: dec.swapInAmountToken1, swapOutAmountToken0: dec.swapOutAmountToken0, status: dec.status, padding: dec.padding, rewardInfos: dec.rewardInfos.map((item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.RewardInfo.fromDecoded(item) ), tickArrayBitmap: dec.tickArrayBitmap, totalFeesToken0: dec.totalFeesToken0, totalFeesClaimedToken0: dec.totalFeesClaimedToken0, totalFeesToken1: dec.totalFeesToken1, totalFeesClaimedToken1: dec.totalFeesClaimedToken1, fundFeesToken0: dec.fundFeesToken0, fundFeesToken1: dec.fundFeesToken1, openTime: dec.openTime, padding1: dec.padding1, padding2: dec.padding2, }); } toJSON(): PoolStateJSON { return { bump: this.bump, ammConfig: this.ammConfig.toString(), owner: this.owner.toString(), tokenMint0: this.tokenMint0.toString(), tokenMint1: this.tokenMint1.toString(), tokenVault0: this.tokenVault0.toString(), tokenVault1: this.tokenVault1.toString(), observationKey: this.observationKey.toString(), mintDecimals0: this.mintDecimals0, mintDecimals1: this.mintDecimals1, tickSpacing: this.tickSpacing, liquidity: this.liquidity.toString(), sqrtPriceX64: this.sqrtPriceX64.toString(), tickCurrent: this.tickCurrent, observationIndex: this.observationIndex, observationUpdateDuration: this.observationUpdateDuration, feeGrowthGlobal0X64: this.feeGrowthGlobal0X64.toString(), feeGrowthGlobal1X64: this.feeGrowthGlobal1X64.toString(), protocolFeesToken0: this.protocolFeesToken0.toString(), protocolFeesToken1: this.protocolFeesToken1.toString(), swapInAmountToken0: this.swapInAmountToken0.toString(), swapOutAmountToken1: this.swapOutAmountToken1.toString(), swapInAmountToken1: this.swapInAmountToken1.toString(), swapOutAmountToken0: this.swapOutAmountToken0.toString(), status: this.status, padding: this.padding, rewardInfos: this.rewardInfos.map((item) => item.toJSON()), tickArrayBitmap: this.tickArrayBitmap.map((item) => item.toString()), totalFeesToken0: this.totalFeesToken0.toString(), totalFeesClaimedToken0: this.totalFeesClaimedToken0.toString(), totalFeesToken1: this.totalFeesToken1.toString(), totalFeesClaimedToken1: this.totalFeesClaimedToken1.toString(), fundFeesToken0: this.fundFeesToken0.toString(), fundFeesToken1: this.fundFeesToken1.toString(), openTime: this.openTime.toString(), padding1: this.padding1.map((item) => item.toString()), padding2: this.padding2.map((item) => item.toString()), }; } static fromJSON(obj: PoolStateJSON): PoolState { return new PoolState({ bump: obj.bump, ammConfig: new PublicKey(obj.ammConfig), owner: new PublicKey(obj.owner), tokenMint0: new PublicKey(obj.tokenMint0), tokenMint1: new PublicKey(obj.tokenMint1), tokenVault0: new PublicKey(obj.tokenVault0), tokenVault1: new PublicKey(obj.tokenVault1), observationKey: new PublicKey(obj.observationKey), mintDecimals0: obj.mintDecimals0, mintDecimals1: obj.mintDecimals1, tickSpacing: obj.tickSpacing, liquidity: new BN(obj.liquidity), sqrtPriceX64: new BN(obj.sqrtPriceX64), tickCurrent: obj.tickCurrent, observationIndex: obj.observationIndex, observationUpdateDuration: obj.observationUpdateDuration, feeGrowthGlobal0X64: new BN(obj.feeGrowthGlobal0X64), feeGrowthGlobal1X64: new BN(obj.feeGrowthGlobal1X64), protocolFeesToken0: new BN(obj.protocolFeesToken0), protocolFeesToken1: new BN(obj.protocolFeesToken1), swapInAmountToken0: new BN(obj.swapInAmountToken0), swapOutAmountToken1: new BN(obj.swapOutAmountToken1), swapInAmountToken1: new BN(obj.swapInAmountToken1), swapOutAmountToken0: new BN(obj.swapOutAmountToken0), status: obj.status, padding: obj.padding, rewardInfos: obj.rewardInfos.map((item) => types.RewardInfo.fromJSON(item)), tickArrayBitmap: obj.tickArrayBitmap.map((item) => new BN(item)), totalFeesToken0: new BN(obj.totalFeesToken0), totalFeesClaimedToken0: new BN(obj.totalFeesClaimedToken0), totalFeesToken1: new BN(obj.totalFeesToken1), totalFeesClaimedToken1: new BN(obj.totalFeesClaimedToken1), fundFeesToken0: new BN(obj.fundFeesToken0), fundFeesToken1: new BN(obj.fundFeesToken1), openTime: new BN(obj.openTime), padding1: obj.padding1.map((item) => new BN(item)), padding2: obj.padding2.map((item) => new BN(item)), }); } }