@kamino-finance/klend-sdk 5.11.6 → 5.11.8

package/src/client.ts

@@ -62,9 +62,17 @@ async function main() {
     .option(`--rpc <string>`, 'The RPC URL')
     .action(async ({ rpc }) => {
       const connection = new Connection(rpc, {});
-      for await (const lendingMarketAccount of getAllLendingMarketAccounts(connection)) {
-        console.log(toJson(lendingMarketAccount.toJSON()));
+      let count = 0;
+      for await (const [address, lendingMarketAccount] of getAllLendingMarketAccounts(connection)) {
+        count++;
+        console.log(
+          address.toString(),
+          lendingMarketAccount.riskCouncil.toString(),
+          lendingMarketAccount.autodeleverageEnabled,
+          lendingMarketAccount.individualAutodeleverageMarginCallPeriodSecs.toString()
+        );
       }
+      console.log(`Total lending markets: ${count}`);
     });
 
   commands
@@ -84,9 +92,17 @@ async function main() {
     .option(`--rpc <string>`, 'The RPC URL')
     .action(async ({ rpc }) => {
       const connection = new Connection(rpc, {});
-      for await (const obligationAccount of getAllObligationAccounts(connection)) {
-        console.log(toJson(obligationAccount.toJSON()));
+      let count = 0;
+      for await (const [address, obligationAccount] of getAllObligationAccounts(connection)) {
+        count++;
+        if (
+          obligationAccount.autodeleverageTargetLtvPct > 0 ||
+          obligationAccount.autodeleverageMarginCallStartedTimestamp.toNumber() > 0
+        ) {
+          console.log(address.toString(), toJson(obligationAccount.toJSON()));
+        }
       }
+      console.log(`Total obligations: ${count}`);
     });
 
   commands
@@ -104,9 +120,19 @@ async function main() {
     .option(`--rpc <string>`, 'The RPC URL')
     .action(async ({ rpc }) => {
       const connection = new Connection(rpc, {});
-      for await (const reserveAccount of getAllReserveAccounts(connection)) {
-        console.log(toJson(reserveAccount.toJSON()));
+      let count = 0;
+      const logItems: { address: string; value: string; index: number }[] = [];
+      for await (const [address, reserveAccount] of getAllReserveAccounts(connection)) {
+        count++;
+        const logItem = {
+          address: address.toString(),
+          value: reserveAccount.config.autodeleverageEnabled.toString(),
+          index: count,
+        };
+        logItems.push(logItem);
       }
+      console.log(`Total reserves: ${count}`);
+      console.log(logItems);
     });
 
   commands

package/src/client_kamino_manager.ts

@@ -1019,6 +1019,21 @@ async function main() {
       );
     });
 
+  commands
+    .command('compute-alloc')
+    .requiredOption('--vault <string>', 'Vault address')
+    .action(async ({ vault }) => {
+      const env = initializeClient(false, false);
+
+      const vaultAddress = new PublicKey(vault);
+
+      const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+      const vaultState = await new KaminoVault(vaultAddress, undefined, env.kVaultProgramId).getState(env.connection);
+
+      const computedAllocation = await kaminoManager.getVaultComputedReservesAllocation(vaultState);
+      console.log('computedAllocation', computedAllocation);
+    });
+
   commands
     .command('download-lending-market-config-and-all-reserves-configs')
     .requiredOption('--lending-market <string>', 'Lending Market Address')

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

@@ -57,6 +57,11 @@ interface RepayWithCollSwapInputsProps<QuoteResponse> {
   quoter: SwapQuoteProvider<QuoteResponse>;
 }
 
+export enum MaxWithdrawLtvCheck {
+  MAX_LTV,
+  LIQUIDATION_THRESHOLD,
+}
+
 export async function getRepayWithCollSwapInputs<QuoteResponse>({
   collTokenMint,
   currentSlot,
@@ -213,8 +218,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
@@ -306,25 +320,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,
-    undefined,
-    0,
-    false,
-    requestElevationGroup,
-    undefined,
-    undefined,
-    referrer
-  );
+  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,
+      undefined,
+      0,
+      false,
+      requestElevationGroup,
+      undefined,
+      undefined,
+      referrer
+    );
+  } 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,
+      undefined,
+      0,
+      false,
+      requestElevationGroup,
+      undefined,
+      undefined,
+      referrer
+    );
+  }
 
   // 4. Swap collateral to debt to repay flash loan
   const { preActionIxs, swapIxs } = swapQuoteIxs;
@@ -341,3 +378,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/accountListing.ts

@@ -1,9 +1,11 @@
-import { Connection } from '@solana/web3.js';
+import { Connection, PublicKey } from '@solana/web3.js';
 import { LendingMarket, Obligation, Reserve } from '../idl_codegen/accounts';
 import { PROGRAM_ID } from '../idl_codegen/programId';
 import bs58 from 'bs58';
 
-export async function* getAllObligationAccounts(connection: Connection): AsyncGenerator<Obligation, void, unknown> {
+export async function* getAllObligationAccounts(
+  connection: Connection
+): AsyncGenerator<[PublicKey, Obligation], void, unknown> {
   // Poor-man's paging...
   for (let i = 0; i < 256; i++) {
     const obligations = await connection.getProgramAccounts(PROGRAM_ID, {
@@ -26,12 +28,14 @@ export async function* getAllObligationAccounts(connection: Connection): AsyncGe
       ],
     });
     for (const obligation of obligations) {
-      yield Obligation.decode(obligation.account.data);
+      yield [obligation.pubkey, Obligation.decode(obligation.account.data)];
     }
   }
 }
 
-export async function* getAllReserveAccounts(connection: Connection): AsyncGenerator<Reserve, void, unknown> {
+export async function* getAllReserveAccounts(
+  connection: Connection
+): AsyncGenerator<[PublicKey, Reserve], void, unknown> {
   // due to relatively low count of reserves, we technically don't really need a generator, but let's keep it consistent within this file
   const reserves = await connection.getProgramAccounts(PROGRAM_ID, {
     filters: [
@@ -47,13 +51,13 @@ export async function* getAllReserveAccounts(connection: Connection): AsyncGener
     ],
   });
   for (const reserve of reserves) {
-    yield Reserve.decode(reserve.account.data);
+    yield [reserve.pubkey, Reserve.decode(reserve.account.data)];
   }
 }
 
 export async function* getAllLendingMarketAccounts(
   connection: Connection
-): AsyncGenerator<LendingMarket, void, unknown> {
+): AsyncGenerator<[PublicKey, LendingMarket], void, unknown> {
   // due to relatively very low count of lending markets, we technically don't really need a generator, but let's keep it consistent within this file
   const lendingMarkets = await connection.getProgramAccounts(PROGRAM_ID, {
     filters: [
@@ -69,6 +73,6 @@ export async function* getAllLendingMarketAccounts(
     ],
   });
   for (const lendingMarket of lendingMarkets) {
-    yield LendingMarket.decode(lendingMarket.account.data);
+    yield [lendingMarket.pubkey, LendingMarket.decode(lendingMarket.account.data)];
   }
 }

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];
 }

package/src/utils/userMetadata.ts

@@ -266,18 +266,18 @@ function getMultiplyObligationAndObligationFarmStateAddresses(
       if (!collReserve.state.farmCollateral.equals(PublicKey.default)) {
         farmUserStates.push({
           address: obligationFarmStatePda(
-            multiplyObligation.toPda(kaminoMarket.getAddress(), user),
-            collReserve.state.farmCollateral!
-          )[0],
+            collReserve.state.farmCollateral!,
+            multiplyObligation.toPda(kaminoMarket.getAddress(), user)
+          ),
           log: 'collReserve farmState for multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
         });
       }
       if (!debtReserve.state.farmDebt.equals(PublicKey.default)) {
         farmUserStates.push({
           address: obligationFarmStatePda(
-            multiplyObligation.toPda(kaminoMarket.getAddress(), user),
-            debtReserve.state.farmDebt!
-          )[0],
+            debtReserve.state.farmDebt!,
+            multiplyObligation.toPda(kaminoMarket.getAddress(), user)
+          ),
           log: 'debtReserve farmState for multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
         });
       }
@@ -309,18 +309,18 @@ function getLeverageObligationAndObligationFarmStateAddresses(
       if (!collReserve.state.farmCollateral.equals(PublicKey.default)) {
         farmUserStates.push({
           address: obligationFarmStatePda(
-            leverageObligation.toPda(kaminoMarket.getAddress(), user),
-            collReserve.state.farmCollateral!
-          )[0],
+            collReserve.state.farmCollateral!,
+            leverageObligation.toPda(kaminoMarket.getAddress(), user)
+          ),
           log: 'collReserve farmState for leverage obligation coll: ' + collMintString + ' debt: ' + debtMintString,
         });
       }
       if (!debtReserve.state.farmDebt.equals(PublicKey.default)) {
         farmUserStates.push({
           address: obligationFarmStatePda(
-            leverageObligation.toPda(kaminoMarket.getAddress(), user),
-            debtReserve.state.farmDebt!
-          )[0],
+            debtReserve.state.farmDebt!,
+            leverageObligation.toPda(kaminoMarket.getAddress(), user)
+          ),
           log: 'debtReserve farmState for leverage obligation coll: ' + collMintString + ' debt: ' + debtMintString,
         });
       }
@@ -341,7 +341,7 @@ function getRepayWithCollObligationFarmStateAddresses(
     const borrowReserve = kaminoMarket.getReserveByMint(borrow.mintAddress)!;
     if (!borrowReserve.state.farmDebt.equals(PublicKey.default)) {
       farmUserStates.push({
-        address: obligationFarmStatePda(obligation.obligationAddress, borrowReserve.state.farmDebt!)[0],
+        address: obligationFarmStatePda(borrowReserve.state.farmDebt!, obligation.obligationAddress),
         log: 'debtReserve farmState for vanilla obligation: ' + obligationString,
       });
     }
@@ -351,7 +351,7 @@ function getRepayWithCollObligationFarmStateAddresses(
     const depositReserve = kaminoMarket.getReserveByMint(deposit.mintAddress)!;
     if (!depositReserve.state.farmCollateral.equals(PublicKey.default)) {
       farmUserStates.push({
-        address: obligationFarmStatePda(obligation.obligationAddress, depositReserve.state.farmCollateral!)[0],
+        address: obligationFarmStatePda(depositReserve.state.farmCollateral!, obligation.obligationAddress),
         log: 'collReserve farmState for vanilla obligation' + obligationString,
       });
     }

package/dist/classes/lut_utils.d.ts

@@ -1,29 +0,0 @@
-import { Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
-/**
- * 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 declare function initLookupTableIx(payer: PublicKey, slot: number): [TransactionInstruction, PublicKey];
-/**
- * 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 declare function deactivateLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction;
-/**
- * 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
- */
-export declare function closeLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction;
-/**
- * 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 declare function getAccountsInLUT(connection: Connection, lookupTable: PublicKey): Promise<PublicKey[]>;
-//# sourceMappingURL=lut_utils.d.ts.map

package/dist/classes/lut_utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lut_utils.d.ts","sourceRoot":"","sources":["../../src/classes/lut_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,UAAU,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE3G;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,sBAAsB,EAAE,SAAS,CAAC,CAQrG;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,GAAG,sBAAsB,CAOxG;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,GAAG,sBAAsB,CAQnG;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAO3G"}

package/dist/classes/lut_utils.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initLookupTableIx = initLookupTableIx;
-exports.deactivateLookupTableIx = deactivateLookupTableIx;
-exports.closeLookupTableIx = closeLookupTableIx;
-exports.getAccountsInLUT = getAccountsInLUT;
-const web3_js_1 = require("@solana/web3.js");
-/**
- * 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
- */
-function initLookupTableIx(payer, slot) {
-    const [ixn, address] = web3_js_1.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
- */
-function deactivateLookupTableIx(payer, lookupTable) {
-    const ixn = web3_js_1.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
-function closeLookupTableIx(payer, lookupTable) {
-    const ixn = web3_js_1.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
- */
-async function getAccountsInLUT(connection, lookupTable) {
-    const lutState = await connection.getAddressLookupTable(lookupTable);
-    if (!lutState || !lutState.value) {
-        throw new Error(`Lookup table ${lookupTable} not found`);
-    }
-    return lutState.value.state.addresses;
-}
-//# sourceMappingURL=lut_utils.js.map

package/dist/classes/lut_utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lut_utils.js","sourceRoot":"","sources":["../../src/classes/lut_utils.ts"],"names":[],"mappings":";;AAQA,8CAQC;AAQD,0DAOC;AASD,gDAQC;AAOD,4CAOC;AA9DD,6CAA2G;AAE3G;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,KAAgB,EAAE,IAAY;IAC9D,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,mCAAyB,CAAC,iBAAiB,CAAC;QACjE,SAAS,EAAE,KAAK;QAChB,KAAK;QACL,UAAU,EAAE,IAAI;KACjB,CAAC,CAAC;IAEH,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AACxB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,uBAAuB,CAAC,KAAgB,EAAE,WAAsB;IAC9E,MAAM,GAAG,GAAG,mCAAyB,CAAC,qBAAqB,CAAC;QAC1D,SAAS,EAAE,KAAK;QAChB,WAAW,EAAE,WAAW;KACzB,CAAC,CAAC;IAEH,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,qEAAqE;AACrE,SAAgB,kBAAkB,CAAC,KAAgB,EAAE,WAAsB;IACzE,MAAM,GAAG,GAAG,mCAAyB,CAAC,gBAAgB,CAAC;QACrD,SAAS,EAAE,KAAK;QAChB,SAAS,EAAE,KAAK;QAChB,WAAW,EAAE,WAAW;KACzB,CAAC,CAAC;IAEH,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,gBAAgB,CAAC,UAAsB,EAAE,WAAsB;IACnF,MAAM,QAAQ,GAAG,MAAM,UAAU,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;IACrE,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,gBAAgB,WAAW,YAAY,CAAC,CAAC;IAC3D,CAAC;IAED,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC;AACxC,CAAC"}

package/src/classes/lut_utils.ts

@@ -1,63 +0,0 @@
-import { AddressLookupTableProgram, Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
-
-/**
- * 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;
-}