@kamino-finance/klend-sdk 3.2.26 → 4.0.0

package/src/idl_codegen_kamino_vault/errors/custom.ts

@@ -0,0 +1,344 @@
+export type CustomError =
+  | DepositAmountsZero
+  | SharesIssuedAmountDoesNotMatch
+  | MathOverflow
+  | IntegerOverflow
+  | CannotWithdrawZeroAmount
+  | TooMuchLiquidityToWithdraw
+  | ReserveAlreadyExists
+  | ReserveNotPartOfAllocations
+  | CouldNotDeserializeAccountAsReserve
+  | ReserveNotProvidedInTheAccounts
+  | ReserveAccountAndKeyMismatch
+  | OutOfRangeOfReserveIndex
+  | CannotFindReserveInAllocations
+  | CannotInvestZeroAmount
+  | SlotDecreased
+  | AdminAuthorityIncorrect
+  | BaseVaultAuthorityIncorrect
+  | BaseVaultAuthorityBumpIncorrect
+  | TokenMintIncorrect
+  | TokenMintDecimalsIncorrect
+  | TokenVaultIncorrect
+  | SharesMintDecimalsIncorrect
+  | SharesMintIncorrect
+  | InitialAccountintIncorrect;
+
+export class DepositAmountsZero extends Error {
+  static readonly code = 6000;
+  readonly code = 6000;
+  readonly name = 'DepositAmountsZero';
+  readonly msg = 'DepositAmountsZero';
+
+  constructor(readonly logs?: string[]) {
+    super('6000: DepositAmountsZero');
+  }
+}
+
+export class SharesIssuedAmountDoesNotMatch extends Error {
+  static readonly code = 6001;
+  readonly code = 6001;
+  readonly name = 'SharesIssuedAmountDoesNotMatch';
+  readonly msg = 'SharesIssuedAmountDoesNotMatch';
+
+  constructor(readonly logs?: string[]) {
+    super('6001: SharesIssuedAmountDoesNotMatch');
+  }
+}
+
+export class MathOverflow extends Error {
+  static readonly code = 6002;
+  readonly code = 6002;
+  readonly name = 'MathOverflow';
+  readonly msg = 'MathOverflow';
+
+  constructor(readonly logs?: string[]) {
+    super('6002: MathOverflow');
+  }
+}
+
+export class IntegerOverflow extends Error {
+  static readonly code = 6003;
+  readonly code = 6003;
+  readonly name = 'IntegerOverflow';
+  readonly msg = 'IntegerOverflow';
+
+  constructor(readonly logs?: string[]) {
+    super('6003: IntegerOverflow');
+  }
+}
+
+export class CannotWithdrawZeroAmount extends Error {
+  static readonly code = 6004;
+  readonly code = 6004;
+  readonly name = 'CannotWithdrawZeroAmount';
+  readonly msg = 'CannotWithdrawZeroAmount';
+
+  constructor(readonly logs?: string[]) {
+    super('6004: CannotWithdrawZeroAmount');
+  }
+}
+
+export class TooMuchLiquidityToWithdraw extends Error {
+  static readonly code = 6005;
+  readonly code = 6005;
+  readonly name = 'TooMuchLiquidityToWithdraw';
+  readonly msg = 'TooMuchLiquidityToWithdraw';
+
+  constructor(readonly logs?: string[]) {
+    super('6005: TooMuchLiquidityToWithdraw');
+  }
+}
+
+export class ReserveAlreadyExists extends Error {
+  static readonly code = 6006;
+  readonly code = 6006;
+  readonly name = 'ReserveAlreadyExists';
+  readonly msg = 'ReserveAlreadyExists';
+
+  constructor(readonly logs?: string[]) {
+    super('6006: ReserveAlreadyExists');
+  }
+}
+
+export class ReserveNotPartOfAllocations extends Error {
+  static readonly code = 6007;
+  readonly code = 6007;
+  readonly name = 'ReserveNotPartOfAllocations';
+  readonly msg = 'ReserveNotPartOfAllocations';
+
+  constructor(readonly logs?: string[]) {
+    super('6007: ReserveNotPartOfAllocations');
+  }
+}
+
+export class CouldNotDeserializeAccountAsReserve extends Error {
+  static readonly code = 6008;
+  readonly code = 6008;
+  readonly name = 'CouldNotDeserializeAccountAsReserve';
+  readonly msg = 'CouldNotDeserializeAccountAsReserve';
+
+  constructor(readonly logs?: string[]) {
+    super('6008: CouldNotDeserializeAccountAsReserve');
+  }
+}
+
+export class ReserveNotProvidedInTheAccounts extends Error {
+  static readonly code = 6009;
+  readonly code = 6009;
+  readonly name = 'ReserveNotProvidedInTheAccounts';
+  readonly msg = 'ReserveNotProvidedInTheAccounts';
+
+  constructor(readonly logs?: string[]) {
+    super('6009: ReserveNotProvidedInTheAccounts');
+  }
+}
+
+export class ReserveAccountAndKeyMismatch extends Error {
+  static readonly code = 6010;
+  readonly code = 6010;
+  readonly name = 'ReserveAccountAndKeyMismatch';
+  readonly msg = 'ReserveAccountAndKeyMismatch';
+
+  constructor(readonly logs?: string[]) {
+    super('6010: ReserveAccountAndKeyMismatch');
+  }
+}
+
+export class OutOfRangeOfReserveIndex extends Error {
+  static readonly code = 6011;
+  readonly code = 6011;
+  readonly name = 'OutOfRangeOfReserveIndex';
+  readonly msg = 'OutOfRangeOfReserveIndex';
+
+  constructor(readonly logs?: string[]) {
+    super('6011: OutOfRangeOfReserveIndex');
+  }
+}
+
+export class CannotFindReserveInAllocations extends Error {
+  static readonly code = 6012;
+  readonly code = 6012;
+  readonly name = 'CannotFindReserveInAllocations';
+  readonly msg = 'OutOfRangeOfReserveIndex';
+
+  constructor(readonly logs?: string[]) {
+    super('6012: OutOfRangeOfReserveIndex');
+  }
+}
+
+export class CannotInvestZeroAmount extends Error {
+  static readonly code = 6013;
+  readonly code = 6013;
+  readonly name = 'CannotInvestZeroAmount';
+  readonly msg = 'CannotInvestZeroAmount';
+
+  constructor(readonly logs?: string[]) {
+    super('6013: CannotInvestZeroAmount');
+  }
+}
+
+export class SlotDecreased extends Error {
+  static readonly code = 6014;
+  readonly code = 6014;
+  readonly name = 'SlotDecreased';
+  readonly msg = 'SlotDecreased';
+
+  constructor(readonly logs?: string[]) {
+    super('6014: SlotDecreased');
+  }
+}
+
+export class AdminAuthorityIncorrect extends Error {
+  static readonly code = 6015;
+  readonly code = 6015;
+  readonly name = 'AdminAuthorityIncorrect';
+  readonly msg = 'AdminAuthorityIncorrect';
+
+  constructor(readonly logs?: string[]) {
+    super('6015: AdminAuthorityIncorrect');
+  }
+}
+
+export class BaseVaultAuthorityIncorrect extends Error {
+  static readonly code = 6016;
+  readonly code = 6016;
+  readonly name = 'BaseVaultAuthorityIncorrect';
+  readonly msg = 'BaseVaultAuthorityIncorrect';
+
+  constructor(readonly logs?: string[]) {
+    super('6016: BaseVaultAuthorityIncorrect');
+  }
+}
+
+export class BaseVaultAuthorityBumpIncorrect extends Error {
+  static readonly code = 6017;
+  readonly code = 6017;
+  readonly name = 'BaseVaultAuthorityBumpIncorrect';
+  readonly msg = 'BaseVaultAuthorityBumpIncorrect';
+
+  constructor(readonly logs?: string[]) {
+    super('6017: BaseVaultAuthorityBumpIncorrect');
+  }
+}
+
+export class TokenMintIncorrect extends Error {
+  static readonly code = 6018;
+  readonly code = 6018;
+  readonly name = 'TokenMintIncorrect';
+  readonly msg = 'TokenMintIncorrect';
+
+  constructor(readonly logs?: string[]) {
+    super('6018: TokenMintIncorrect');
+  }
+}
+
+export class TokenMintDecimalsIncorrect extends Error {
+  static readonly code = 6019;
+  readonly code = 6019;
+  readonly name = 'TokenMintDecimalsIncorrect';
+  readonly msg = 'TokenMintDecimalsIncorrect';
+
+  constructor(readonly logs?: string[]) {
+    super('6019: TokenMintDecimalsIncorrect');
+  }
+}
+
+export class TokenVaultIncorrect extends Error {
+  static readonly code = 6020;
+  readonly code = 6020;
+  readonly name = 'TokenVaultIncorrect';
+  readonly msg = 'TokenVaultIncorrect';
+
+  constructor(readonly logs?: string[]) {
+    super('6020: TokenVaultIncorrect');
+  }
+}
+
+export class SharesMintDecimalsIncorrect extends Error {
+  static readonly code = 6021;
+  readonly code = 6021;
+  readonly name = 'SharesMintDecimalsIncorrect';
+  readonly msg = 'SharesMintDecimalsIncorrect';
+
+  constructor(readonly logs?: string[]) {
+    super('6021: SharesMintDecimalsIncorrect');
+  }
+}
+
+export class SharesMintIncorrect extends Error {
+  static readonly code = 6022;
+  readonly code = 6022;
+  readonly name = 'SharesMintIncorrect';
+  readonly msg = 'SharesMintIncorrect';
+
+  constructor(readonly logs?: string[]) {
+    super('6022: SharesMintIncorrect');
+  }
+}
+
+export class InitialAccountintIncorrect extends Error {
+  static readonly code = 6023;
+  readonly code = 6023;
+  readonly name = 'InitialAccountintIncorrect';
+  readonly msg = 'InitialAccountintIncorrect';
+
+  constructor(readonly logs?: string[]) {
+    super('6023: InitialAccountintIncorrect');
+  }
+}
+
+export function fromCode(code: number, logs?: string[]): CustomError | null {
+  switch (code) {
+    case 6000:
+      return new DepositAmountsZero(logs);
+    case 6001:
+      return new SharesIssuedAmountDoesNotMatch(logs);
+    case 6002:
+      return new MathOverflow(logs);
+    case 6003:
+      return new IntegerOverflow(logs);
+    case 6004:
+      return new CannotWithdrawZeroAmount(logs);
+    case 6005:
+      return new TooMuchLiquidityToWithdraw(logs);
+    case 6006:
+      return new ReserveAlreadyExists(logs);
+    case 6007:
+      return new ReserveNotPartOfAllocations(logs);
+    case 6008:
+      return new CouldNotDeserializeAccountAsReserve(logs);
+    case 6009:
+      return new ReserveNotProvidedInTheAccounts(logs);
+    case 6010:
+      return new ReserveAccountAndKeyMismatch(logs);
+    case 6011:
+      return new OutOfRangeOfReserveIndex(logs);
+    case 6012:
+      return new CannotFindReserveInAllocations(logs);
+    case 6013:
+      return new CannotInvestZeroAmount(logs);
+    case 6014:
+      return new SlotDecreased(logs);
+    case 6015:
+      return new AdminAuthorityIncorrect(logs);
+    case 6016:
+      return new BaseVaultAuthorityIncorrect(logs);
+    case 6017:
+      return new BaseVaultAuthorityBumpIncorrect(logs);
+    case 6018:
+      return new TokenMintIncorrect(logs);
+    case 6019:
+      return new TokenMintDecimalsIncorrect(logs);
+    case 6020:
+      return new TokenVaultIncorrect(logs);
+    case 6021:
+      return new SharesMintDecimalsIncorrect(logs);
+    case 6022:
+      return new SharesMintIncorrect(logs);
+    case 6023:
+      return new InitialAccountintIncorrect(logs);
+  }
+
+  return null;
+}

package/src/idl_codegen_kamino_vault/errors/index.ts

@@ -0,0 +1,49 @@
+import { PublicKey } from '@solana/web3.js';
+import { PROGRAM_ID } from '../programId';
+import * as anchor from './anchor';
+import * as custom from './custom';
+
+export function fromCode(code: number, logs?: string[]): custom.CustomError | anchor.AnchorError | null {
+  return code >= 6000 ? custom.fromCode(code, logs) : anchor.fromCode(code, logs);
+}
+
+function hasOwnProperty<X extends object, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown> {
+  return Object.hasOwnProperty.call(obj, prop);
+}
+
+const errorRe = /Program (\w+) failed: custom program error: (\w+)/;
+
+export function fromTxError(
+  err: unknown,
+  programId: PublicKey = PROGRAM_ID
+): custom.CustomError | anchor.AnchorError | null {
+  if (typeof err !== 'object' || err === null || !hasOwnProperty(err, 'logs') || !Array.isArray(err.logs)) {
+    return null;
+  }
+
+  let firstMatch: RegExpExecArray | null = null;
+  for (const logLine of err.logs) {
+    firstMatch = errorRe.exec(logLine);
+    if (firstMatch !== null) {
+      break;
+    }
+  }
+
+  if (firstMatch === null) {
+    return null;
+  }
+
+  const [programIdRaw, codeRaw] = firstMatch.slice(1);
+  if (programIdRaw !== programId.toString()) {
+    return null;
+  }
+
+  let errorCode: number;
+  try {
+    errorCode = parseInt(codeRaw, 16);
+  } catch (parseErr) {
+    return null;
+  }
+
+  return fromCode(errorCode, err.logs);
+}

package/src/idl_codegen_kamino_vault/instructions/deposit.ts

@@ -0,0 +1,54 @@
+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 DepositArgs {
+  maxAmount: BN;
+}
+
+export interface DepositAccounts {
+  user: PublicKey;
+  vaultState: PublicKey;
+  tokenVault: PublicKey;
+  tokenMint: PublicKey;
+  baseVaultAuthority: PublicKey;
+  sharesMint: PublicKey;
+  tokenAta: PublicKey;
+  userSharesAta: PublicKey;
+  tokenProgram: PublicKey;
+  instructionSysvarAccount: PublicKey;
+}
+
+export const layout = borsh.struct([borsh.u64('maxAmount')]);
+
+export function deposit(args: DepositArgs, accounts: DepositAccounts, programId: PublicKey = PROGRAM_ID) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.user, isSigner: true, isWritable: true },
+    { pubkey: accounts.vaultState, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.baseVaultAuthority, isSigner: false, isWritable: false },
+    { pubkey: accounts.sharesMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.userSharesAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.instructionSysvarAccount,
+      isSigner: false,
+      isWritable: false,
+    },
+  ];
+  const identifier = Buffer.from([242, 35, 198, 137, 82, 225, 242, 182]);
+  const buffer = Buffer.alloc(1000);
+  const len = layout.encode(
+    {
+      maxAmount: args.maxAmount,
+    },
+    buffer
+  );
+  const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}

package/src/idl_codegen_kamino_vault/instructions/index.ts

@@ -0,0 +1,10 @@
+export { initVault } from './initVault';
+export type { InitVaultAccounts } from './initVault';
+export { updateReserveAllocation } from './updateReserveAllocation';
+export type { UpdateReserveAllocationArgs, UpdateReserveAllocationAccounts } from './updateReserveAllocation';
+export { deposit } from './deposit';
+export type { DepositArgs, DepositAccounts } from './deposit';
+export { withdraw } from './withdraw';
+export type { WithdrawArgs, WithdrawAccounts } from './withdraw';
+export { invest } from './invest';
+export type { InvestAccounts } from './invest';

package/src/idl_codegen_kamino_vault/instructions/initVault.ts

@@ -0,0 +1,35 @@
+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 InitVaultAccounts {
+  adminAuthority: PublicKey;
+  vaultState: PublicKey;
+  tokenMint: PublicKey;
+  tokenVault: PublicKey;
+  baseVaultAuthority: PublicKey;
+  sharesMint: PublicKey;
+  systemProgram: PublicKey;
+  rent: PublicKey;
+  tokenProgram: PublicKey;
+}
+
+export function initVault(accounts: InitVaultAccounts, programId: PublicKey = PROGRAM_ID) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.adminAuthority, isSigner: true, isWritable: true },
+    { pubkey: accounts.vaultState, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.baseVaultAuthority, isSigner: false, isWritable: true },
+    { pubkey: accounts.sharesMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.rent, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+  ];
+  const identifier = Buffer.from([77, 79, 85, 150, 33, 217, 52, 106]);
+  const data = identifier;
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}

package/src/idl_codegen_kamino_vault/instructions/invest.ts

@@ -0,0 +1,60 @@
+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 InvestAccounts {
+  adminAuthority: PublicKey;
+  vaultState: PublicKey;
+  tokenVault: PublicKey;
+  baseVaultAuthority: PublicKey;
+  ctokenVault: PublicKey;
+  reserve: PublicKey;
+  /** CPI accounts */
+  lendingMarket: PublicKey;
+  lendingMarketAuthority: PublicKey;
+  reserveLiquiditySupply: PublicKey;
+  reserveCollateralMint: PublicKey;
+  klendProgram: PublicKey;
+  instructionSysvarAccount: PublicKey;
+  tokenProgram: PublicKey;
+}
+
+export function invest(accounts: InvestAccounts, programId: PublicKey = PROGRAM_ID) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.adminAuthority, isSigner: true, isWritable: true },
+    { pubkey: accounts.vaultState, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.baseVaultAuthority, isSigner: false, isWritable: true },
+    { pubkey: accounts.ctokenVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.reserve, isSigner: false, isWritable: true },
+    { pubkey: accounts.lendingMarket, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.lendingMarketAuthority,
+      isSigner: false,
+      isWritable: false,
+    },
+    {
+      pubkey: accounts.reserveLiquiditySupply,
+      isSigner: false,
+      isWritable: true,
+    },
+    {
+      pubkey: accounts.reserveCollateralMint,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.klendProgram, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.instructionSysvarAccount,
+      isSigner: false,
+      isWritable: false,
+    },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+  ];
+  const identifier = Buffer.from([13, 245, 180, 103, 254, 182, 121, 4]);
+  const data = identifier;
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}

package/src/idl_codegen_kamino_vault/instructions/updateReserveAllocation.ts

@@ -0,0 +1,58 @@
+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 UpdateReserveAllocationArgs {
+  weight: BN;
+  cap: BN;
+}
+
+export interface UpdateReserveAllocationAccounts {
+  adminAuthority: PublicKey;
+  vaultState: PublicKey;
+  baseVaultAuthority: PublicKey;
+  reserveCollateralMint: PublicKey;
+  reserve: PublicKey;
+  ctokenVault: PublicKey;
+  systemProgram: PublicKey;
+  rent: PublicKey;
+  tokenProgram: PublicKey;
+}
+
+export const layout = borsh.struct([borsh.u64('weight'), borsh.u64('cap')]);
+
+export function updateReserveAllocation(
+  args: UpdateReserveAllocationArgs,
+  accounts: UpdateReserveAllocationAccounts,
+  programId: PublicKey = PROGRAM_ID
+) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.adminAuthority, isSigner: true, isWritable: true },
+    { pubkey: accounts.vaultState, isSigner: false, isWritable: true },
+    { pubkey: accounts.baseVaultAuthority, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.reserveCollateralMint,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.reserve, isSigner: false, isWritable: false },
+    { pubkey: accounts.ctokenVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.rent, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+  ];
+  const identifier = Buffer.from([5, 54, 213, 112, 75, 232, 117, 37]);
+  const buffer = Buffer.alloc(1000);
+  const len = layout.encode(
+    {
+      weight: args.weight,
+      cap: args.cap,
+    },
+    buffer
+  );
+  const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}

package/src/idl_codegen_kamino_vault/instructions/withdraw.ts

@@ -0,0 +1,81 @@
+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 WithdrawArgs {
+  sharesAmount: BN;
+}
+
+export interface WithdrawAccounts {
+  user: PublicKey;
+  vaultState: PublicKey;
+  reserve: PublicKey;
+  tokenVault: PublicKey;
+  ctokenVault: PublicKey;
+  baseVaultAuthority: PublicKey;
+  tokenAta: PublicKey;
+  tokenMint: PublicKey;
+  userSharesAta: PublicKey;
+  sharesMint: PublicKey;
+  tokenProgram: PublicKey;
+  /** CPI accounts */
+  lendingMarket: PublicKey;
+  lendingMarketAuthority: PublicKey;
+  reserveLiquiditySupply: PublicKey;
+  reserveCollateralMint: PublicKey;
+  klendProgram: PublicKey;
+  instructionSysvarAccount: PublicKey;
+}
+
+export const layout = borsh.struct([borsh.u64('sharesAmount')]);
+
+export function withdraw(args: WithdrawArgs, accounts: WithdrawAccounts, programId: PublicKey = PROGRAM_ID) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.user, isSigner: true, isWritable: true },
+    { pubkey: accounts.vaultState, isSigner: false, isWritable: true },
+    { pubkey: accounts.reserve, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.ctokenVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.baseVaultAuthority, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.userSharesAta, isSigner: false, isWritable: true },
+    { pubkey: accounts.sharesMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.lendingMarket, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.lendingMarketAuthority,
+      isSigner: false,
+      isWritable: false,
+    },
+    {
+      pubkey: accounts.reserveLiquiditySupply,
+      isSigner: false,
+      isWritable: true,
+    },
+    {
+      pubkey: accounts.reserveCollateralMint,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.klendProgram, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.instructionSysvarAccount,
+      isSigner: false,
+      isWritable: false,
+    },
+  ];
+  const identifier = Buffer.from([183, 18, 70, 156, 148, 109, 161, 34]);
+  const buffer = Buffer.alloc(1000);
+  const len = layout.encode(
+    {
+      sharesAmount: args.sharesAmount,
+    },
+    buffer
+  );
+  const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}