@kamino-finance/kliquidity-sdk 8.5.1 → 8.5.2-beta.0

package/src/whirlpools-client/instructions/twoHopSwap.ts

@@ -0,0 +1,110 @@
+import { TransactionInstruction, PublicKey, AccountMeta } 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 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 TwoHopSwapArgs {
+  amount: BN
+  otherAmountThreshold: BN
+  amountSpecifiedIsInput: boolean
+  aToBOne: boolean
+  aToBTwo: boolean
+  sqrtPriceLimitOne: BN
+  sqrtPriceLimitTwo: BN
+}
+
+export interface TwoHopSwapAccounts {
+  tokenProgram: PublicKey
+  tokenAuthority: PublicKey
+  whirlpoolOne: PublicKey
+  whirlpoolTwo: PublicKey
+  tokenOwnerAccountOneA: PublicKey
+  tokenVaultOneA: PublicKey
+  tokenOwnerAccountOneB: PublicKey
+  tokenVaultOneB: PublicKey
+  tokenOwnerAccountTwoA: PublicKey
+  tokenVaultTwoA: PublicKey
+  tokenOwnerAccountTwoB: PublicKey
+  tokenVaultTwoB: PublicKey
+  tickArrayOne0: PublicKey
+  tickArrayOne1: PublicKey
+  tickArrayOne2: PublicKey
+  tickArrayTwo0: PublicKey
+  tickArrayTwo1: PublicKey
+  tickArrayTwo2: PublicKey
+  oracleOne: PublicKey
+  oracleTwo: PublicKey
+}
+
+export const layout = borsh.struct([
+  borsh.u64("amount"),
+  borsh.u64("otherAmountThreshold"),
+  borsh.bool("amountSpecifiedIsInput"),
+  borsh.bool("aToBOne"),
+  borsh.bool("aToBTwo"),
+  borsh.u128("sqrtPriceLimitOne"),
+  borsh.u128("sqrtPriceLimitTwo"),
+])
+
+export function twoHopSwap(
+  args: TwoHopSwapArgs,
+  accounts: TwoHopSwapAccounts,
+  programId: PublicKey = PROGRAM_ID
+) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenAuthority, isSigner: true, isWritable: false },
+    { pubkey: accounts.whirlpoolOne, isSigner: false, isWritable: true },
+    { pubkey: accounts.whirlpoolTwo, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.tokenOwnerAccountOneA,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.tokenVaultOneA, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.tokenOwnerAccountOneB,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.tokenVaultOneB, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.tokenOwnerAccountTwoA,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.tokenVaultTwoA, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.tokenOwnerAccountTwoB,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.tokenVaultTwoB, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayOne0, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayOne1, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayOne2, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayTwo0, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayTwo1, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayTwo2, isSigner: false, isWritable: true },
+    { pubkey: accounts.oracleOne, isSigner: false, isWritable: false },
+    { pubkey: accounts.oracleTwo, isSigner: false, isWritable: false },
+  ]
+  const identifier = Buffer.from([195, 96, 237, 108, 68, 162, 219, 230])
+  const buffer = Buffer.alloc(1000)
+  const len = layout.encode(
+    {
+      amount: args.amount,
+      otherAmountThreshold: args.otherAmountThreshold,
+      amountSpecifiedIsInput: args.amountSpecifiedIsInput,
+      aToBOne: args.aToBOne,
+      aToBTwo: args.aToBTwo,
+      sqrtPriceLimitOne: args.sqrtPriceLimitOne,
+      sqrtPriceLimitTwo: args.sqrtPriceLimitTwo,
+    },
+    buffer
+  )
+  const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len)
+  const ix = new TransactionInstruction({ keys, programId, data })
+  return ix
+}

package/src/whirlpools-client/instructions/twoHopSwapV2.ts

@@ -0,0 +1,134 @@
+import { TransactionInstruction, PublicKey, AccountMeta } 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 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 TwoHopSwapV2Args {
+  amount: BN
+  otherAmountThreshold: BN
+  amountSpecifiedIsInput: boolean
+  aToBOne: boolean
+  aToBTwo: boolean
+  sqrtPriceLimitOne: BN
+  sqrtPriceLimitTwo: BN
+  remainingAccountsInfo: types.RemainingAccountsInfoFields | null
+}
+
+export interface TwoHopSwapV2Accounts {
+  whirlpoolOne: PublicKey
+  whirlpoolTwo: PublicKey
+  tokenMintInput: PublicKey
+  tokenMintIntermediate: PublicKey
+  tokenMintOutput: PublicKey
+  tokenProgramInput: PublicKey
+  tokenProgramIntermediate: PublicKey
+  tokenProgramOutput: PublicKey
+  tokenOwnerAccountInput: PublicKey
+  tokenVaultOneInput: PublicKey
+  tokenVaultOneIntermediate: PublicKey
+  tokenVaultTwoIntermediate: PublicKey
+  tokenVaultTwoOutput: PublicKey
+  tokenOwnerAccountOutput: PublicKey
+  tokenAuthority: PublicKey
+  tickArrayOne0: PublicKey
+  tickArrayOne1: PublicKey
+  tickArrayOne2: PublicKey
+  tickArrayTwo0: PublicKey
+  tickArrayTwo1: PublicKey
+  tickArrayTwo2: PublicKey
+  oracleOne: PublicKey
+  oracleTwo: PublicKey
+  memoProgram: PublicKey
+}
+
+export const layout = borsh.struct([
+  borsh.u64("amount"),
+  borsh.u64("otherAmountThreshold"),
+  borsh.bool("amountSpecifiedIsInput"),
+  borsh.bool("aToBOne"),
+  borsh.bool("aToBTwo"),
+  borsh.u128("sqrtPriceLimitOne"),
+  borsh.u128("sqrtPriceLimitTwo"),
+  borsh.option(types.RemainingAccountsInfo.layout(), "remainingAccountsInfo"),
+])
+
+export function twoHopSwapV2(
+  args: TwoHopSwapV2Args,
+  accounts: TwoHopSwapV2Accounts,
+  programId: PublicKey = PROGRAM_ID
+) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.whirlpoolOne, isSigner: false, isWritable: true },
+    { pubkey: accounts.whirlpoolTwo, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenMintInput, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.tokenMintIntermediate,
+      isSigner: false,
+      isWritable: false,
+    },
+    { pubkey: accounts.tokenMintOutput, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgramInput, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.tokenProgramIntermediate,
+      isSigner: false,
+      isWritable: false,
+    },
+    { pubkey: accounts.tokenProgramOutput, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.tokenOwnerAccountInput,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.tokenVaultOneInput, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.tokenVaultOneIntermediate,
+      isSigner: false,
+      isWritable: true,
+    },
+    {
+      pubkey: accounts.tokenVaultTwoIntermediate,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.tokenVaultTwoOutput, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.tokenOwnerAccountOutput,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.tokenAuthority, isSigner: true, isWritable: false },
+    { pubkey: accounts.tickArrayOne0, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayOne1, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayOne2, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayTwo0, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayTwo1, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayTwo2, isSigner: false, isWritable: true },
+    { pubkey: accounts.oracleOne, isSigner: false, isWritable: true },
+    { pubkey: accounts.oracleTwo, isSigner: false, isWritable: true },
+    { pubkey: accounts.memoProgram, isSigner: false, isWritable: false },
+  ]
+  const identifier = Buffer.from([186, 143, 209, 29, 254, 2, 194, 117])
+  const buffer = Buffer.alloc(1000)
+  const len = layout.encode(
+    {
+      amount: args.amount,
+      otherAmountThreshold: args.otherAmountThreshold,
+      amountSpecifiedIsInput: args.amountSpecifiedIsInput,
+      aToBOne: args.aToBOne,
+      aToBTwo: args.aToBTwo,
+      sqrtPriceLimitOne: args.sqrtPriceLimitOne,
+      sqrtPriceLimitTwo: args.sqrtPriceLimitTwo,
+      remainingAccountsInfo:
+        (args.remainingAccountsInfo &&
+          types.RemainingAccountsInfo.toEncodable(
+            args.remainingAccountsInfo
+          )) ||
+        null,
+    },
+    buffer
+  )
+  const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len)
+  const ix = new TransactionInstruction({ keys, programId, data })
+  return ix
+}

package/src/whirlpools-client/instructions/updateFeesAndRewards.ts

@@ -0,0 +1,28 @@
+import { TransactionInstruction, PublicKey, AccountMeta } 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 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 UpdateFeesAndRewardsAccounts {
+  whirlpool: PublicKey
+  position: PublicKey
+  tickArrayLower: PublicKey
+  tickArrayUpper: PublicKey
+}
+
+export function updateFeesAndRewards(
+  accounts: UpdateFeesAndRewardsAccounts,
+  programId: PublicKey = PROGRAM_ID
+) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.whirlpool, isSigner: false, isWritable: true },
+    { pubkey: accounts.position, isSigner: false, isWritable: true },
+    { pubkey: accounts.tickArrayLower, isSigner: false, isWritable: false },
+    { pubkey: accounts.tickArrayUpper, isSigner: false, isWritable: false },
+  ]
+  const identifier = Buffer.from([154, 230, 250, 13, 236, 209, 75, 223])
+  const data = identifier
+  const ix = new TransactionInstruction({ keys, programId, data })
+  return ix
+}

package/src/whirlpools-client/programId.ts

@@ -0,0 +1,14 @@
+import { PublicKey } from "@solana/web3.js"
+
+// Program ID passed with the cli --program-id flag when running the code generator. Do not edit, it will get overwritten.
+export const PROGRAM_ID_CLI = new PublicKey(
+  "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
+)
+
+// This constant will not get overwritten on subsequent code generations and it's safe to modify it's value.
+export let WHIRLPOOL_PROGRAM_ID: PublicKey = PROGRAM_ID_CLI;
+export let PROGRAM_ID: PublicKey = PROGRAM_ID_CLI;
+export const setWhirlpoolsProgramId = (programId: PublicKey) => {
+  WHIRLPOOL_PROGRAM_ID = programId;
+  PROGRAM_ID = programId;
+};

package/src/whirlpools-client/shim/remove-liquidity.ts

@@ -0,0 +1,128 @@
+// Source: https://raw.githubusercontent.com/orca-so/whirlpool-sdk/main/src/position/quotes/remove-liquidity.ts
+/**
+ * Added roundUp flag to accurately estimate token holdings for deposits
+ */
+import { tickIndexToSqrtPriceX64 } from "@orca-so/whirlpool-client-sdk";
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import {
+  adjustForSlippage, getTokenAFromLiquidity,
+  getTokenBFromLiquidity, Percentage, PositionStatus, PositionUtil, RemoveLiquidityQuote,
+} from '@orca-so/whirlpool-sdk';
+import { ZERO_BN } from "../../utils";
+
+export type InternalRemoveLiquidityQuoteParam = {
+  positionAddress: PublicKey;
+  tickCurrentIndex: number;
+  sqrtPrice: BN;
+  tickLowerIndex: number;
+  tickUpperIndex: number;
+  liquidity: BN;
+  slippageTolerance: Percentage;
+};
+
+export function getRemoveLiquidityQuote(
+  param: InternalRemoveLiquidityQuoteParam,
+  roundUp: boolean = false,
+): RemoveLiquidityQuote {
+  const positionStatus = PositionUtil.getPositionStatus(
+    param.tickCurrentIndex,
+    param.tickLowerIndex,
+    param.tickUpperIndex
+  );
+
+  switch (positionStatus) {
+    case PositionStatus.BelowRange:
+      return getRemoveLiquidityQuoteWhenPositionIsBelowRange(param, roundUp);
+    case PositionStatus.InRange:
+      return getRemoveLiquidityQuoteWhenPositionIsInRange(param, roundUp);
+    case PositionStatus.AboveRange:
+      return getRemoveLiquidityQuoteWhenPositionIsAboveRange(param, roundUp);
+    default:
+      throw new Error(`type ${positionStatus} is an unknown PositionStatus`);
+  }
+}
+
+function getRemoveLiquidityQuoteWhenPositionIsBelowRange(
+  param: InternalRemoveLiquidityQuoteParam,
+  roundUp: boolean = false,
+): RemoveLiquidityQuote {
+  const { positionAddress, tickLowerIndex, tickUpperIndex, liquidity, slippageTolerance } = param;
+
+  const sqrtPriceLowerX64 = tickIndexToSqrtPriceX64(tickLowerIndex);
+  const sqrtPriceUpperX64 = tickIndexToSqrtPriceX64(tickUpperIndex);
+
+  const estTokenA = getTokenAFromLiquidity(liquidity, sqrtPriceLowerX64, sqrtPriceUpperX64, roundUp);
+  const minTokenA = adjustForSlippage(estTokenA, slippageTolerance, roundUp);
+
+  return {
+    positionAddress,
+    minTokenA,
+    minTokenB: ZERO_BN,
+    estTokenA,
+    estTokenB: ZERO_BN,
+    liquidity,
+  };
+}
+
+function getRemoveLiquidityQuoteWhenPositionIsInRange(
+  param: InternalRemoveLiquidityQuoteParam,
+  roundUp: boolean = false,
+): RemoveLiquidityQuote {
+  const {
+    positionAddress,
+    sqrtPrice,
+    tickLowerIndex,
+    tickUpperIndex,
+    liquidity,
+    slippageTolerance,
+  } = param;
+
+  const sqrtPriceX64 = sqrtPrice;
+  const sqrtPriceLowerX64 = tickIndexToSqrtPriceX64(tickLowerIndex);
+  const sqrtPriceUpperX64 = tickIndexToSqrtPriceX64(tickUpperIndex);
+
+  const estTokenA = getTokenAFromLiquidity(liquidity, sqrtPriceX64, sqrtPriceUpperX64, roundUp);
+  const minTokenA = adjustForSlippage(estTokenA, slippageTolerance, roundUp);
+
+  const estTokenB = getTokenBFromLiquidity(liquidity, sqrtPriceLowerX64, sqrtPriceX64, roundUp);
+  const minTokenB = adjustForSlippage(estTokenB, slippageTolerance, roundUp);
+
+  return {
+    positionAddress,
+    minTokenA,
+    minTokenB,
+    estTokenA,
+    estTokenB,
+    liquidity,
+  };
+}
+
+function getRemoveLiquidityQuoteWhenPositionIsAboveRange(
+  param: InternalRemoveLiquidityQuoteParam,
+  roundUp: boolean = false,
+
+): RemoveLiquidityQuote {
+  const {
+    positionAddress,
+    tickLowerIndex,
+    tickUpperIndex,
+    liquidity,
+    slippageTolerance: slippageTolerance,
+  } = param;
+
+  const sqrtPriceLowerX64 = tickIndexToSqrtPriceX64(tickLowerIndex);
+  const sqrtPriceUpperX64 = tickIndexToSqrtPriceX64(tickUpperIndex);
+
+  const estTokenB = getTokenBFromLiquidity(liquidity, sqrtPriceLowerX64, sqrtPriceUpperX64, roundUp);
+  const minTokenB = adjustForSlippage(estTokenB, slippageTolerance, roundUp);
+
+  return {
+    positionAddress,
+    minTokenA: ZERO_BN,
+    minTokenB,
+    estTokenA: ZERO_BN,
+    estTokenB,
+    liquidity,
+  };
+}

package/src/whirlpools-client/types/AccountsType.ts

@@ -0,0 +1,208 @@
+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 TransferHookAJSON {
+  kind: "TransferHookA"
+}
+
+export class TransferHookA {
+  static readonly discriminator = 0
+  static readonly kind = "TransferHookA"
+  readonly discriminator = 0
+  readonly kind = "TransferHookA"
+
+  toJSON(): TransferHookAJSON {
+    return {
+      kind: "TransferHookA",
+    }
+  }
+
+  toEncodable() {
+    return {
+      TransferHookA: {},
+    }
+  }
+}
+
+export interface TransferHookBJSON {
+  kind: "TransferHookB"
+}
+
+export class TransferHookB {
+  static readonly discriminator = 1
+  static readonly kind = "TransferHookB"
+  readonly discriminator = 1
+  readonly kind = "TransferHookB"
+
+  toJSON(): TransferHookBJSON {
+    return {
+      kind: "TransferHookB",
+    }
+  }
+
+  toEncodable() {
+    return {
+      TransferHookB: {},
+    }
+  }
+}
+
+export interface TransferHookRewardJSON {
+  kind: "TransferHookReward"
+}
+
+export class TransferHookReward {
+  static readonly discriminator = 2
+  static readonly kind = "TransferHookReward"
+  readonly discriminator = 2
+  readonly kind = "TransferHookReward"
+
+  toJSON(): TransferHookRewardJSON {
+    return {
+      kind: "TransferHookReward",
+    }
+  }
+
+  toEncodable() {
+    return {
+      TransferHookReward: {},
+    }
+  }
+}
+
+export interface TransferHookInputJSON {
+  kind: "TransferHookInput"
+}
+
+export class TransferHookInput {
+  static readonly discriminator = 3
+  static readonly kind = "TransferHookInput"
+  readonly discriminator = 3
+  readonly kind = "TransferHookInput"
+
+  toJSON(): TransferHookInputJSON {
+    return {
+      kind: "TransferHookInput",
+    }
+  }
+
+  toEncodable() {
+    return {
+      TransferHookInput: {},
+    }
+  }
+}
+
+export interface TransferHookIntermediateJSON {
+  kind: "TransferHookIntermediate"
+}
+
+export class TransferHookIntermediate {
+  static readonly discriminator = 4
+  static readonly kind = "TransferHookIntermediate"
+  readonly discriminator = 4
+  readonly kind = "TransferHookIntermediate"
+
+  toJSON(): TransferHookIntermediateJSON {
+    return {
+      kind: "TransferHookIntermediate",
+    }
+  }
+
+  toEncodable() {
+    return {
+      TransferHookIntermediate: {},
+    }
+  }
+}
+
+export interface TransferHookOutputJSON {
+  kind: "TransferHookOutput"
+}
+
+export class TransferHookOutput {
+  static readonly discriminator = 5
+  static readonly kind = "TransferHookOutput"
+  readonly discriminator = 5
+  readonly kind = "TransferHookOutput"
+
+  toJSON(): TransferHookOutputJSON {
+    return {
+      kind: "TransferHookOutput",
+    }
+  }
+
+  toEncodable() {
+    return {
+      TransferHookOutput: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.AccountsTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("TransferHookA" in obj) {
+    return new TransferHookA()
+  }
+  if ("TransferHookB" in obj) {
+    return new TransferHookB()
+  }
+  if ("TransferHookReward" in obj) {
+    return new TransferHookReward()
+  }
+  if ("TransferHookInput" in obj) {
+    return new TransferHookInput()
+  }
+  if ("TransferHookIntermediate" in obj) {
+    return new TransferHookIntermediate()
+  }
+  if ("TransferHookOutput" in obj) {
+    return new TransferHookOutput()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.AccountsTypeJSON): types.AccountsTypeKind {
+  switch (obj.kind) {
+    case "TransferHookA": {
+      return new TransferHookA()
+    }
+    case "TransferHookB": {
+      return new TransferHookB()
+    }
+    case "TransferHookReward": {
+      return new TransferHookReward()
+    }
+    case "TransferHookInput": {
+      return new TransferHookInput()
+    }
+    case "TransferHookIntermediate": {
+      return new TransferHookIntermediate()
+    }
+    case "TransferHookOutput": {
+      return new TransferHookOutput()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "TransferHookA"),
+    borsh.struct([], "TransferHookB"),
+    borsh.struct([], "TransferHookReward"),
+    borsh.struct([], "TransferHookInput"),
+    borsh.struct([], "TransferHookIntermediate"),
+    borsh.struct([], "TransferHookOutput"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}