@kamino-finance/kliquidity-sdk 8.4.8-beta.1 → 8.5.0

package/src/@codegen/kliquidity/types/RebalanceType.ts

@@ -0,0 +1,271 @@
+import { address, Address } from "@solana/kit" // 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"
+import { borshAddress } from "../utils"
+
+export interface ManualJSON {
+  kind: "Manual"
+}
+
+export class Manual {
+  static readonly discriminator = 0
+  static readonly kind = "Manual"
+  readonly discriminator = 0
+  readonly kind = "Manual"
+
+  toJSON(): ManualJSON {
+    return {
+      kind: "Manual",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Manual: {},
+    }
+  }
+}
+
+export interface PricePercentageJSON {
+  kind: "PricePercentage"
+}
+
+export class PricePercentage {
+  static readonly discriminator = 1
+  static readonly kind = "PricePercentage"
+  readonly discriminator = 1
+  readonly kind = "PricePercentage"
+
+  toJSON(): PricePercentageJSON {
+    return {
+      kind: "PricePercentage",
+    }
+  }
+
+  toEncodable() {
+    return {
+      PricePercentage: {},
+    }
+  }
+}
+
+export interface PricePercentageWithResetJSON {
+  kind: "PricePercentageWithReset"
+}
+
+export class PricePercentageWithReset {
+  static readonly discriminator = 2
+  static readonly kind = "PricePercentageWithReset"
+  readonly discriminator = 2
+  readonly kind = "PricePercentageWithReset"
+
+  toJSON(): PricePercentageWithResetJSON {
+    return {
+      kind: "PricePercentageWithReset",
+    }
+  }
+
+  toEncodable() {
+    return {
+      PricePercentageWithReset: {},
+    }
+  }
+}
+
+export interface DriftJSON {
+  kind: "Drift"
+}
+
+export class Drift {
+  static readonly discriminator = 3
+  static readonly kind = "Drift"
+  readonly discriminator = 3
+  readonly kind = "Drift"
+
+  toJSON(): DriftJSON {
+    return {
+      kind: "Drift",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Drift: {},
+    }
+  }
+}
+
+export interface TakeProfitJSON {
+  kind: "TakeProfit"
+}
+
+export class TakeProfit {
+  static readonly discriminator = 4
+  static readonly kind = "TakeProfit"
+  readonly discriminator = 4
+  readonly kind = "TakeProfit"
+
+  toJSON(): TakeProfitJSON {
+    return {
+      kind: "TakeProfit",
+    }
+  }
+
+  toEncodable() {
+    return {
+      TakeProfit: {},
+    }
+  }
+}
+
+export interface PeriodicRebalanceJSON {
+  kind: "PeriodicRebalance"
+}
+
+export class PeriodicRebalance {
+  static readonly discriminator = 5
+  static readonly kind = "PeriodicRebalance"
+  readonly discriminator = 5
+  readonly kind = "PeriodicRebalance"
+
+  toJSON(): PeriodicRebalanceJSON {
+    return {
+      kind: "PeriodicRebalance",
+    }
+  }
+
+  toEncodable() {
+    return {
+      PeriodicRebalance: {},
+    }
+  }
+}
+
+export interface ExpanderJSON {
+  kind: "Expander"
+}
+
+export class Expander {
+  static readonly discriminator = 6
+  static readonly kind = "Expander"
+  readonly discriminator = 6
+  readonly kind = "Expander"
+
+  toJSON(): ExpanderJSON {
+    return {
+      kind: "Expander",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Expander: {},
+    }
+  }
+}
+
+export interface AutodriftJSON {
+  kind: "Autodrift"
+}
+
+export class Autodrift {
+  static readonly discriminator = 7
+  static readonly kind = "Autodrift"
+  readonly discriminator = 7
+  readonly kind = "Autodrift"
+
+  toJSON(): AutodriftJSON {
+    return {
+      kind: "Autodrift",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Autodrift: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.RebalanceTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Manual" in obj) {
+    return new Manual()
+  }
+  if ("PricePercentage" in obj) {
+    return new PricePercentage()
+  }
+  if ("PricePercentageWithReset" in obj) {
+    return new PricePercentageWithReset()
+  }
+  if ("Drift" in obj) {
+    return new Drift()
+  }
+  if ("TakeProfit" in obj) {
+    return new TakeProfit()
+  }
+  if ("PeriodicRebalance" in obj) {
+    return new PeriodicRebalance()
+  }
+  if ("Expander" in obj) {
+    return new Expander()
+  }
+  if ("Autodrift" in obj) {
+    return new Autodrift()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.RebalanceTypeJSON
+): types.RebalanceTypeKind {
+  switch (obj.kind) {
+    case "Manual": {
+      return new Manual()
+    }
+    case "PricePercentage": {
+      return new PricePercentage()
+    }
+    case "PricePercentageWithReset": {
+      return new PricePercentageWithReset()
+    }
+    case "Drift": {
+      return new Drift()
+    }
+    case "TakeProfit": {
+      return new TakeProfit()
+    }
+    case "PeriodicRebalance": {
+      return new PeriodicRebalance()
+    }
+    case "Expander": {
+      return new Expander()
+    }
+    case "Autodrift": {
+      return new Autodrift()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Manual"),
+    borsh.struct([], "PricePercentage"),
+    borsh.struct([], "PricePercentageWithReset"),
+    borsh.struct([], "Drift"),
+    borsh.struct([], "TakeProfit"),
+    borsh.struct([], "PeriodicRebalance"),
+    borsh.struct([], "Expander"),
+    borsh.struct([], "Autodrift"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/@codegen/kliquidity/types/ReferencePriceType.ts

@@ -0,0 +1,91 @@
+import { address, Address } from "@solana/kit" // 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"
+import { borshAddress } from "../utils"
+
+export interface POOLJSON {
+  kind: "POOL"
+}
+
+export class POOL {
+  static readonly discriminator = 0
+  static readonly kind = "POOL"
+  readonly discriminator = 0
+  readonly kind = "POOL"
+
+  toJSON(): POOLJSON {
+    return {
+      kind: "POOL",
+    }
+  }
+
+  toEncodable() {
+    return {
+      POOL: {},
+    }
+  }
+}
+
+export interface TWAPJSON {
+  kind: "TWAP"
+}
+
+export class TWAP {
+  static readonly discriminator = 1
+  static readonly kind = "TWAP"
+  readonly discriminator = 1
+  readonly kind = "TWAP"
+
+  toJSON(): TWAPJSON {
+    return {
+      kind: "TWAP",
+    }
+  }
+
+  toEncodable() {
+    return {
+      TWAP: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.ReferencePriceTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("POOL" in obj) {
+    return new POOL()
+  }
+  if ("TWAP" in obj) {
+    return new TWAP()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.ReferencePriceTypeJSON
+): types.ReferencePriceTypeKind {
+  switch (obj.kind) {
+    case "POOL": {
+      return new POOL()
+    }
+    case "TWAP": {
+      return new TWAP()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "POOL"),
+    borsh.struct([], "TWAP"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/@codegen/kliquidity/types/RemoveLiquidityMode.ts

@@ -0,0 +1,147 @@
+import { address, Address } from "@solana/kit" // 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"
+import { borshAddress } from "../utils"
+
+export type LiquidityFields = [BN]
+export type LiquidityValue = [BN]
+
+export interface LiquidityJSON {
+  kind: "Liquidity"
+  value: [string]
+}
+
+export class Liquidity {
+  static readonly discriminator = 0
+  static readonly kind = "Liquidity"
+  readonly discriminator = 0
+  readonly kind = "Liquidity"
+  readonly value: LiquidityValue
+
+  constructor(value: LiquidityFields) {
+    this.value = [value[0]]
+  }
+
+  toJSON(): LiquidityJSON {
+    return {
+      kind: "Liquidity",
+      value: [this.value[0].toString()],
+    }
+  }
+
+  toEncodable() {
+    return {
+      Liquidity: {
+        _0: this.value[0],
+      },
+    }
+  }
+}
+
+export type BpsFields = [number]
+export type BpsValue = [number]
+
+export interface BpsJSON {
+  kind: "Bps"
+  value: [number]
+}
+
+export class Bps {
+  static readonly discriminator = 1
+  static readonly kind = "Bps"
+  readonly discriminator = 1
+  readonly kind = "Bps"
+  readonly value: BpsValue
+
+  constructor(value: BpsFields) {
+    this.value = [value[0]]
+  }
+
+  toJSON(): BpsJSON {
+    return {
+      kind: "Bps",
+      value: [this.value[0]],
+    }
+  }
+
+  toEncodable() {
+    return {
+      Bps: {
+        _0: this.value[0],
+      },
+    }
+  }
+}
+
+export interface AllJSON {
+  kind: "All"
+}
+
+export class All {
+  static readonly discriminator = 2
+  static readonly kind = "All"
+  readonly discriminator = 2
+  readonly kind = "All"
+
+  toJSON(): AllJSON {
+    return {
+      kind: "All",
+    }
+  }
+
+  toEncodable() {
+    return {
+      All: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.RemoveLiquidityModeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Liquidity" in obj) {
+    const val = obj["Liquidity"]
+    return new Liquidity([val["_0"]])
+  }
+  if ("Bps" in obj) {
+    const val = obj["Bps"]
+    return new Bps([val["_0"]])
+  }
+  if ("All" in obj) {
+    return new All()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.RemoveLiquidityModeJSON
+): types.RemoveLiquidityModeKind {
+  switch (obj.kind) {
+    case "Liquidity": {
+      return new Liquidity([new BN(obj.value[0])])
+    }
+    case "Bps": {
+      return new Bps([obj.value[0]])
+    }
+    case "All": {
+      return new All()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([borsh.u128("_0")], "Liquidity"),
+    borsh.struct([borsh.u16("_0")], "Bps"),
+    borsh.struct([], "All"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/@codegen/kliquidity/types/RewardInfo.ts

@@ -0,0 +1,191 @@
+import { address, Address } from "@solana/kit" // 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"
+import { borshAddress } from "../utils"
+
+export interface RewardInfoFields {
+  /** Reward state */
+  rewardState: number
+  /** Reward open time */
+  openTime: BN
+  /** Reward end time */
+  endTime: BN
+  /** Reward last update time */
+  lastUpdateTime: BN
+  /** Q64.64 number indicates how many tokens per second are earned per unit of liquidity. */
+  emissionsPerSecondX64: BN
+  /** The total amount of reward emissioned */
+  rewardTotalEmissioned: BN
+  /** The total amount of claimed reward */
+  rewardClaimed: BN
+  /** Reward token mint. */
+  tokenMint: Address
+  /** Reward vault token account. */
+  tokenVault: Address
+  /** The owner that has permission to set reward param */
+  authority: Address
+  /**
+   * Q64.64 number that tracks the total tokens earned per unit of liquidity since the reward
+   * emissions were turned on.
+   */
+  rewardGrowthGlobalX64: BN
+}
+
+export interface RewardInfoJSON {
+  /** Reward state */
+  rewardState: number
+  /** Reward open time */
+  openTime: string
+  /** Reward end time */
+  endTime: string
+  /** Reward last update time */
+  lastUpdateTime: string
+  /** Q64.64 number indicates how many tokens per second are earned per unit of liquidity. */
+  emissionsPerSecondX64: string
+  /** The total amount of reward emissioned */
+  rewardTotalEmissioned: string
+  /** The total amount of claimed reward */
+  rewardClaimed: string
+  /** Reward token mint. */
+  tokenMint: string
+  /** Reward vault token account. */
+  tokenVault: string
+  /** The owner that has permission to set reward param */
+  authority: string
+  /**
+   * Q64.64 number that tracks the total tokens earned per unit of liquidity since the reward
+   * emissions were turned on.
+   */
+  rewardGrowthGlobalX64: string
+}
+
+export class RewardInfo {
+  /** Reward state */
+  readonly rewardState: number
+  /** Reward open time */
+  readonly openTime: BN
+  /** Reward end time */
+  readonly endTime: BN
+  /** Reward last update time */
+  readonly lastUpdateTime: BN
+  /** Q64.64 number indicates how many tokens per second are earned per unit of liquidity. */
+  readonly emissionsPerSecondX64: BN
+  /** The total amount of reward emissioned */
+  readonly rewardTotalEmissioned: BN
+  /** The total amount of claimed reward */
+  readonly rewardClaimed: BN
+  /** Reward token mint. */
+  readonly tokenMint: Address
+  /** Reward vault token account. */
+  readonly tokenVault: Address
+  /** The owner that has permission to set reward param */
+  readonly authority: Address
+  /**
+   * Q64.64 number that tracks the total tokens earned per unit of liquidity since the reward
+   * emissions were turned on.
+   */
+  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"),
+        borshAddress("tokenMint"),
+        borshAddress("tokenVault"),
+        borshAddress("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,
+      tokenVault: this.tokenVault,
+      authority: this.authority,
+      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: address(obj.tokenMint),
+      tokenVault: address(obj.tokenVault),
+      authority: address(obj.authority),
+      rewardGrowthGlobalX64: new BN(obj.rewardGrowthGlobalX64),
+    })
+  }
+
+  toEncodable() {
+    return RewardInfo.toEncodable(this)
+  }
+}