@kamino-finance/kliquidity-sdk 6.2.2 → 6.3.0

package/src/raydium_client/accounts/AmmConfig.ts

@@ -0,0 +1,161 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/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 AmmConfigFields {
+  bump: number
+  index: number
+  owner: PublicKey
+  protocolFeeRate: number
+  tradeFeeRate: number
+  tickSpacing: number
+  fundFeeRate: number
+  paddingU32: number
+  fundOwner: PublicKey
+  padding: Array<BN>
+}
+
+export interface AmmConfigJSON {
+  bump: number
+  index: number
+  owner: string
+  protocolFeeRate: number
+  tradeFeeRate: number
+  tickSpacing: number
+  fundFeeRate: number
+  paddingU32: number
+  fundOwner: string
+  padding: Array<string>
+}
+
+export class AmmConfig {
+  readonly bump: number
+  readonly index: number
+  readonly owner: PublicKey
+  readonly protocolFeeRate: number
+  readonly tradeFeeRate: number
+  readonly tickSpacing: number
+  readonly fundFeeRate: number
+  readonly paddingU32: number
+  readonly fundOwner: PublicKey
+  readonly padding: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    218, 244, 33, 104, 203, 203, 43, 111,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u8("bump"),
+    borsh.u16("index"),
+    borsh.publicKey("owner"),
+    borsh.u32("protocolFeeRate"),
+    borsh.u32("tradeFeeRate"),
+    borsh.u16("tickSpacing"),
+    borsh.u32("fundFeeRate"),
+    borsh.u32("paddingU32"),
+    borsh.publicKey("fundOwner"),
+    borsh.array(borsh.u64(), 3, "padding"),
+  ])
+
+  constructor(fields: AmmConfigFields) {
+    this.bump = fields.bump
+    this.index = fields.index
+    this.owner = fields.owner
+    this.protocolFeeRate = fields.protocolFeeRate
+    this.tradeFeeRate = fields.tradeFeeRate
+    this.tickSpacing = fields.tickSpacing
+    this.fundFeeRate = fields.fundFeeRate
+    this.paddingU32 = fields.paddingU32
+    this.fundOwner = fields.fundOwner
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<AmmConfig | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<AmmConfig | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): AmmConfig {
+    if (!data.slice(0, 8).equals(AmmConfig.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = AmmConfig.layout.decode(data.slice(8))
+
+    return new AmmConfig({
+      bump: dec.bump,
+      index: dec.index,
+      owner: dec.owner,
+      protocolFeeRate: dec.protocolFeeRate,
+      tradeFeeRate: dec.tradeFeeRate,
+      tickSpacing: dec.tickSpacing,
+      fundFeeRate: dec.fundFeeRate,
+      paddingU32: dec.paddingU32,
+      fundOwner: dec.fundOwner,
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): AmmConfigJSON {
+    return {
+      bump: this.bump,
+      index: this.index,
+      owner: this.owner.toString(),
+      protocolFeeRate: this.protocolFeeRate,
+      tradeFeeRate: this.tradeFeeRate,
+      tickSpacing: this.tickSpacing,
+      fundFeeRate: this.fundFeeRate,
+      paddingU32: this.paddingU32,
+      fundOwner: this.fundOwner.toString(),
+      padding: this.padding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: AmmConfigJSON): AmmConfig {
+    return new AmmConfig({
+      bump: obj.bump,
+      index: obj.index,
+      owner: new PublicKey(obj.owner),
+      protocolFeeRate: obj.protocolFeeRate,
+      tradeFeeRate: obj.tradeFeeRate,
+      tickSpacing: obj.tickSpacing,
+      fundFeeRate: obj.fundFeeRate,
+      paddingU32: obj.paddingU32,
+      fundOwner: new PublicKey(obj.fundOwner),
+      padding: obj.padding.map((item) => new BN(item)),
+    })
+  }
+}

package/src/raydium_client/accounts/ObservationState.ts

@@ -0,0 +1,121 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/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 ObservationStateFields {
+  initialized: boolean
+  poolId: PublicKey
+  observations: Array<types.ObservationFields>
+  padding: Array<BN>
+}
+
+export interface ObservationStateJSON {
+  initialized: boolean
+  poolId: string
+  observations: Array<types.ObservationJSON>
+  padding: Array<string>
+}
+
+export class ObservationState {
+  readonly initialized: boolean
+  readonly poolId: PublicKey
+  readonly observations: Array<types.Observation>
+  readonly padding: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    122, 174, 197, 53, 129, 9, 165, 132,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.bool("initialized"),
+    borsh.publicKey("poolId"),
+    borsh.array(types.Observation.layout(), 1000, "observations"),
+    borsh.array(borsh.u128(), 5, "padding"),
+  ])
+
+  constructor(fields: ObservationStateFields) {
+    this.initialized = fields.initialized
+    this.poolId = fields.poolId
+    this.observations = fields.observations.map(
+      (item) => new types.Observation({ ...item })
+    )
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<ObservationState | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<ObservationState | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): ObservationState {
+    if (!data.slice(0, 8).equals(ObservationState.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ObservationState.layout.decode(data.slice(8))
+
+    return new ObservationState({
+      initialized: dec.initialized,
+      poolId: dec.poolId,
+      observations: dec.observations.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.Observation.fromDecoded(item)
+      ),
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): ObservationStateJSON {
+    return {
+      initialized: this.initialized,
+      poolId: this.poolId.toString(),
+      observations: this.observations.map((item) => item.toJSON()),
+      padding: this.padding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: ObservationStateJSON): ObservationState {
+    return new ObservationState({
+      initialized: obj.initialized,
+      poolId: new PublicKey(obj.poolId),
+      observations: obj.observations.map((item) =>
+        types.Observation.fromJSON(item)
+      ),
+      padding: obj.padding.map((item) => new BN(item)),
+    })
+  }
+}

package/src/raydium_client/accounts/OperationState.ts

@@ -0,0 +1,105 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/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 OperationStateFields {
+  bump: number
+  operationOwners: Array<PublicKey>
+  whitelistMints: Array<PublicKey>
+}
+
+export interface OperationStateJSON {
+  bump: number
+  operationOwners: Array<string>
+  whitelistMints: Array<string>
+}
+
+export class OperationState {
+  readonly bump: number
+  readonly operationOwners: Array<PublicKey>
+  readonly whitelistMints: Array<PublicKey>
+
+  static readonly discriminator = Buffer.from([
+    19, 236, 58, 237, 81, 222, 183, 252,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u8("bump"),
+    borsh.array(borsh.publicKey(), 10, "operationOwners"),
+    borsh.array(borsh.publicKey(), 100, "whitelistMints"),
+  ])
+
+  constructor(fields: OperationStateFields) {
+    this.bump = fields.bump
+    this.operationOwners = fields.operationOwners
+    this.whitelistMints = fields.whitelistMints
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<OperationState | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<OperationState | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): OperationState {
+    if (!data.slice(0, 8).equals(OperationState.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = OperationState.layout.decode(data.slice(8))
+
+    return new OperationState({
+      bump: dec.bump,
+      operationOwners: dec.operationOwners,
+      whitelistMints: dec.whitelistMints,
+    })
+  }
+
+  toJSON(): OperationStateJSON {
+    return {
+      bump: this.bump,
+      operationOwners: this.operationOwners.map((item) => item.toString()),
+      whitelistMints: this.whitelistMints.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: OperationStateJSON): OperationState {
+    return new OperationState({
+      bump: obj.bump,
+      operationOwners: obj.operationOwners.map((item) => new PublicKey(item)),
+      whitelistMints: obj.whitelistMints.map((item) => new PublicKey(item)),
+    })
+  }
+}

package/src/raydium_client/accounts/PersonalPositionState.ts

@@ -0,0 +1,185 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/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 PersonalPositionStateFields {
+  bump: number
+  nftMint: PublicKey
+  poolId: PublicKey
+  tickLowerIndex: number
+  tickUpperIndex: number
+  liquidity: BN
+  feeGrowthInside0LastX64: BN
+  feeGrowthInside1LastX64: BN
+  tokenFeesOwed0: BN
+  tokenFeesOwed1: BN
+  rewardInfos: Array<types.PositionRewardInfoFields>
+  padding: Array<BN>
+}
+
+export interface PersonalPositionStateJSON {
+  bump: number
+  nftMint: string
+  poolId: string
+  tickLowerIndex: number
+  tickUpperIndex: number
+  liquidity: string
+  feeGrowthInside0LastX64: string
+  feeGrowthInside1LastX64: string
+  tokenFeesOwed0: string
+  tokenFeesOwed1: string
+  rewardInfos: Array<types.PositionRewardInfoJSON>
+  padding: Array<string>
+}
+
+export class PersonalPositionState {
+  readonly bump: number
+  readonly nftMint: PublicKey
+  readonly poolId: PublicKey
+  readonly tickLowerIndex: number
+  readonly tickUpperIndex: number
+  readonly liquidity: BN
+  readonly feeGrowthInside0LastX64: BN
+  readonly feeGrowthInside1LastX64: BN
+  readonly tokenFeesOwed0: BN
+  readonly tokenFeesOwed1: BN
+  readonly rewardInfos: Array<types.PositionRewardInfo>
+  readonly padding: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    70, 111, 150, 126, 230, 15, 25, 117,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u8("bump"),
+    borsh.publicKey("nftMint"),
+    borsh.publicKey("poolId"),
+    borsh.i32("tickLowerIndex"),
+    borsh.i32("tickUpperIndex"),
+    borsh.u128("liquidity"),
+    borsh.u128("feeGrowthInside0LastX64"),
+    borsh.u128("feeGrowthInside1LastX64"),
+    borsh.u64("tokenFeesOwed0"),
+    borsh.u64("tokenFeesOwed1"),
+    borsh.array(types.PositionRewardInfo.layout(), 3, "rewardInfos"),
+    borsh.array(borsh.u64(), 8, "padding"),
+  ])
+
+  constructor(fields: PersonalPositionStateFields) {
+    this.bump = fields.bump
+    this.nftMint = fields.nftMint
+    this.poolId = fields.poolId
+    this.tickLowerIndex = fields.tickLowerIndex
+    this.tickUpperIndex = fields.tickUpperIndex
+    this.liquidity = fields.liquidity
+    this.feeGrowthInside0LastX64 = fields.feeGrowthInside0LastX64
+    this.feeGrowthInside1LastX64 = fields.feeGrowthInside1LastX64
+    this.tokenFeesOwed0 = fields.tokenFeesOwed0
+    this.tokenFeesOwed1 = fields.tokenFeesOwed1
+    this.rewardInfos = fields.rewardInfos.map(
+      (item) => new types.PositionRewardInfo({ ...item })
+    )
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<PersonalPositionState | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<PersonalPositionState | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): PersonalPositionState {
+    if (!data.slice(0, 8).equals(PersonalPositionState.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = PersonalPositionState.layout.decode(data.slice(8))
+
+    return new PersonalPositionState({
+      bump: dec.bump,
+      nftMint: dec.nftMint,
+      poolId: dec.poolId,
+      tickLowerIndex: dec.tickLowerIndex,
+      tickUpperIndex: dec.tickUpperIndex,
+      liquidity: dec.liquidity,
+      feeGrowthInside0LastX64: dec.feeGrowthInside0LastX64,
+      feeGrowthInside1LastX64: dec.feeGrowthInside1LastX64,
+      tokenFeesOwed0: dec.tokenFeesOwed0,
+      tokenFeesOwed1: dec.tokenFeesOwed1,
+      rewardInfos: dec.rewardInfos.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.PositionRewardInfo.fromDecoded(item)
+      ),
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): PersonalPositionStateJSON {
+    return {
+      bump: this.bump,
+      nftMint: this.nftMint.toString(),
+      poolId: this.poolId.toString(),
+      tickLowerIndex: this.tickLowerIndex,
+      tickUpperIndex: this.tickUpperIndex,
+      liquidity: this.liquidity.toString(),
+      feeGrowthInside0LastX64: this.feeGrowthInside0LastX64.toString(),
+      feeGrowthInside1LastX64: this.feeGrowthInside1LastX64.toString(),
+      tokenFeesOwed0: this.tokenFeesOwed0.toString(),
+      tokenFeesOwed1: this.tokenFeesOwed1.toString(),
+      rewardInfos: this.rewardInfos.map((item) => item.toJSON()),
+      padding: this.padding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: PersonalPositionStateJSON): PersonalPositionState {
+    return new PersonalPositionState({
+      bump: obj.bump,
+      nftMint: new PublicKey(obj.nftMint),
+      poolId: new PublicKey(obj.poolId),
+      tickLowerIndex: obj.tickLowerIndex,
+      tickUpperIndex: obj.tickUpperIndex,
+      liquidity: new BN(obj.liquidity),
+      feeGrowthInside0LastX64: new BN(obj.feeGrowthInside0LastX64),
+      feeGrowthInside1LastX64: new BN(obj.feeGrowthInside1LastX64),
+      tokenFeesOwed0: new BN(obj.tokenFeesOwed0),
+      tokenFeesOwed1: new BN(obj.tokenFeesOwed1),
+      rewardInfos: obj.rewardInfos.map((item) =>
+        types.PositionRewardInfo.fromJSON(item)
+      ),
+      padding: obj.padding.map((item) => new BN(item)),
+    })
+  }
+}