@kamino-finance/klend-sdk 5.11.0 → 5.11.2-beta.0

package/src/classes/vault.ts

@@ -11,7 +11,7 @@ import {
   SYSVAR_RENT_PUBKEY,
   TransactionInstruction,
 } from '@solana/web3.js';
-import { NATIVE_MINT, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
+import { getAssociatedTokenAddressSync, NATIVE_MINT, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
 import {
   getAssociatedTokenAddress,
   getTransferWsolIxns,
@@ -82,7 +82,7 @@ import {
 import { batchFetch, collToLamportsDecimal, ZERO } from '@kamino-finance/kliquidity-sdk';
 import { FullBPSDecimal } from '@kamino-finance/kliquidity-sdk/dist/utils/CreationParameters';
 import { FarmState } from '@kamino-finance/farms-sdk/dist';
-import { getAccountsInLUT, initLookupTableIx } from './lut_utils';
+import { getAccountsInLUT, initLookupTableIx } from '../utils/lookupTable';
 import {
   getFarmStakeIxs,
   getFarmUnstakeAndWithdrawIxs,
@@ -100,6 +100,8 @@ const CTOKEN_VAULT_SEED = 'ctoken_vault';
 const BASE_VAULT_AUTHORITY_SEED = 'authority';
 const SHARES_SEED = 'shares';
 
+export const INITIAL_DEPOSIT_LAMPORTS = 1000;
+
 /**
  * KaminoVaultClient is a class that provides a high-level interface to interact with the Kamino Vault program.
  */
@@ -195,6 +197,8 @@ export class KaminoVaultClient {
       this._kaminoVaultProgramId
     )[0];
 
+    const adminTokenAccount = getAssociatedTokenAddressSync(vaultConfig.tokenMint, vaultConfig.admin, false);
+
     const initVaultAccounts: InitVaultAccounts = {
       adminAuthority: vaultConfig.admin,
       vaultState: vaultState.publicKey,
@@ -206,6 +210,7 @@ export class KaminoVaultClient {
       rent: SYSVAR_RENT_PUBKEY,
       tokenProgram: vaultConfig.tokenMintProgramId,
       sharesTokenProgram: TOKEN_PROGRAM_ID,
+      adminTokenAccount,
     };
     const initVaultIx = initVault(initVaultAccounts, this._kaminoVaultProgramId);
 
@@ -288,7 +293,7 @@ export class KaminoVaultClient {
     );
 
     const updateReserveAllocationAccounts: UpdateReserveAllocationAccounts = {
-      adminAuthority: vaultState.adminAuthority,
+      signer: vaultState.adminAuthority,
       vaultState: vault.address,
       baseVaultAuthority: vaultState.baseVaultAuthority,
       reserveCollateralMint: reserveState.collateral.mintPubkey,
@@ -1010,20 +1015,16 @@ export class KaminoVaultClient {
     if (allReserves.length === 0) {
       throw new Error('No reserves found for the vault, please select at least one reserve for the vault');
     }
-
     const [allReservesStateMap, computedReservesAllocation] = await Promise.all([
       this.loadVaultReserves(vaultState),
       this.getVaultComputedReservesAllocation(vaultState),
     ]);
-
     const tokenProgram = await getAccountOwner(this.getConnection(), vaultState.tokenMint);
     const [{ ata: _payerTokenAta, createAtaIx }] = createAtasIdempotent(payer, [
       { mint: vaultState.tokenMint, tokenProgram },
     ]);
-
     // compute total vault holdings and expected distribution based on weights
     const curentVaultAllocations = this.getVaultAllocations(vaultState);
-
     const reservesToDisinvestFrom: PublicKey[] = [];
     const reservesToInvestInto: PublicKey[] = [];
 
@@ -1528,8 +1529,8 @@ export class KaminoVaultClient {
 
     let totalLeftToInvest = holdings.totalAUMIncludingFees.sub(holdings.pendingFees);
     let currentAllocationSum = totalAllocation;
-    const ZERO = new Decimal(0);
-    while (totalLeftToInvest.gt(ZERO)) {
+    const ONE = new Decimal(1);
+    while (totalLeftToInvest.gt(ONE)) {
       const totalLeftover = totalLeftToInvest;
       for (const reserve of allReserves) {
         const reserveWithWeight = initialVaultAllocations.get(reserve);

package/src/idl_codegen_kamino_vault/accounts/VaultState.ts

@@ -38,6 +38,7 @@ export interface VaultStateFields {
   vaultFarm: PublicKey
   creationTimestamp: BN
   padding1: BN
+  allocationAdmin: PublicKey
   padding2: Array<BN>
 }
 
@@ -75,6 +76,7 @@ export interface VaultStateJSON {
   vaultFarm: string
   creationTimestamp: string
   padding1: string
+  allocationAdmin: string
   padding2: Array<string>
 }
 
@@ -112,6 +114,7 @@ export class VaultState {
   readonly vaultFarm: PublicKey
   readonly creationTimestamp: BN
   readonly padding1: BN
+  readonly allocationAdmin: PublicKey
   readonly padding2: Array<BN>
 
   static readonly discriminator = Buffer.from([
@@ -152,7 +155,8 @@ export class VaultState {
     borsh.publicKey("vaultFarm"),
     borsh.u64("creationTimestamp"),
     borsh.u64("padding1"),
-    borsh.array(borsh.u128(), 244, "padding2"),
+    borsh.publicKey("allocationAdmin"),
+    borsh.array(borsh.u128(), 242, "padding2"),
   ])
 
   constructor(fields: VaultStateFields) {
@@ -191,6 +195,7 @@ export class VaultState {
     this.vaultFarm = fields.vaultFarm
     this.creationTimestamp = fields.creationTimestamp
     this.padding1 = fields.padding1
+    this.allocationAdmin = fields.allocationAdmin
     this.padding2 = fields.padding2
   }
 
@@ -275,6 +280,7 @@ export class VaultState {
       vaultFarm: dec.vaultFarm,
       creationTimestamp: dec.creationTimestamp,
       padding1: dec.padding1,
+      allocationAdmin: dec.allocationAdmin,
       padding2: dec.padding2,
     })
   }
@@ -316,6 +322,7 @@ export class VaultState {
       vaultFarm: this.vaultFarm.toString(),
       creationTimestamp: this.creationTimestamp.toString(),
       padding1: this.padding1.toString(),
+      allocationAdmin: this.allocationAdmin.toString(),
       padding2: this.padding2.map((item) => item.toString()),
     }
   }
@@ -357,6 +364,7 @@ export class VaultState {
       vaultFarm: new PublicKey(obj.vaultFarm),
       creationTimestamp: new BN(obj.creationTimestamp),
       padding1: new BN(obj.padding1),
+      allocationAdmin: new PublicKey(obj.allocationAdmin),
       padding2: obj.padding2.map((item) => new BN(item)),
     })
   }

package/src/idl_codegen_kamino_vault/errors/custom.ts

@@ -43,6 +43,9 @@ export type CustomError =
   | ManagementFeeGreaterThanMaxAllowed
   | VaultAUMZero
   | MissingReserveForBatchRefresh
+  | MinWithdrawAmountTooBig
+  | InvestTooSoon
+  | WrongAdminOrAllocationAdmin
 
 export class DepositAmountsZero extends Error {
   static readonly code = 7000
@@ -528,6 +531,39 @@ export class MissingReserveForBatchRefresh extends Error {
   }
 }
 
+export class MinWithdrawAmountTooBig extends Error {
+  static readonly code = 7044
+  readonly code = 7044
+  readonly name = "MinWithdrawAmountTooBig"
+  readonly msg = "Min withdraw amount is too big"
+
+  constructor(readonly logs?: string[]) {
+    super("7044: Min withdraw amount is too big")
+  }
+}
+
+export class InvestTooSoon extends Error {
+  static readonly code = 7045
+  readonly code = 7045
+  readonly name = "InvestTooSoon"
+  readonly msg = "Invest is called too soon after last invest"
+
+  constructor(readonly logs?: string[]) {
+    super("7045: Invest is called too soon after last invest")
+  }
+}
+
+export class WrongAdminOrAllocationAdmin extends Error {
+  static readonly code = 7046
+  readonly code = 7046
+  readonly name = "WrongAdminOrAllocationAdmin"
+  readonly msg = "Wrong admin or allocation admin"
+
+  constructor(readonly logs?: string[]) {
+    super("7046: Wrong admin or allocation admin")
+  }
+}
+
 export function fromCode(code: number, logs?: string[]): CustomError | null {
   switch (code) {
     case 7000:
@@ -618,6 +654,12 @@ export function fromCode(code: number, logs?: string[]): CustomError | null {
       return new VaultAUMZero(logs)
     case 7043:
       return new MissingReserveForBatchRefresh(logs)
+    case 7044:
+      return new MinWithdrawAmountTooBig(logs)
+    case 7045:
+      return new InvestTooSoon(logs)
+    case 7046:
+      return new WrongAdminOrAllocationAdmin(logs)
   }
 
   return null

package/src/idl_codegen_kamino_vault/instructions/initVault.ts

@@ -11,6 +11,7 @@ export interface InitVaultAccounts {
   tokenVault: PublicKey
   baseTokenMint: PublicKey
   sharesMint: PublicKey
+  adminTokenAccount: PublicKey
   systemProgram: PublicKey
   rent: PublicKey
   tokenProgram: PublicKey
@@ -28,6 +29,7 @@ export function initVault(
     { pubkey: accounts.tokenVault, isSigner: false, isWritable: true },
     { pubkey: accounts.baseTokenMint, isSigner: false, isWritable: false },
     { pubkey: accounts.sharesMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.adminTokenAccount, 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 },

package/src/idl_codegen_kamino_vault/instructions/updateReserveAllocation.ts

@@ -10,7 +10,7 @@ export interface UpdateReserveAllocationArgs {
 }
 
 export interface UpdateReserveAllocationAccounts {
-  adminAuthority: PublicKey
+  signer: PublicKey
   vaultState: PublicKey
   baseVaultAuthority: PublicKey
   reserveCollateralMint: PublicKey
@@ -29,7 +29,7 @@ export function updateReserveAllocation(
   programId: PublicKey = PROGRAM_ID
 ) {
   const keys: Array<AccountMeta> = [
-    { pubkey: accounts.adminAuthority, isSigner: true, isWritable: true },
+    { pubkey: accounts.signer, isSigner: true, isWritable: true },
     { pubkey: accounts.vaultState, isSigner: false, isWritable: true },
     { pubkey: accounts.baseVaultAuthority, isSigner: false, isWritable: false },
     {

package/src/idl_codegen_kamino_vault/types/VaultConfigField.ts

@@ -256,6 +256,29 @@ export class Farm {
   }
 }
 
+export interface AllocationAdminJSON {
+  kind: "AllocationAdmin"
+}
+
+export class AllocationAdmin {
+  static readonly discriminator = 11
+  static readonly kind = "AllocationAdmin"
+  readonly discriminator = 11
+  readonly kind = "AllocationAdmin"
+
+  toJSON(): AllocationAdminJSON {
+    return {
+      kind: "AllocationAdmin",
+    }
+  }
+
+  toEncodable() {
+    return {
+      AllocationAdmin: {},
+    }
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function fromDecoded(obj: any): types.VaultConfigFieldKind {
   if (typeof obj !== "object") {
@@ -295,6 +318,9 @@ export function fromDecoded(obj: any): types.VaultConfigFieldKind {
   if ("Farm" in obj) {
     return new Farm()
   }
+  if ("AllocationAdmin" in obj) {
+    return new AllocationAdmin()
+  }
 
   throw new Error("Invalid enum object")
 }
@@ -336,6 +362,9 @@ export function fromJSON(
     case "Farm": {
       return new Farm()
     }
+    case "AllocationAdmin": {
+      return new AllocationAdmin()
+    }
   }
 }
 
@@ -352,6 +381,7 @@ export function layout(property?: string) {
     borsh.struct([], "Name"),
     borsh.struct([], "LookupTable"),
     borsh.struct([], "Farm"),
+    borsh.struct([], "AllocationAdmin"),
   ])
   if (property !== undefined) {
     return ret.replicate(property)

package/src/idl_codegen_kamino_vault/types/index.ts

@@ -63,6 +63,7 @@ export type VaultConfigFieldKind =
   | VaultConfigField.Name
   | VaultConfigField.LookupTable
   | VaultConfigField.Farm
+  | VaultConfigField.AllocationAdmin
 export type VaultConfigFieldJSON =
   | VaultConfigField.PerformanceFeeBpsJSON
   | VaultConfigField.ManagementFeeBpsJSON
@@ -75,6 +76,7 @@ export type VaultConfigFieldJSON =
   | VaultConfigField.NameJSON
   | VaultConfigField.LookupTableJSON
   | VaultConfigField.FarmJSON
+  | VaultConfigField.AllocationAdminJSON
 
 export { VaultAllocation } from "./VaultAllocation"
 export type {

package/src/idl_kamino_vault.json

@@ -35,6 +35,11 @@
           "isMut": true,
           "isSigner": false
         },
+        {
+          "name": "adminTokenAccount",
+          "isMut": true,
+          "isSigner": false
+        },
         {
           "name": "systemProgram",
           "isMut": false,
@@ -62,7 +67,7 @@
       "name": "updateReserveAllocation",
       "accounts": [
         {
-          "name": "adminAuthority",
+          "name": "signer",
           "isMut": true,
           "isSigner": true
         },
@@ -996,12 +1001,16 @@
             "name": "padding1",
             "type": "u64"
           },
+          {
+            "name": "allocationAdmin",
+            "type": "publicKey"
+          },
           {
             "name": "padding2",
             "type": {
               "array": [
                 "u128",
-                244
+                242
               ]
             }
           }
@@ -1874,6 +1883,9 @@
           },
           {
             "name": "Farm"
+          },
+          {
+            "name": "AllocationAdmin"
           }
         ]
       }
@@ -2160,6 +2172,21 @@
       "code": 7043,
       "name": "MissingReserveForBatchRefresh",
       "msg": "Missing reserve for batch refresh"
+    },
+    {
+      "code": 7044,
+      "name": "MinWithdrawAmountTooBig",
+      "msg": "Min withdraw amount is too big"
+    },
+    {
+      "code": 7045,
+      "name": "InvestTooSoon",
+      "msg": "Invest is called too soon after last invest"
+    },
+    {
+      "code": 7046,
+      "name": "WrongAdminOrAllocationAdmin",
+      "msg": "Wrong admin or allocation admin"
     }
   ]
-}
+}

package/src/lending_operations/repay_with_collateral_calcs.ts

@@ -2,6 +2,7 @@ import Decimal from 'decimal.js';
 import { KaminoMarket, KaminoObligation, KaminoReserve, numberToLamportsDecimal } from '../classes';
 import { PublicKey } from '@solana/web3.js';
 import { lamportsToDecimal } from '../classes/utils';
+import { MaxWithdrawLtvCheck, getMaxWithdrawLtvCheck } from './repay_with_collateral_operations';
 
 export function calcRepayAmountWithSlippage(
   kaminoMarket: KaminoMarket,
@@ -102,6 +103,7 @@ export function calcMaxWithdrawCollateral(
       .filter((p) => !p.reserveAddress.equals(borrow.reserveAddress))
       .reduce((acc, b) => acc.add(b.marketValueRefreshed), new Decimal('0'));
   }
+  const maxWithdrawLtvCheck = getMaxWithdrawLtvCheck(obligation);
 
   let remainingDepositsValueWithLtv = new Decimal('0');
   if (obligation.getDeposits().length > 1) {
@@ -109,8 +111,13 @@ export function calcMaxWithdrawCollateral(
       .getDeposits()
       .filter((p) => !p.reserveAddress.equals(deposit.reserveAddress))
       .reduce((acc, d) => {
-        const { maxLtv } = obligation.getLtvForReserve(market, market.getReserveByAddress(d.reserveAddress)!);
-        return acc.add(d.marketValueRefreshed.mul(maxLtv));
+        const { maxLtv, liquidationLtv } = obligation.getLtvForReserve(
+          market,
+          market.getReserveByAddress(d.reserveAddress)!
+        );
+        const maxWithdrawLtv =
+          maxWithdrawLtvCheck === MaxWithdrawLtvCheck.LIQUIDATION_THRESHOLD ? liquidationLtv : maxLtv;
+        return acc.add(d.marketValueRefreshed.mul(maxWithdrawLtv));
       }, new Decimal('0'));
   }
 
@@ -123,16 +130,18 @@ export function calcMaxWithdrawCollateral(
       repayingAllDebt: repayAmountLamports.gte(borrow.amount),
     };
   } else {
-    const { maxLtv: collMaxLtv } = obligation.getLtvForReserve(
+    const { maxLtv: collMaxLtv, liquidationLtv: collLiquidationLtv } = obligation.getLtvForReserve(
       market,
       market.getReserveByAddress(depositReserve.address)!
     );
+    const maxWithdrawLtv =
+      maxWithdrawLtvCheck === MaxWithdrawLtvCheck.LIQUIDATION_THRESHOLD ? collLiquidationLtv : collMaxLtv;
     const numerator = deposit.marketValueRefreshed
-      .mul(collMaxLtv)
+      .mul(maxWithdrawLtv)
       .add(remainingDepositsValueWithLtv)
       .sub(remainingBorrowsValue);
 
-    const denominator = depositReserve.getOracleMarketPrice().mul(collMaxLtv);
+    const denominator = depositReserve.getOracleMarketPrice().mul(maxWithdrawLtv);
     const maxCollWithdrawAmount = numerator.div(denominator);
     const withdrawableCollLamports = maxCollWithdrawAmount.mul(depositReserve.getMintFactor()).floor();
 

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -56,6 +56,11 @@ interface RepayWithCollSwapInputsProps<QuoteResponse> {
   quoter: SwapQuoteProvider<QuoteResponse>;
 }
 
+export enum MaxWithdrawLtvCheck {
+  MAX_LTV,
+  LIQUIDATION_THRESHOLD,
+}
+
 export async function getRepayWithCollSwapInputs<QuoteResponse>({
   collTokenMint,
   currentSlot,
@@ -212,8 +217,17 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   const { debtRepayAmountLamports, flashRepayAmountLamports, maxCollateralWithdrawLamports, swapQuote } = initialInputs;
   const { inputAmountLamports: collSwapInLamports } = swapInputs;
 
-  const collReserve = kaminoMarket.getReserveByMint(collTokenMint)!;
-  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint)!;
+  const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
+
+  if (!collReserve) {
+    throw new Error(`Collateral reserve with mint ${collTokenMint} not found in market ${kaminoMarket.getAddress()}`);
+  }
+
+  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
+
+  if (!debtReserve) {
+    throw new Error(`Debt reserve with mint ${debtTokenMint} not found in market ${kaminoMarket.getAddress()}`);
+  }
 
   // the client should use these values to prevent this input, but the tx may succeed, so we don't want to fail
   // there is also a chance that the tx will consume debt token from the user's ata which they would not expect
@@ -303,25 +317,48 @@ async function buildRepayWithCollateralIxs(
 
   const requestElevationGroup = !isClosingPosition && obligation.state.elevationGroup !== 0;
 
+  const maxWithdrawLtvCheck = getMaxWithdrawLtvCheck(obligation);
+
   // 3. Repay using the flash borrowed funds & withdraw collateral to swap and pay the flash loan
-  const repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawTxns(
-    market,
-    isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
-    debtReserve.getLiquidityMint(),
-    isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
-    collReserve.getLiquidityMint(),
-    obligation.state.owner,
-    currentSlot,
-    obligation,
-    useV2Ixs,
-    0,
-    false,
-    requestElevationGroup,
-    undefined,
-    undefined,
-    referrer,
-    scopeRefresh
-  );
+  let repayAndWithdrawAction;
+  if (maxWithdrawLtvCheck === MaxWithdrawLtvCheck.MAX_LTV) {
+    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawTxns(
+      market,
+      isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
+      debtReserve.getLiquidityMint(),
+      isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
+      collReserve.getLiquidityMint(),
+      obligation.state.owner,
+      currentSlot,
+      obligation,
+      useV2Ixs,
+      0,
+      false,
+      requestElevationGroup,
+      undefined,
+      undefined,
+      referrer,
+      scopeRefresh
+    );
+  } else {
+    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawV2Txns(
+      market,
+      isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
+      debtReserve.getLiquidityMint(),
+      isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
+      collReserve.getLiquidityMint(),
+      obligation.state.owner,
+      currentSlot,
+      obligation,
+      0,
+      false,
+      requestElevationGroup,
+      undefined,
+      undefined,
+      referrer,
+      scopeRefresh
+    );
+  }
 
   // 4. Swap collateral to debt to repay flash loan
   const { preActionIxs, swapIxs } = swapQuoteIxs;
@@ -337,3 +374,9 @@ async function buildRepayWithCollateralIxs(
     flashRepayIxn,
   ];
 }
+
+export const getMaxWithdrawLtvCheck = (obligation: KaminoObligation) => {
+  return obligation.refreshedStats.userTotalBorrowBorrowFactorAdjusted.gte(obligation.refreshedStats.borrowLimit)
+    ? MaxWithdrawLtvCheck.LIQUIDATION_THRESHOLD
+    : MaxWithdrawLtvCheck.MAX_LTV;
+};

package/src/utils/constants.ts

@@ -85,3 +85,4 @@ export const DEFAULT_MAX_COMPUTE_UNITS = 1_400_000;
  * Minimum initial deposit required for the initialization of a reserve
  */
 export const MIN_INITIAL_DEPOSIT = 100_000;
+export const MIN_VAULT_INITIAL_DEPOSIT = 1_000_000_000;

package/src/utils/lookupTable.ts

@@ -53,3 +53,65 @@ export const extendLookupTableIxs = (
 
   return extendLookupIxs;
 };
+
+/**
+ * This method retuns an instruction that creates a lookup table, alongside the pubkey of the lookup table
+ * @param payer - the owner of the lookup table
+ * @param slot - the current slot
+ * @returns - the instruction to create the lookup table and its address
+ */
+export function initLookupTableIx(payer: PublicKey, slot: number): [TransactionInstruction, PublicKey] {
+  const [ixn, address] = AddressLookupTableProgram.createLookupTable({
+    authority: payer,
+    payer,
+    recentSlot: slot,
+  });
+
+  return [ixn, address];
+}
+
+/**
+ * This method retuns an instruction that deactivates a lookup table, which is needed to close it
+ * @param payer - the owner of the lookup table
+ * @param lookupTable - the lookup table to deactivate
+ * @returns - the instruction to deactivate the lookup table
+ */
+export function deactivateLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+  const ixn = AddressLookupTableProgram.deactivateLookupTable({
+    authority: payer,
+    lookupTable: lookupTable,
+  });
+
+  return ixn;
+}
+
+/**
+ * This method returns an instruction that closes a lookup table. That lookup table needs to be disabled at least 500 blocks before closing it.
+ * @param payer - the owner of the lookup table
+ * @param lookupTable - the lookup table to close
+ * @returns - the instruction to close the lookup table
+ */
+/// this require the LUT to be deactivated at least 500 blocks before
+export function closeLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+  const ixn = AddressLookupTableProgram.closeLookupTable({
+    authority: payer,
+    recipient: payer,
+    lookupTable: lookupTable,
+  });
+
+  return ixn;
+}
+
+/**
+ * Returns the accounts in a lookup table
+ * @param lookupTable - lookup table to get the accounts from
+ * @returns - an array of accounts in the lookup table
+ */
+export async function getAccountsInLUT(connection: Connection, lookupTable: PublicKey): Promise<PublicKey[]> {
+  const lutState = await connection.getAddressLookupTable(lookupTable);
+  if (!lutState || !lutState.value) {
+    throw new Error(`Lookup table ${lookupTable} not found`);
+  }
+
+  return lutState.value.state.addresses;
+}

package/src/utils/seeds.ts

@@ -38,6 +38,10 @@ export const BASE_SEED_REFERRER_STATE = 'ref_state';
  * Short url seed
  */
 export const BASE_SEED_SHORT_URL = 'short_url';
+/**
+ * Farm user state seed
+ */
+export const BASE_SEED_USER_STATE = 'user';
 
 /**
  * User farm state seed
@@ -188,9 +192,15 @@ export function shortUrlPda(shortUrl: string, programId: PublicKey = PROGRAM_ID)
   return PublicKey.findProgramAddressSync([Buffer.from(BASE_SEED_SHORT_URL), Buffer.from(shortUrl)], programId);
 }
 
-export function obligationFarmStatePda(obligation: PublicKey, farm: PublicKey, programId: PublicKey = farmsId) {
+/**
+ * Returns the PDA for the obligation farm state
+ * @param farm
+ * @param obligation
+ * @returns pda
+ */
+export function obligationFarmStatePda(farm: PublicKey, obligation: PublicKey) {
   return PublicKey.findProgramAddressSync(
-    [Buffer.from(BASE_SEED_FARM_USER_STATE), farm.toBuffer(), obligation.toBuffer()],
-    programId
-  );
+    [Buffer.from(BASE_SEED_USER_STATE), farm.toBytes(), obligation.toBytes()],
+    farmsId
+  )[0];
 }