@kamino-finance/klend-sdk 7.2.6-beta.1 → 7.3.0

package/src/@codegen/kvault/accounts/GlobalConfig.ts

@@ -0,0 +1,136 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  address,
+  Address,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  GetAccountInfoApi,
+  GetMultipleAccountsApi,
+  Rpc,
+} from "@solana/kit"
+/* eslint-enable @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 { borshAddress } from "../utils" // 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 GlobalConfigFields {
+  globalAdmin: Address
+  pendingAdmin: Address
+  withdrawalPenaltyLamports: BN
+  withdrawalPenaltyBps: BN
+  padding: Array<number>
+}
+
+export interface GlobalConfigJSON {
+  globalAdmin: string
+  pendingAdmin: string
+  withdrawalPenaltyLamports: string
+  withdrawalPenaltyBps: string
+  padding: Array<number>
+}
+
+export class GlobalConfig {
+  readonly globalAdmin: Address
+  readonly pendingAdmin: Address
+  readonly withdrawalPenaltyLamports: BN
+  readonly withdrawalPenaltyBps: BN
+  readonly padding: Array<number>
+
+  static readonly discriminator = Buffer.from([
+    149, 8, 156, 202, 160, 252, 176, 217,
+  ])
+
+  static readonly layout = borsh.struct<GlobalConfig>([
+    borshAddress("globalAdmin"),
+    borshAddress("pendingAdmin"),
+    borsh.u64("withdrawalPenaltyLamports"),
+    borsh.u64("withdrawalPenaltyBps"),
+    borsh.array(borsh.u8(), 944, "padding"),
+  ])
+
+  constructor(fields: GlobalConfigFields) {
+    this.globalAdmin = fields.globalAdmin
+    this.pendingAdmin = fields.pendingAdmin
+    this.withdrawalPenaltyLamports = fields.withdrawalPenaltyLamports
+    this.withdrawalPenaltyBps = fields.withdrawalPenaltyBps
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    rpc: Rpc<GetAccountInfoApi>,
+    address: Address,
+    programId: Address = PROGRAM_ID
+  ): Promise<GlobalConfig | null> {
+    const info = await fetchEncodedAccount(rpc, address)
+
+    if (!info.exists) {
+      return null
+    }
+    if (info.programAddress !== programId) {
+      throw new Error(
+        `KVaultGlobalConfigFields account ${address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+      )
+    }
+
+    return this.decode(Buffer.from(info.data))
+  }
+
+  static async fetchMultiple(
+    rpc: Rpc<GetMultipleAccountsApi>,
+    addresses: Address[],
+    programId: Address = PROGRAM_ID
+  ): Promise<Array<GlobalConfig | null>> {
+    const infos = await fetchEncodedAccounts(rpc, addresses)
+
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null
+      }
+      if (info.programAddress !== programId) {
+        throw new Error(
+          `GlobalConfigFields account ${info.address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+        )
+      }
+
+      return this.decode(Buffer.from(info.data))
+    })
+  }
+
+  static decode(data: Buffer): GlobalConfig {
+    if (!data.slice(0, 8).equals(GlobalConfig.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = GlobalConfig.layout.decode(data.slice(8))
+
+    return new GlobalConfig({
+      globalAdmin: dec.globalAdmin,
+      pendingAdmin: dec.pendingAdmin,
+      withdrawalPenaltyLamports: dec.withdrawalPenaltyLamports,
+      withdrawalPenaltyBps: dec.withdrawalPenaltyBps,
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): GlobalConfigJSON {
+    return {
+      globalAdmin: this.globalAdmin,
+      pendingAdmin: this.pendingAdmin,
+      withdrawalPenaltyLamports: this.withdrawalPenaltyLamports.toString(),
+      withdrawalPenaltyBps: this.withdrawalPenaltyBps.toString(),
+      padding: this.padding,
+    }
+  }
+
+  static fromJSON(obj: GlobalConfigJSON): GlobalConfig {
+    return new GlobalConfig({
+      globalAdmin: address(obj.globalAdmin),
+      pendingAdmin: address(obj.pendingAdmin),
+      withdrawalPenaltyLamports: new BN(obj.withdrawalPenaltyLamports),
+      withdrawalPenaltyBps: new BN(obj.withdrawalPenaltyBps),
+      padding: obj.padding,
+    })
+  }
+}

package/src/@codegen/kvault/accounts/Reserve.ts

@@ -110,7 +110,7 @@ export class Reserve {
     types.ReserveCollateral.layout("collateral"),
     borsh.array(borsh.u64(), 150, "reserveCollateralPadding"),
     types.ReserveConfig.layout("config"),
-    borsh.array(borsh.u64(), 115, "configPadding"),
+    borsh.array(borsh.u64(), 116, "configPadding"),
     borsh.u64("borrowedAmountOutsideElevationGroup"),
     borsh.array(
       borsh.u64(),

package/src/@codegen/kvault/accounts/ReserveWhitelistEntry.ts

@@ -0,0 +1,157 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  address,
+  Address,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  GetAccountInfoApi,
+  GetMultipleAccountsApi,
+  Rpc,
+} from "@solana/kit"
+/* eslint-enable @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 { borshAddress } from "../utils" // 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 ReserveWhitelistEntryFields {
+  /**
+   * The token mint is stored to solve the problem of finding all the whitelisted reserves for a particular token mint:
+   * when storing the token mint inside the PDA, finding all the whitelisted reserves becomes a `getProgramAccounts` with
+   * a filter on discriminator + the mint field
+   * The reserve pubkey, as seed of the reserve whitelist PDA account, it stored so you can link back the PDA to its seeds
+   * (for instance, in the operation above we easily find the reserve corresponding to the PDA)
+   */
+  tokenMint: Address
+  reserve: Address
+  whitelistAddAllocation: number
+  whitelistInvest: number
+  padding: Array<number>
+}
+
+export interface ReserveWhitelistEntryJSON {
+  /**
+   * The token mint is stored to solve the problem of finding all the whitelisted reserves for a particular token mint:
+   * when storing the token mint inside the PDA, finding all the whitelisted reserves becomes a `getProgramAccounts` with
+   * a filter on discriminator + the mint field
+   * The reserve pubkey, as seed of the reserve whitelist PDA account, it stored so you can link back the PDA to its seeds
+   * (for instance, in the operation above we easily find the reserve corresponding to the PDA)
+   */
+  tokenMint: string
+  reserve: string
+  whitelistAddAllocation: number
+  whitelistInvest: number
+  padding: Array<number>
+}
+
+export class ReserveWhitelistEntry {
+  /**
+   * The token mint is stored to solve the problem of finding all the whitelisted reserves for a particular token mint:
+   * when storing the token mint inside the PDA, finding all the whitelisted reserves becomes a `getProgramAccounts` with
+   * a filter on discriminator + the mint field
+   * The reserve pubkey, as seed of the reserve whitelist PDA account, it stored so you can link back the PDA to its seeds
+   * (for instance, in the operation above we easily find the reserve corresponding to the PDA)
+   */
+  readonly tokenMint: Address
+  readonly reserve: Address
+  readonly whitelistAddAllocation: number
+  readonly whitelistInvest: number
+  readonly padding: Array<number>
+
+  static readonly discriminator = Buffer.from([
+    135, 130, 156, 210, 58, 58, 91, 170,
+  ])
+
+  static readonly layout = borsh.struct<ReserveWhitelistEntry>([
+    borshAddress("tokenMint"),
+    borshAddress("reserve"),
+    borsh.u8("whitelistAddAllocation"),
+    borsh.u8("whitelistInvest"),
+    borsh.array(borsh.u8(), 62, "padding"),
+  ])
+
+  constructor(fields: ReserveWhitelistEntryFields) {
+    this.tokenMint = fields.tokenMint
+    this.reserve = fields.reserve
+    this.whitelistAddAllocation = fields.whitelistAddAllocation
+    this.whitelistInvest = fields.whitelistInvest
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    rpc: Rpc<GetAccountInfoApi>,
+    address: Address,
+    programId: Address = PROGRAM_ID
+  ): Promise<ReserveWhitelistEntry | null> {
+    const info = await fetchEncodedAccount(rpc, address)
+
+    if (!info.exists) {
+      return null
+    }
+    if (info.programAddress !== programId) {
+      throw new Error(
+        `ReserveWhitelistEntryFields account ${address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+      )
+    }
+
+    return this.decode(Buffer.from(info.data))
+  }
+
+  static async fetchMultiple(
+    rpc: Rpc<GetMultipleAccountsApi>,
+    addresses: Address[],
+    programId: Address = PROGRAM_ID
+  ): Promise<Array<ReserveWhitelistEntry | null>> {
+    const infos = await fetchEncodedAccounts(rpc, addresses)
+
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null
+      }
+      if (info.programAddress !== programId) {
+        throw new Error(
+          `ReserveWhitelistEntryFields account ${info.address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+        )
+      }
+
+      return this.decode(Buffer.from(info.data))
+    })
+  }
+
+  static decode(data: Buffer): ReserveWhitelistEntry {
+    if (!data.slice(0, 8).equals(ReserveWhitelistEntry.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ReserveWhitelistEntry.layout.decode(data.slice(8))
+
+    return new ReserveWhitelistEntry({
+      tokenMint: dec.tokenMint,
+      reserve: dec.reserve,
+      whitelistAddAllocation: dec.whitelistAddAllocation,
+      whitelistInvest: dec.whitelistInvest,
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): ReserveWhitelistEntryJSON {
+    return {
+      tokenMint: this.tokenMint,
+      reserve: this.reserve,
+      whitelistAddAllocation: this.whitelistAddAllocation,
+      whitelistInvest: this.whitelistInvest,
+      padding: this.padding,
+    }
+  }
+
+  static fromJSON(obj: ReserveWhitelistEntryJSON): ReserveWhitelistEntry {
+    return new ReserveWhitelistEntry({
+      tokenMint: address(obj.tokenMint),
+      reserve: address(obj.reserve),
+      whitelistAddAllocation: obj.whitelistAddAllocation,
+      whitelistInvest: obj.whitelistInvest,
+      padding: obj.padding,
+    })
+  }
+}

package/src/@codegen/kvault/accounts/VaultState.ts

@@ -51,6 +51,12 @@ export interface VaultStateFields {
   creationTimestamp: BN
   unallocatedTokensCap: BN
   allocationAdmin: Address
+  withdrawalPenaltyLamports: BN
+  withdrawalPenaltyBps: BN
+  firstLossCapitalFarm: Address
+  allowAllocationsInWhitelistedReservesOnly: number
+  allowInvestInWhitelistedReservesOnly: number
+  padding4: Array<number>
   padding3: Array<BN>
 }
 
@@ -90,6 +96,12 @@ export interface VaultStateJSON {
   creationTimestamp: string
   unallocatedTokensCap: string
   allocationAdmin: string
+  withdrawalPenaltyLamports: string
+  withdrawalPenaltyBps: string
+  firstLossCapitalFarm: string
+  allowAllocationsInWhitelistedReservesOnly: number
+  allowInvestInWhitelistedReservesOnly: number
+  padding4: Array<number>
   padding3: Array<string>
 }
 
@@ -129,6 +141,12 @@ export class VaultState {
   readonly creationTimestamp: BN
   readonly unallocatedTokensCap: BN
   readonly allocationAdmin: Address
+  readonly withdrawalPenaltyLamports: BN
+  readonly withdrawalPenaltyBps: BN
+  readonly firstLossCapitalFarm: Address
+  readonly allowAllocationsInWhitelistedReservesOnly: number
+  readonly allowInvestInWhitelistedReservesOnly: number
+  readonly padding4: Array<number>
   readonly padding3: Array<BN>
 
   static readonly discriminator = Buffer.from([
@@ -171,7 +189,13 @@ export class VaultState {
     borsh.u64("creationTimestamp"),
     borsh.u64("unallocatedTokensCap"),
     borshAddress("allocationAdmin"),
-    borsh.array(borsh.u128(), 242, "padding3"),
+    borsh.u64("withdrawalPenaltyLamports"),
+    borsh.u64("withdrawalPenaltyBps"),
+    borshAddress("firstLossCapitalFarm"),
+    borsh.u8("allowAllocationsInWhitelistedReservesOnly"),
+    borsh.u8("allowInvestInWhitelistedReservesOnly"),
+    borsh.array(borsh.u8(), 14, "padding4"),
+    borsh.array(borsh.u128(), 238, "padding3"),
   ])
 
   constructor(fields: VaultStateFields) {
@@ -212,6 +236,14 @@ export class VaultState {
     this.creationTimestamp = fields.creationTimestamp
     this.unallocatedTokensCap = fields.unallocatedTokensCap
     this.allocationAdmin = fields.allocationAdmin
+    this.withdrawalPenaltyLamports = fields.withdrawalPenaltyLamports
+    this.withdrawalPenaltyBps = fields.withdrawalPenaltyBps
+    this.firstLossCapitalFarm = fields.firstLossCapitalFarm
+    this.allowAllocationsInWhitelistedReservesOnly =
+      fields.allowAllocationsInWhitelistedReservesOnly
+    this.allowInvestInWhitelistedReservesOnly =
+      fields.allowInvestInWhitelistedReservesOnly
+    this.padding4 = fields.padding4
     this.padding3 = fields.padding3
   }
 
@@ -302,6 +334,14 @@ export class VaultState {
       creationTimestamp: dec.creationTimestamp,
       unallocatedTokensCap: dec.unallocatedTokensCap,
       allocationAdmin: dec.allocationAdmin,
+      withdrawalPenaltyLamports: dec.withdrawalPenaltyLamports,
+      withdrawalPenaltyBps: dec.withdrawalPenaltyBps,
+      firstLossCapitalFarm: dec.firstLossCapitalFarm,
+      allowAllocationsInWhitelistedReservesOnly:
+        dec.allowAllocationsInWhitelistedReservesOnly,
+      allowInvestInWhitelistedReservesOnly:
+        dec.allowInvestInWhitelistedReservesOnly,
+      padding4: dec.padding4,
       padding3: dec.padding3,
     })
   }
@@ -345,6 +385,14 @@ export class VaultState {
       creationTimestamp: this.creationTimestamp.toString(),
       unallocatedTokensCap: this.unallocatedTokensCap.toString(),
       allocationAdmin: this.allocationAdmin,
+      withdrawalPenaltyLamports: this.withdrawalPenaltyLamports.toString(),
+      withdrawalPenaltyBps: this.withdrawalPenaltyBps.toString(),
+      firstLossCapitalFarm: this.firstLossCapitalFarm,
+      allowAllocationsInWhitelistedReservesOnly:
+        this.allowAllocationsInWhitelistedReservesOnly,
+      allowInvestInWhitelistedReservesOnly:
+        this.allowInvestInWhitelistedReservesOnly,
+      padding4: this.padding4,
       padding3: this.padding3.map((item) => item.toString()),
     }
   }
@@ -388,6 +436,14 @@ export class VaultState {
       creationTimestamp: new BN(obj.creationTimestamp),
       unallocatedTokensCap: new BN(obj.unallocatedTokensCap),
       allocationAdmin: address(obj.allocationAdmin),
+      withdrawalPenaltyLamports: new BN(obj.withdrawalPenaltyLamports),
+      withdrawalPenaltyBps: new BN(obj.withdrawalPenaltyBps),
+      firstLossCapitalFarm: address(obj.firstLossCapitalFarm),
+      allowAllocationsInWhitelistedReservesOnly:
+        obj.allowAllocationsInWhitelistedReservesOnly,
+      allowInvestInWhitelistedReservesOnly:
+        obj.allowInvestInWhitelistedReservesOnly,
+      padding4: obj.padding4,
       padding3: obj.padding3.map((item) => new BN(item)),
     })
   }

package/src/@codegen/kvault/accounts/index.ts

@@ -1,4 +1,11 @@
 export { Reserve } from "./Reserve"
 export type { ReserveFields, ReserveJSON } from "./Reserve"
+export { GlobalConfig } from "./GlobalConfig"
+export type { GlobalConfigFields, GlobalConfigJSON } from "./GlobalConfig"
+export { ReserveWhitelistEntry } from "./ReserveWhitelistEntry"
+export type {
+  ReserveWhitelistEntryFields,
+  ReserveWhitelistEntryJSON,
+} from "./ReserveWhitelistEntry"
 export { VaultState } from "./VaultState"
 export type { VaultStateFields, VaultStateJSON } from "./VaultState"

package/src/@codegen/kvault/errors/custom.ts

@@ -48,15 +48,22 @@ export type CustomError =
   | WrongAdminOrAllocationAdmin
   | ReserveHasNonZeroAllocationOrCTokens
   | DepositAmountGreaterThanRequestedAmount
+  | WithdrawAmountLessThanWithdrawalPenalty
+  | CannotWithdrawZeroLamports
+  | NoUpgradeAuthority
+  | WithdrawalFeeBPSGreaterThanMaxAllowed
+  | WithdrawalFeeLamportsGreaterThanMaxAllowed
+  | ReserveNotWhitelisted
+  | InvalidBoolLikeValue
 
 export class DepositAmountsZero extends Error {
   static readonly code = 7000
   readonly code = 7000
   readonly name = "DepositAmountsZero"
-  readonly msg = "DepositAmountsZero"
+  readonly msg = "Cannot deposit zero tokens"
 
   constructor(readonly logs?: string[]) {
-    super("7000: DepositAmountsZero")
+    super("7000: Cannot deposit zero tokens")
   }
 }
 
@@ -64,10 +71,10 @@ export class SharesIssuedAmountDoesNotMatch extends Error {
   static readonly code = 7001
   readonly code = 7001
   readonly name = "SharesIssuedAmountDoesNotMatch"
-  readonly msg = "SharesIssuedAmountDoesNotMatch"
+  readonly msg = "Post check failed on share issued"
 
   constructor(readonly logs?: string[]) {
-    super("7001: SharesIssuedAmountDoesNotMatch")
+    super("7001: Post check failed on share issued")
   }
 }
 
@@ -75,10 +82,10 @@ export class MathOverflow extends Error {
   static readonly code = 7002
   readonly code = 7002
   readonly name = "MathOverflow"
-  readonly msg = "MathOverflow"
+  readonly msg = "Math operation overflowed"
 
   constructor(readonly logs?: string[]) {
-    super("7002: MathOverflow")
+    super("7002: Math operation overflowed")
   }
 }
 
@@ -86,10 +93,10 @@ export class IntegerOverflow extends Error {
   static readonly code = 7003
   readonly code = 7003
   readonly name = "IntegerOverflow"
-  readonly msg = "IntegerOverflow"
+  readonly msg = "Integer conversion overflowed"
 
   constructor(readonly logs?: string[]) {
-    super("7003: IntegerOverflow")
+    super("7003: Integer conversion overflowed")
   }
 }
 
@@ -591,6 +598,86 @@ export class DepositAmountGreaterThanRequestedAmount extends Error {
   }
 }
 
+export class WithdrawAmountLessThanWithdrawalPenalty extends Error {
+  static readonly code = 7049
+  readonly code = 7049
+  readonly name = "WithdrawAmountLessThanWithdrawalPenalty"
+  readonly msg = "Withdraw amount is less than withdrawal penalty"
+
+  constructor(readonly logs?: string[]) {
+    super("7049: Withdraw amount is less than withdrawal penalty")
+  }
+}
+
+export class CannotWithdrawZeroLamports extends Error {
+  static readonly code = 7050
+  readonly code = 7050
+  readonly name = "CannotWithdrawZeroLamports"
+  readonly msg = "Cannot withdraw 0 lamports"
+
+  constructor(readonly logs?: string[]) {
+    super("7050: Cannot withdraw 0 lamports")
+  }
+}
+
+export class NoUpgradeAuthority extends Error {
+  static readonly code = 7051
+  readonly code = 7051
+  readonly name = "NoUpgradeAuthority"
+  readonly msg =
+    "Cannot initialize global config because there is no upgrade authority to the program"
+
+  constructor(readonly logs?: string[]) {
+    super(
+      "7051: Cannot initialize global config because there is no upgrade authority to the program"
+    )
+  }
+}
+
+export class WithdrawalFeeBPSGreaterThanMaxAllowed extends Error {
+  static readonly code = 7052
+  readonly code = 7052
+  readonly name = "WithdrawalFeeBPSGreaterThanMaxAllowed"
+  readonly msg = "Withdrawal fee BPS is greater than maximum allowed"
+
+  constructor(readonly logs?: string[]) {
+    super("7052: Withdrawal fee BPS is greater than maximum allowed")
+  }
+}
+
+export class WithdrawalFeeLamportsGreaterThanMaxAllowed extends Error {
+  static readonly code = 7053
+  readonly code = 7053
+  readonly name = "WithdrawalFeeLamportsGreaterThanMaxAllowed"
+  readonly msg = "Withdrawal fee lamports is greater than maximum allowed"
+
+  constructor(readonly logs?: string[]) {
+    super("7053: Withdrawal fee lamports is greater than maximum allowed")
+  }
+}
+
+export class ReserveNotWhitelisted extends Error {
+  static readonly code = 7054
+  readonly code = 7054
+  readonly name = "ReserveNotWhitelisted"
+  readonly msg = "Reserve is not whitelisted"
+
+  constructor(readonly logs?: string[]) {
+    super("7054: Reserve is not whitelisted")
+  }
+}
+
+export class InvalidBoolLikeValue extends Error {
+  static readonly code = 7055
+  readonly code = 7055
+  readonly name = "InvalidBoolLikeValue"
+  readonly msg = "Invalid bool-like value passed in (should be 0 or 1)"
+
+  constructor(readonly logs?: string[]) {
+    super("7055: Invalid bool-like value passed in (should be 0 or 1)")
+  }
+}
+
 export function fromCode(code: number, logs?: string[]): CustomError | null {
   switch (code) {
     case 7000:
@@ -691,6 +778,20 @@ export function fromCode(code: number, logs?: string[]): CustomError | null {
       return new ReserveHasNonZeroAllocationOrCTokens(logs)
     case 7048:
       return new DepositAmountGreaterThanRequestedAmount(logs)
+    case 7049:
+      return new WithdrawAmountLessThanWithdrawalPenalty(logs)
+    case 7050:
+      return new CannotWithdrawZeroLamports(logs)
+    case 7051:
+      return new NoUpgradeAuthority(logs)
+    case 7052:
+      return new WithdrawalFeeBPSGreaterThanMaxAllowed(logs)
+    case 7053:
+      return new WithdrawalFeeLamportsGreaterThanMaxAllowed(logs)
+    case 7054:
+      return new ReserveNotWhitelisted(logs)
+    case 7055:
+      return new InvalidBoolLikeValue(logs)
   }
 
   return null

package/src/@codegen/kvault/instructions/addUpdateWhitelistedReserve.ts

@@ -0,0 +1,64 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  Address,
+  isSome,
+  AccountMeta,
+  AccountSignerMeta,
+  Instruction,
+  Option,
+  TransactionSigner,
+} from "@solana/kit"
+/* eslint-enable @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 { borshAddress } from "../utils" // 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 const DISCRIMINATOR = Buffer.from([219, 139, 95, 204, 7, 183, 118, 45])
+
+export interface AddUpdateWhitelistedReserveArgs {
+  update: types.UpdateReserveWhitelistModeKind
+}
+
+export interface AddUpdateWhitelistedReserveAccounts {
+  globalAdmin: TransactionSigner
+  globalConfig: Address
+  reserve: Address
+  reserveWhitelistEntry: Address
+  systemProgram: Address
+}
+
+export const layout = borsh.struct([
+  types.UpdateReserveWhitelistMode.layout("update"),
+])
+
+export function addUpdateWhitelistedReserve(
+  args: AddUpdateWhitelistedReserveArgs,
+  accounts: AddUpdateWhitelistedReserveAccounts,
+  remainingAccounts: Array<AccountMeta | AccountSignerMeta> = [],
+  programAddress: Address = PROGRAM_ID
+) {
+  const keys: Array<AccountMeta | AccountSignerMeta> = [
+    {
+      address: accounts.globalAdmin.address,
+      role: 3,
+      signer: accounts.globalAdmin,
+    },
+    { address: accounts.globalConfig, role: 0 },
+    { address: accounts.reserve, role: 0 },
+    { address: accounts.reserveWhitelistEntry, role: 1 },
+    { address: accounts.systemProgram, role: 0 },
+    ...remainingAccounts,
+  ]
+  const buffer = Buffer.alloc(1000)
+  const len = layout.encode(
+    {
+      update: args.update.toEncodable(),
+    },
+    buffer
+  )
+  const data = Buffer.concat([DISCRIMINATOR, buffer]).slice(0, 8 + len)
+  const ix: Instruction = { accounts: keys, programAddress, data }
+  return ix
+}