@kamino-finance/kliquidity-sdk 8.1.0 → 8.1.3

package/src/raydium_client/types/Observation.ts

@@ -0,0 +1,85 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface ObservationFields {
+  blockTimestamp: number
+  sqrtPriceX64: BN
+  cumulativeTimePriceX64: BN
+  padding: BN
+}
+
+export interface ObservationJSON {
+  blockTimestamp: number
+  sqrtPriceX64: string
+  cumulativeTimePriceX64: string
+  padding: string
+}
+
+export class Observation {
+  readonly blockTimestamp: number
+  readonly sqrtPriceX64: BN
+  readonly cumulativeTimePriceX64: BN
+  readonly padding: BN
+
+  constructor(fields: ObservationFields) {
+    this.blockTimestamp = fields.blockTimestamp
+    this.sqrtPriceX64 = fields.sqrtPriceX64
+    this.cumulativeTimePriceX64 = fields.cumulativeTimePriceX64
+    this.padding = fields.padding
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u32("blockTimestamp"),
+        borsh.u128("sqrtPriceX64"),
+        borsh.u128("cumulativeTimePriceX64"),
+        borsh.u128("padding"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new Observation({
+      blockTimestamp: obj.blockTimestamp,
+      sqrtPriceX64: obj.sqrtPriceX64,
+      cumulativeTimePriceX64: obj.cumulativeTimePriceX64,
+      padding: obj.padding,
+    })
+  }
+
+  static toEncodable(fields: ObservationFields) {
+    return {
+      blockTimestamp: fields.blockTimestamp,
+      sqrtPriceX64: fields.sqrtPriceX64,
+      cumulativeTimePriceX64: fields.cumulativeTimePriceX64,
+      padding: fields.padding,
+    }
+  }
+
+  toJSON(): ObservationJSON {
+    return {
+      blockTimestamp: this.blockTimestamp,
+      sqrtPriceX64: this.sqrtPriceX64.toString(),
+      cumulativeTimePriceX64: this.cumulativeTimePriceX64.toString(),
+      padding: this.padding.toString(),
+    }
+  }
+
+  static fromJSON(obj: ObservationJSON): Observation {
+    return new Observation({
+      blockTimestamp: obj.blockTimestamp,
+      sqrtPriceX64: new BN(obj.sqrtPriceX64),
+      cumulativeTimePriceX64: new BN(obj.cumulativeTimePriceX64),
+      padding: new BN(obj.padding),
+    })
+  }
+
+  toEncodable() {
+    return Observation.toEncodable(this)
+  }
+}

package/src/raydium_client/types/PoolStatusBitFlag.ts

@@ -0,0 +1,90 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface EnableJSON {
+  kind: "Enable"
+}
+
+export class Enable {
+  static readonly discriminator = 0
+  static readonly kind = "Enable"
+  readonly discriminator = 0
+  readonly kind = "Enable"
+
+  toJSON(): EnableJSON {
+    return {
+      kind: "Enable",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Enable: {},
+    }
+  }
+}
+
+export interface DisableJSON {
+  kind: "Disable"
+}
+
+export class Disable {
+  static readonly discriminator = 1
+  static readonly kind = "Disable"
+  readonly discriminator = 1
+  readonly kind = "Disable"
+
+  toJSON(): DisableJSON {
+    return {
+      kind: "Disable",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Disable: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PoolStatusBitFlagKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Enable" in obj) {
+    return new Enable()
+  }
+  if ("Disable" in obj) {
+    return new Disable()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.PoolStatusBitFlagJSON
+): types.PoolStatusBitFlagKind {
+  switch (obj.kind) {
+    case "Enable": {
+      return new Enable()
+    }
+    case "Disable": {
+      return new Disable()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Enable"),
+    borsh.struct([], "Disable"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/raydium_client/types/PoolStatusBitIndex.ts

@@ -0,0 +1,180 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface OpenPositionOrIncreaseLiquidityJSON {
+  kind: "OpenPositionOrIncreaseLiquidity"
+}
+
+export class OpenPositionOrIncreaseLiquidity {
+  static readonly discriminator = 0
+  static readonly kind = "OpenPositionOrIncreaseLiquidity"
+  readonly discriminator = 0
+  readonly kind = "OpenPositionOrIncreaseLiquidity"
+
+  toJSON(): OpenPositionOrIncreaseLiquidityJSON {
+    return {
+      kind: "OpenPositionOrIncreaseLiquidity",
+    }
+  }
+
+  toEncodable() {
+    return {
+      OpenPositionOrIncreaseLiquidity: {},
+    }
+  }
+}
+
+export interface DecreaseLiquidityJSON {
+  kind: "DecreaseLiquidity"
+}
+
+export class DecreaseLiquidity {
+  static readonly discriminator = 1
+  static readonly kind = "DecreaseLiquidity"
+  readonly discriminator = 1
+  readonly kind = "DecreaseLiquidity"
+
+  toJSON(): DecreaseLiquidityJSON {
+    return {
+      kind: "DecreaseLiquidity",
+    }
+  }
+
+  toEncodable() {
+    return {
+      DecreaseLiquidity: {},
+    }
+  }
+}
+
+export interface CollectFeeJSON {
+  kind: "CollectFee"
+}
+
+export class CollectFee {
+  static readonly discriminator = 2
+  static readonly kind = "CollectFee"
+  readonly discriminator = 2
+  readonly kind = "CollectFee"
+
+  toJSON(): CollectFeeJSON {
+    return {
+      kind: "CollectFee",
+    }
+  }
+
+  toEncodable() {
+    return {
+      CollectFee: {},
+    }
+  }
+}
+
+export interface CollectRewardJSON {
+  kind: "CollectReward"
+}
+
+export class CollectReward {
+  static readonly discriminator = 3
+  static readonly kind = "CollectReward"
+  readonly discriminator = 3
+  readonly kind = "CollectReward"
+
+  toJSON(): CollectRewardJSON {
+    return {
+      kind: "CollectReward",
+    }
+  }
+
+  toEncodable() {
+    return {
+      CollectReward: {},
+    }
+  }
+}
+
+export interface SwapJSON {
+  kind: "Swap"
+}
+
+export class Swap {
+  static readonly discriminator = 4
+  static readonly kind = "Swap"
+  readonly discriminator = 4
+  readonly kind = "Swap"
+
+  toJSON(): SwapJSON {
+    return {
+      kind: "Swap",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Swap: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PoolStatusBitIndexKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("OpenPositionOrIncreaseLiquidity" in obj) {
+    return new OpenPositionOrIncreaseLiquidity()
+  }
+  if ("DecreaseLiquidity" in obj) {
+    return new DecreaseLiquidity()
+  }
+  if ("CollectFee" in obj) {
+    return new CollectFee()
+  }
+  if ("CollectReward" in obj) {
+    return new CollectReward()
+  }
+  if ("Swap" in obj) {
+    return new Swap()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.PoolStatusBitIndexJSON
+): types.PoolStatusBitIndexKind {
+  switch (obj.kind) {
+    case "OpenPositionOrIncreaseLiquidity": {
+      return new OpenPositionOrIncreaseLiquidity()
+    }
+    case "DecreaseLiquidity": {
+      return new DecreaseLiquidity()
+    }
+    case "CollectFee": {
+      return new CollectFee()
+    }
+    case "CollectReward": {
+      return new CollectReward()
+    }
+    case "Swap": {
+      return new Swap()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "OpenPositionOrIncreaseLiquidity"),
+    borsh.struct([], "DecreaseLiquidity"),
+    borsh.struct([], "CollectFee"),
+    borsh.struct([], "CollectReward"),
+    borsh.struct([], "Swap"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/raydium_client/types/PositionRewardInfo.ts

@@ -0,0 +1,64 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface PositionRewardInfoFields {
+  growthInsideLastX64: BN
+  rewardAmountOwed: BN
+}
+
+export interface PositionRewardInfoJSON {
+  growthInsideLastX64: string
+  rewardAmountOwed: string
+}
+
+export class PositionRewardInfo {
+  readonly growthInsideLastX64: BN
+  readonly rewardAmountOwed: BN
+
+  constructor(fields: PositionRewardInfoFields) {
+    this.growthInsideLastX64 = fields.growthInsideLastX64
+    this.rewardAmountOwed = fields.rewardAmountOwed
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.u128("growthInsideLastX64"), borsh.u64("rewardAmountOwed")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new PositionRewardInfo({
+      growthInsideLastX64: obj.growthInsideLastX64,
+      rewardAmountOwed: obj.rewardAmountOwed,
+    })
+  }
+
+  static toEncodable(fields: PositionRewardInfoFields) {
+    return {
+      growthInsideLastX64: fields.growthInsideLastX64,
+      rewardAmountOwed: fields.rewardAmountOwed,
+    }
+  }
+
+  toJSON(): PositionRewardInfoJSON {
+    return {
+      growthInsideLastX64: this.growthInsideLastX64.toString(),
+      rewardAmountOwed: this.rewardAmountOwed.toString(),
+    }
+  }
+
+  static fromJSON(obj: PositionRewardInfoJSON): PositionRewardInfo {
+    return new PositionRewardInfo({
+      growthInsideLastX64: new BN(obj.growthInsideLastX64),
+      rewardAmountOwed: new BN(obj.rewardAmountOwed),
+    })
+  }
+
+  toEncodable() {
+    return PositionRewardInfo.toEncodable(this)
+  }
+}

package/src/raydium_client/types/RewardInfo.ts

@@ -0,0 +1,148 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface RewardInfoFields {
+  rewardState: number
+  openTime: BN
+  endTime: BN
+  lastUpdateTime: BN
+  emissionsPerSecondX64: BN
+  rewardTotalEmissioned: BN
+  rewardClaimed: BN
+  tokenMint: PublicKey
+  tokenVault: PublicKey
+  authority: PublicKey
+  rewardGrowthGlobalX64: BN
+}
+
+export interface RewardInfoJSON {
+  rewardState: number
+  openTime: string
+  endTime: string
+  lastUpdateTime: string
+  emissionsPerSecondX64: string
+  rewardTotalEmissioned: string
+  rewardClaimed: string
+  tokenMint: string
+  tokenVault: string
+  authority: string
+  rewardGrowthGlobalX64: string
+}
+
+export class RewardInfo {
+  readonly rewardState: number
+  readonly openTime: BN
+  readonly endTime: BN
+  readonly lastUpdateTime: BN
+  readonly emissionsPerSecondX64: BN
+  readonly rewardTotalEmissioned: BN
+  readonly rewardClaimed: BN
+  readonly tokenMint: PublicKey
+  readonly tokenVault: PublicKey
+  readonly authority: PublicKey
+  readonly rewardGrowthGlobalX64: BN
+
+  constructor(fields: RewardInfoFields) {
+    this.rewardState = fields.rewardState
+    this.openTime = fields.openTime
+    this.endTime = fields.endTime
+    this.lastUpdateTime = fields.lastUpdateTime
+    this.emissionsPerSecondX64 = fields.emissionsPerSecondX64
+    this.rewardTotalEmissioned = fields.rewardTotalEmissioned
+    this.rewardClaimed = fields.rewardClaimed
+    this.tokenMint = fields.tokenMint
+    this.tokenVault = fields.tokenVault
+    this.authority = fields.authority
+    this.rewardGrowthGlobalX64 = fields.rewardGrowthGlobalX64
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u8("rewardState"),
+        borsh.u64("openTime"),
+        borsh.u64("endTime"),
+        borsh.u64("lastUpdateTime"),
+        borsh.u128("emissionsPerSecondX64"),
+        borsh.u64("rewardTotalEmissioned"),
+        borsh.u64("rewardClaimed"),
+        borsh.publicKey("tokenMint"),
+        borsh.publicKey("tokenVault"),
+        borsh.publicKey("authority"),
+        borsh.u128("rewardGrowthGlobalX64"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new RewardInfo({
+      rewardState: obj.rewardState,
+      openTime: obj.openTime,
+      endTime: obj.endTime,
+      lastUpdateTime: obj.lastUpdateTime,
+      emissionsPerSecondX64: obj.emissionsPerSecondX64,
+      rewardTotalEmissioned: obj.rewardTotalEmissioned,
+      rewardClaimed: obj.rewardClaimed,
+      tokenMint: obj.tokenMint,
+      tokenVault: obj.tokenVault,
+      authority: obj.authority,
+      rewardGrowthGlobalX64: obj.rewardGrowthGlobalX64,
+    })
+  }
+
+  static toEncodable(fields: RewardInfoFields) {
+    return {
+      rewardState: fields.rewardState,
+      openTime: fields.openTime,
+      endTime: fields.endTime,
+      lastUpdateTime: fields.lastUpdateTime,
+      emissionsPerSecondX64: fields.emissionsPerSecondX64,
+      rewardTotalEmissioned: fields.rewardTotalEmissioned,
+      rewardClaimed: fields.rewardClaimed,
+      tokenMint: fields.tokenMint,
+      tokenVault: fields.tokenVault,
+      authority: fields.authority,
+      rewardGrowthGlobalX64: fields.rewardGrowthGlobalX64,
+    }
+  }
+
+  toJSON(): RewardInfoJSON {
+    return {
+      rewardState: this.rewardState,
+      openTime: this.openTime.toString(),
+      endTime: this.endTime.toString(),
+      lastUpdateTime: this.lastUpdateTime.toString(),
+      emissionsPerSecondX64: this.emissionsPerSecondX64.toString(),
+      rewardTotalEmissioned: this.rewardTotalEmissioned.toString(),
+      rewardClaimed: this.rewardClaimed.toString(),
+      tokenMint: this.tokenMint.toString(),
+      tokenVault: this.tokenVault.toString(),
+      authority: this.authority.toString(),
+      rewardGrowthGlobalX64: this.rewardGrowthGlobalX64.toString(),
+    }
+  }
+
+  static fromJSON(obj: RewardInfoJSON): RewardInfo {
+    return new RewardInfo({
+      rewardState: obj.rewardState,
+      openTime: new BN(obj.openTime),
+      endTime: new BN(obj.endTime),
+      lastUpdateTime: new BN(obj.lastUpdateTime),
+      emissionsPerSecondX64: new BN(obj.emissionsPerSecondX64),
+      rewardTotalEmissioned: new BN(obj.rewardTotalEmissioned),
+      rewardClaimed: new BN(obj.rewardClaimed),
+      tokenMint: new PublicKey(obj.tokenMint),
+      tokenVault: new PublicKey(obj.tokenVault),
+      authority: new PublicKey(obj.authority),
+      rewardGrowthGlobalX64: new BN(obj.rewardGrowthGlobalX64),
+    })
+  }
+
+  toEncodable() {
+    return RewardInfo.toEncodable(this)
+  }
+}

package/src/raydium_client/types/RewardState.ts

@@ -0,0 +1,148 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface UninitializedJSON {
+  kind: "Uninitialized"
+}
+
+export class Uninitialized {
+  static readonly discriminator = 0
+  static readonly kind = "Uninitialized"
+  readonly discriminator = 0
+  readonly kind = "Uninitialized"
+
+  toJSON(): UninitializedJSON {
+    return {
+      kind: "Uninitialized",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Uninitialized: {},
+    }
+  }
+}
+
+export interface InitializedJSON {
+  kind: "Initialized"
+}
+
+export class Initialized {
+  static readonly discriminator = 1
+  static readonly kind = "Initialized"
+  readonly discriminator = 1
+  readonly kind = "Initialized"
+
+  toJSON(): InitializedJSON {
+    return {
+      kind: "Initialized",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Initialized: {},
+    }
+  }
+}
+
+export interface OpeningJSON {
+  kind: "Opening"
+}
+
+export class Opening {
+  static readonly discriminator = 2
+  static readonly kind = "Opening"
+  readonly discriminator = 2
+  readonly kind = "Opening"
+
+  toJSON(): OpeningJSON {
+    return {
+      kind: "Opening",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Opening: {},
+    }
+  }
+}
+
+export interface EndedJSON {
+  kind: "Ended"
+}
+
+export class Ended {
+  static readonly discriminator = 3
+  static readonly kind = "Ended"
+  readonly discriminator = 3
+  readonly kind = "Ended"
+
+  toJSON(): EndedJSON {
+    return {
+      kind: "Ended",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Ended: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.RewardStateKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Uninitialized" in obj) {
+    return new Uninitialized()
+  }
+  if ("Initialized" in obj) {
+    return new Initialized()
+  }
+  if ("Opening" in obj) {
+    return new Opening()
+  }
+  if ("Ended" in obj) {
+    return new Ended()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.RewardStateJSON): types.RewardStateKind {
+  switch (obj.kind) {
+    case "Uninitialized": {
+      return new Uninitialized()
+    }
+    case "Initialized": {
+      return new Initialized()
+    }
+    case "Opening": {
+      return new Opening()
+    }
+    case "Ended": {
+      return new Ended()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Uninitialized"),
+    borsh.struct([], "Initialized"),
+    borsh.struct([], "Opening"),
+    borsh.struct([], "Ended"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}