@kamino-finance/kliquidity-sdk 6.2.1 → 6.3.0

package/src/kamino-client/types/RebalanceEffects.ts

@@ -0,0 +1,104 @@
+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 type NewRangeFields = [number, number]
+export type NewRangeValue = [number, number]
+
+export interface NewRangeJSON {
+  kind: "NewRange"
+  value: [number, number]
+}
+
+export class NewRange {
+  static readonly discriminator = 0
+  static readonly kind = "NewRange"
+  readonly discriminator = 0
+  readonly kind = "NewRange"
+  readonly value: NewRangeValue
+
+  constructor(value: NewRangeFields) {
+    this.value = [value[0], value[1]]
+  }
+
+  toJSON(): NewRangeJSON {
+    return {
+      kind: "NewRange",
+      value: [this.value[0], this.value[1]],
+    }
+  }
+
+  toEncodable() {
+    return {
+      NewRange: {
+        _0: this.value[0],
+        _1: this.value[1],
+      },
+    }
+  }
+}
+
+export interface WithdrawAndFreezeJSON {
+  kind: "WithdrawAndFreeze"
+}
+
+export class WithdrawAndFreeze {
+  static readonly discriminator = 1
+  static readonly kind = "WithdrawAndFreeze"
+  readonly discriminator = 1
+  readonly kind = "WithdrawAndFreeze"
+
+  toJSON(): WithdrawAndFreezeJSON {
+    return {
+      kind: "WithdrawAndFreeze",
+    }
+  }
+
+  toEncodable() {
+    return {
+      WithdrawAndFreeze: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.RebalanceEffectsKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("NewRange" in obj) {
+    const val = obj["NewRange"]
+    return new NewRange([val["_0"], val["_1"]])
+  }
+  if ("WithdrawAndFreeze" in obj) {
+    return new WithdrawAndFreeze()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.RebalanceEffectsJSON
+): types.RebalanceEffectsKind {
+  switch (obj.kind) {
+    case "NewRange": {
+      return new NewRange([obj.value[0], obj.value[1]])
+    }
+    case "WithdrawAndFreeze": {
+      return new WithdrawAndFreeze()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([borsh.i32("_0"), borsh.i32("_1")], "NewRange"),
+    borsh.struct([], "WithdrawAndFreeze"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/kamino-client/types/RebalanceExpanderState.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 RebalanceExpanderStateFields {
+  initialPoolPrice: BN
+  expansionCount: number
+}
+
+export interface RebalanceExpanderStateJSON {
+  initialPoolPrice: string
+  expansionCount: number
+}
+
+export class RebalanceExpanderState {
+  readonly initialPoolPrice: BN
+  readonly expansionCount: number
+
+  constructor(fields: RebalanceExpanderStateFields) {
+    this.initialPoolPrice = fields.initialPoolPrice
+    this.expansionCount = fields.expansionCount
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.u128("initialPoolPrice"), borsh.u16("expansionCount")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new RebalanceExpanderState({
+      initialPoolPrice: obj.initialPoolPrice,
+      expansionCount: obj.expansionCount,
+    })
+  }
+
+  static toEncodable(fields: RebalanceExpanderStateFields) {
+    return {
+      initialPoolPrice: fields.initialPoolPrice,
+      expansionCount: fields.expansionCount,
+    }
+  }
+
+  toJSON(): RebalanceExpanderStateJSON {
+    return {
+      initialPoolPrice: this.initialPoolPrice.toString(),
+      expansionCount: this.expansionCount,
+    }
+  }
+
+  static fromJSON(obj: RebalanceExpanderStateJSON): RebalanceExpanderState {
+    return new RebalanceExpanderState({
+      initialPoolPrice: new BN(obj.initialPoolPrice),
+      expansionCount: obj.expansionCount,
+    })
+  }
+
+  toEncodable() {
+    return RebalanceExpanderState.toEncodable(this)
+  }
+}

package/src/kamino-client/types/RebalanceManualState.ts

@@ -0,0 +1,37 @@
+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 RebalanceManualStateFields {}
+
+export interface RebalanceManualStateJSON {}
+
+export class RebalanceManualState {
+  constructor(fields: RebalanceManualStateFields) {}
+
+  static layout(property?: string) {
+    return borsh.struct([], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new RebalanceManualState({})
+  }
+
+  static toEncodable(fields: RebalanceManualStateFields) {
+    return {}
+  }
+
+  toJSON(): RebalanceManualStateJSON {
+    return {}
+  }
+
+  static fromJSON(obj: RebalanceManualStateJSON): RebalanceManualState {
+    return new RebalanceManualState({})
+  }
+
+  toEncodable() {
+    return RebalanceManualState.toEncodable(this)
+  }
+}

package/src/kamino-client/types/RebalancePricePercentageState.ts

@@ -0,0 +1,69 @@
+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 RebalancePricePercentageStateFields {
+  lastRebalanceLowerPoolPrice: BN
+  lastRebalanceUpperPoolPrice: BN
+}
+
+export interface RebalancePricePercentageStateJSON {
+  lastRebalanceLowerPoolPrice: string
+  lastRebalanceUpperPoolPrice: string
+}
+
+export class RebalancePricePercentageState {
+  readonly lastRebalanceLowerPoolPrice: BN
+  readonly lastRebalanceUpperPoolPrice: BN
+
+  constructor(fields: RebalancePricePercentageStateFields) {
+    this.lastRebalanceLowerPoolPrice = fields.lastRebalanceLowerPoolPrice
+    this.lastRebalanceUpperPoolPrice = fields.lastRebalanceUpperPoolPrice
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u128("lastRebalanceLowerPoolPrice"),
+        borsh.u128("lastRebalanceUpperPoolPrice"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new RebalancePricePercentageState({
+      lastRebalanceLowerPoolPrice: obj.lastRebalanceLowerPoolPrice,
+      lastRebalanceUpperPoolPrice: obj.lastRebalanceUpperPoolPrice,
+    })
+  }
+
+  static toEncodable(fields: RebalancePricePercentageStateFields) {
+    return {
+      lastRebalanceLowerPoolPrice: fields.lastRebalanceLowerPoolPrice,
+      lastRebalanceUpperPoolPrice: fields.lastRebalanceUpperPoolPrice,
+    }
+  }
+
+  toJSON(): RebalancePricePercentageStateJSON {
+    return {
+      lastRebalanceLowerPoolPrice: this.lastRebalanceLowerPoolPrice.toString(),
+      lastRebalanceUpperPoolPrice: this.lastRebalanceUpperPoolPrice.toString(),
+    }
+  }
+
+  static fromJSON(
+    obj: RebalancePricePercentageStateJSON
+  ): RebalancePricePercentageState {
+    return new RebalancePricePercentageState({
+      lastRebalanceLowerPoolPrice: new BN(obj.lastRebalanceLowerPoolPrice),
+      lastRebalanceUpperPoolPrice: new BN(obj.lastRebalanceUpperPoolPrice),
+    })
+  }
+
+  toEncodable() {
+    return RebalancePricePercentageState.toEncodable(this)
+  }
+}

package/src/kamino-client/types/RebalancePricePercentageWithResetState.ts

@@ -0,0 +1,77 @@
+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 RebalancePricePercentageWithResetStateFields {
+  lastRebalanceLowerResetPoolPrice: BN
+  lastRebalanceUpperResetPoolPrice: BN
+}
+
+export interface RebalancePricePercentageWithResetStateJSON {
+  lastRebalanceLowerResetPoolPrice: string
+  lastRebalanceUpperResetPoolPrice: string
+}
+
+export class RebalancePricePercentageWithResetState {
+  readonly lastRebalanceLowerResetPoolPrice: BN
+  readonly lastRebalanceUpperResetPoolPrice: BN
+
+  constructor(fields: RebalancePricePercentageWithResetStateFields) {
+    this.lastRebalanceLowerResetPoolPrice =
+      fields.lastRebalanceLowerResetPoolPrice
+    this.lastRebalanceUpperResetPoolPrice =
+      fields.lastRebalanceUpperResetPoolPrice
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u128("lastRebalanceLowerResetPoolPrice"),
+        borsh.u128("lastRebalanceUpperResetPoolPrice"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new RebalancePricePercentageWithResetState({
+      lastRebalanceLowerResetPoolPrice: obj.lastRebalanceLowerResetPoolPrice,
+      lastRebalanceUpperResetPoolPrice: obj.lastRebalanceUpperResetPoolPrice,
+    })
+  }
+
+  static toEncodable(fields: RebalancePricePercentageWithResetStateFields) {
+    return {
+      lastRebalanceLowerResetPoolPrice: fields.lastRebalanceLowerResetPoolPrice,
+      lastRebalanceUpperResetPoolPrice: fields.lastRebalanceUpperResetPoolPrice,
+    }
+  }
+
+  toJSON(): RebalancePricePercentageWithResetStateJSON {
+    return {
+      lastRebalanceLowerResetPoolPrice:
+        this.lastRebalanceLowerResetPoolPrice.toString(),
+      lastRebalanceUpperResetPoolPrice:
+        this.lastRebalanceUpperResetPoolPrice.toString(),
+    }
+  }
+
+  static fromJSON(
+    obj: RebalancePricePercentageWithResetStateJSON
+  ): RebalancePricePercentageWithResetState {
+    return new RebalancePricePercentageWithResetState({
+      lastRebalanceLowerResetPoolPrice: new BN(
+        obj.lastRebalanceLowerResetPoolPrice
+      ),
+      lastRebalanceUpperResetPoolPrice: new BN(
+        obj.lastRebalanceUpperResetPoolPrice
+      ),
+    })
+  }
+
+  toEncodable() {
+    return RebalancePricePercentageWithResetState.toEncodable(this)
+  }
+}

package/src/kamino-client/types/RebalanceRaw.ts

@@ -0,0 +1,76 @@
+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 RebalanceRawFields {
+  params: Array<number>
+  state: Array<number>
+  referencePriceType: number
+}
+
+export interface RebalanceRawJSON {
+  params: Array<number>
+  state: Array<number>
+  referencePriceType: number
+}
+
+export class RebalanceRaw {
+  readonly params: Array<number>
+  readonly state: Array<number>
+  readonly referencePriceType: number
+
+  constructor(fields: RebalanceRawFields) {
+    this.params = fields.params
+    this.state = fields.state
+    this.referencePriceType = fields.referencePriceType
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.array(borsh.u8(), 128, "params"),
+        borsh.array(borsh.u8(), 256, "state"),
+        borsh.u8("referencePriceType"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new RebalanceRaw({
+      params: obj.params,
+      state: obj.state,
+      referencePriceType: obj.referencePriceType,
+    })
+  }
+
+  static toEncodable(fields: RebalanceRawFields) {
+    return {
+      params: fields.params,
+      state: fields.state,
+      referencePriceType: fields.referencePriceType,
+    }
+  }
+
+  toJSON(): RebalanceRawJSON {
+    return {
+      params: this.params,
+      state: this.state,
+      referencePriceType: this.referencePriceType,
+    }
+  }
+
+  static fromJSON(obj: RebalanceRawJSON): RebalanceRaw {
+    return new RebalanceRaw({
+      params: obj.params,
+      state: obj.state,
+      referencePriceType: obj.referencePriceType,
+    })
+  }
+
+  toEncodable() {
+    return RebalanceRaw.toEncodable(this)
+  }
+}

package/src/kamino-client/types/RebalanceTakeProfitState.ts

@@ -0,0 +1,56 @@
+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 RebalanceTakeProfitStateFields {
+  step: types.RebalanceTakeProfitStepKind
+}
+
+export interface RebalanceTakeProfitStateJSON {
+  step: types.RebalanceTakeProfitStepJSON
+}
+
+export class RebalanceTakeProfitState {
+  readonly step: types.RebalanceTakeProfitStepKind
+
+  constructor(fields: RebalanceTakeProfitStateFields) {
+    this.step = fields.step
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [types.RebalanceTakeProfitStep.layout("step")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new RebalanceTakeProfitState({
+      step: types.RebalanceTakeProfitStep.fromDecoded(obj.step),
+    })
+  }
+
+  static toEncodable(fields: RebalanceTakeProfitStateFields) {
+    return {
+      step: fields.step.toEncodable(),
+    }
+  }
+
+  toJSON(): RebalanceTakeProfitStateJSON {
+    return {
+      step: this.step.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: RebalanceTakeProfitStateJSON): RebalanceTakeProfitState {
+    return new RebalanceTakeProfitState({
+      step: types.RebalanceTakeProfitStep.fromJSON(obj.step),
+    })
+  }
+
+  toEncodable() {
+    return RebalanceTakeProfitState.toEncodable(this)
+  }
+}

package/src/kamino-client/types/RebalanceTakeProfitStep.ts

@@ -0,0 +1,120 @@
+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 TakingProfitJSON {
+  kind: "TakingProfit"
+}
+
+export class TakingProfit {
+  static readonly discriminator = 1
+  static readonly kind = "TakingProfit"
+  readonly discriminator = 1
+  readonly kind = "TakingProfit"
+
+  toJSON(): TakingProfitJSON {
+    return {
+      kind: "TakingProfit",
+    }
+  }
+
+  toEncodable() {
+    return {
+      TakingProfit: {},
+    }
+  }
+}
+
+export interface FinishedJSON {
+  kind: "Finished"
+}
+
+export class Finished {
+  static readonly discriminator = 2
+  static readonly kind = "Finished"
+  readonly discriminator = 2
+  readonly kind = "Finished"
+
+  toJSON(): FinishedJSON {
+    return {
+      kind: "Finished",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Finished: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.RebalanceTakeProfitStepKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Uninitialized" in obj) {
+    return new Uninitialized()
+  }
+  if ("TakingProfit" in obj) {
+    return new TakingProfit()
+  }
+  if ("Finished" in obj) {
+    return new Finished()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.RebalanceTakeProfitStepJSON
+): types.RebalanceTakeProfitStepKind {
+  switch (obj.kind) {
+    case "Uninitialized": {
+      return new Uninitialized()
+    }
+    case "TakingProfit": {
+      return new TakingProfit()
+    }
+    case "Finished": {
+      return new Finished()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Uninitialized"),
+    borsh.struct([], "TakingProfit"),
+    borsh.struct([], "Finished"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/kamino-client/types/RebalanceTakeProfitToken.ts

@@ -0,0 +1,87 @@
+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 AJSON {
+  kind: "A"
+}
+
+export class A {
+  static readonly discriminator = 0
+  static readonly kind = "A"
+  readonly discriminator = 0
+  readonly kind = "A"
+
+  toJSON(): AJSON {
+    return {
+      kind: "A",
+    }
+  }
+
+  toEncodable() {
+    return {
+      A: {},
+    }
+  }
+}
+
+export interface BJSON {
+  kind: "B"
+}
+
+export class B {
+  static readonly discriminator = 1
+  static readonly kind = "B"
+  readonly discriminator = 1
+  readonly kind = "B"
+
+  toJSON(): BJSON {
+    return {
+      kind: "B",
+    }
+  }
+
+  toEncodable() {
+    return {
+      B: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.RebalanceTakeProfitTokenKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("A" in obj) {
+    return new A()
+  }
+  if ("B" in obj) {
+    return new B()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.RebalanceTakeProfitTokenJSON
+): types.RebalanceTakeProfitTokenKind {
+  switch (obj.kind) {
+    case "A": {
+      return new A()
+    }
+    case "B": {
+      return new B()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([borsh.struct([], "A"), borsh.struct([], "B")])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}