@kamino-finance/klend-sdk 7.0.12 → 7.1.0

package/src/classes/vault.ts

@@ -13,8 +13,8 @@ import {
   GetProgramAccountsDatasizeFilter,
   GetProgramAccountsMemcmpFilter,
   getProgramDerivedAddress,
-  IAccountMeta,
-  IInstruction,
+  AccountMeta,
+  Instruction,
   lamports,
   ProgramDerivedAddress,
   Rpc,
@@ -243,8 +243,8 @@ export class KaminoVaultClient {
     ]);
 
     let adminTokenAccount: Address;
-    const prerequisiteIxs: IInstruction[] = [];
-    const cleanupIxs: IInstruction[] = [];
+    const prerequisiteIxs: Instruction[] = [];
+    const cleanupIxs: Instruction[] = [];
     if (vaultConfig.tokenMint === WRAPPED_SOL_MINT) {
       const { wsolAta, createAtaIxs, closeAtaIxs } = await createWsolAtaIfMissing(
         this.getConnection(),
@@ -278,7 +278,7 @@ export class KaminoVaultClient {
       sharesTokenProgram: TOKEN_PROGRAM_ADDRESS,
       adminTokenAccount,
     };
-    const initVaultIx = initVault(initVaultAccounts, this._kaminoVaultProgramId);
+    const initVaultIx = initVault(initVaultAccounts, undefined, this._kaminoVaultProgramId);
 
     // create and set up the vault lookup table
     const [createLUTIx, lut] = await initLookupTableIx(vaultConfig.admin, slot);
@@ -432,6 +432,7 @@ export class KaminoVaultClient {
     const updateReserveAllocationIx = updateReserveAllocation(
       updateReserveAllocationArgs,
       updateReserveAllocationAccounts,
+      undefined,
       this._kaminoVaultProgramId
     );
 
@@ -477,7 +478,7 @@ export class KaminoVaultClient {
     const unallocatedWeightToUse = unallocatedWeight ? unallocatedWeight : vaultState.unallocatedWeight;
     const unallocatedCapToUse = unallocatedCap ? unallocatedCap : vaultState.unallocatedTokensCap;
 
-    const ixs: IInstruction[] = [];
+    const ixs: Instruction[] = [];
 
     if (!unallocatedWeightToUse.eq(vaultState.unallocatedWeight)) {
       const updateVaultUnallocatedWeightIx = await this.updateVaultConfigIxs(
@@ -657,7 +658,7 @@ export class KaminoVaultClient {
     vault: KaminoVault,
     reserve: Address,
     vaultAdminAuthority?: TransactionSigner
-  ): Promise<IInstruction | undefined> {
+  ): Promise<Instruction | undefined> {
     const vaultState = await vault.getState(this.getConnection());
     const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
 
@@ -729,6 +730,7 @@ export class KaminoVaultClient {
     let updateVaultConfigIx = updateVaultConfig(
       updateVaultConfigArgs,
       updateVaultConfigAccs,
+      undefined,
       this._kaminoVaultProgramId
     );
     updateVaultConfigIx = this.appendRemainingAccountsForVaultReserves(
@@ -737,7 +739,7 @@ export class KaminoVaultClient {
       vaultReservesState
     );
 
-    const updateLUTIxs: IInstruction[] = [];
+    const updateLUTIxs: Instruction[] = [];
 
     if (mode.kind === new VaultConfigField.PendingVaultAdmin().kind) {
       const newPubkey = address(value);
@@ -807,7 +809,7 @@ export class KaminoVaultClient {
     vault: Address,
     mode: VaultConfigFieldKind,
     value: string
-  ): IInstruction {
+  ): Instruction {
     const updateVaultConfigAccs: UpdateVaultConfigAccounts = {
       vaultAdminAuthority: admin,
       vaultState: vault,
@@ -836,6 +838,7 @@ export class KaminoVaultClient {
     const updateVaultConfigIx = updateVaultConfig(
       updateVaultConfigArgs,
       updateVaultConfigAccs,
+      undefined,
       this._kaminoVaultProgramId
     );
 
@@ -860,14 +863,14 @@ export class KaminoVaultClient {
       vaultState: vault.address,
     };
 
-    const acceptVaultOwnershipIx = updateAdmin(acceptOwneshipAccounts, this._kaminoVaultProgramId);
+    const acceptVaultOwnershipIx = updateAdmin(acceptOwneshipAccounts, undefined, this._kaminoVaultProgramId);
 
     // read the current LUT and create a new one for the new admin and backfill it
     const accountsInExistentLUT = (await getAccountsInLut(this.getConnection(), vaultState.vaultLookupTable)).filter(
       (account) => account !== vaultState.vaultAdminAuthority
     );
 
-    const lutIxs: IInstruction[] = [];
+    const lutIxs: Instruction[] = [];
     const [initNewLutIx, newLut] = await initLookupTableIx(
       signer,
       await this.getConnection().getSlot({ commitment: 'finalized' }).send()
@@ -906,7 +909,7 @@ export class KaminoVaultClient {
     vault: KaminoVault,
     maxAmountToGiveUp: Decimal,
     vaultAdminAuthority?: TransactionSigner
-  ): Promise<IInstruction> {
+  ): Promise<Instruction> {
     const vaultState: VaultState = await vault.getState(this.getConnection());
     const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
 
@@ -924,7 +927,7 @@ export class KaminoVaultClient {
       maxAmountToGiveUp: new BN(maxAmountToGiveUpLamports.toString()),
     };
 
-    return giveUpPendingFees(giveUpPendingFeesArgs, giveUpPendingFeesAccounts, this._kaminoVaultProgramId);
+    return giveUpPendingFees(giveUpPendingFeesArgs, giveUpPendingFeesAccounts, undefined, this._kaminoVaultProgramId);
   }
 
   /**
@@ -941,7 +944,7 @@ export class KaminoVaultClient {
     slot: Slot,
     vaultReservesMap?: Map<Address, KaminoReserve>,
     vaultAdminAuthority?: TransactionSigner
-  ): Promise<IInstruction[]> {
+  ): Promise<Instruction[]> {
     const vaultState: VaultState = await vault.getState(this.getConnection());
     const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
@@ -985,7 +988,7 @@ export class KaminoVaultClient {
       reservesToWithdraw,
       this._kaminoLendProgramId
     );
-    const withdrawIxs: IInstruction[] = await Promise.all(
+    const withdrawIxs: Instruction[] = await Promise.all(
       reservesToWithdraw.map(async (reserve, index) => {
         if (reserveStates[index] === null) {
           throw new Error(`Reserve ${reserve} not found`);
@@ -1008,7 +1011,7 @@ export class KaminoVaultClient {
     return [createAtaIx, ...withdrawIxs];
   }
 
-  // async closeVaultIx(vault: KaminoVault): Promise<IInstruction> {
+  // async closeVaultIx(vault: KaminoVault): Promise<Instruction> {
   //   const vaultState: VaultState = await vault.getState(this.getConnection());
 
   //   const closeVaultAccounts: CloseVaultAccounts = {
@@ -1039,8 +1042,8 @@ export class KaminoVaultClient {
 
     const tokenProgramID = vaultState.tokenProgram;
     const userTokenAta = await getAssociatedTokenAddress(vaultState.tokenMint, user.address, tokenProgramID);
-    const createAtasIxs: IInstruction[] = [];
-    const closeAtasIxs: IInstruction[] = [];
+    const createAtasIxs: Instruction[] = [];
+    const closeAtasIxs: Instruction[] = [];
     if (vaultState.tokenMint === WRAPPED_SOL_MINT) {
       const [{ ata: wsolAta, createAtaIx: createWsolAtaIxn }] = await createAtasIdempotent(user, [
         {
@@ -1090,7 +1093,7 @@ export class KaminoVaultClient {
       ),
     };
 
-    let depositIx = deposit(depositArgs, depositAccounts, this._kaminoVaultProgramId);
+    let depositIx = deposit(depositArgs, depositAccounts, undefined, this._kaminoVaultProgramId);
 
     const vaultReserves = this.getVaultReserves(vaultState);
 
@@ -1126,7 +1129,7 @@ export class KaminoVaultClient {
     vault: KaminoVault,
     sharesAmount?: Decimal,
     farmState?: FarmState
-  ): Promise<IInstruction[]> {
+  ): Promise<Instruction[]> {
     const vaultState = await vault.getState(this.getConnection());
 
     let sharesToStakeLamports = new Decimal(U64_MAX);
@@ -1287,7 +1290,7 @@ export class KaminoVaultClient {
     user: TransactionSigner,
     vault: KaminoVault,
     shareAmount: Decimal
-  ): Promise<IInstruction[]> {
+  ): Promise<Instruction[]> {
     const vaultState = await vault.getState(this.getConnection());
     const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
 
@@ -1319,7 +1322,7 @@ export class KaminoVaultClient {
     allUserShares: Decimal,
     slot: Slot,
     vaultReservesMap?: Map<Address, KaminoReserve>
-  ): Promise<IInstruction[]> {
+  ): Promise<Instruction[]> {
     const vaultState = await vault.getState(this.getConnection());
 
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
@@ -1395,7 +1398,7 @@ export class KaminoVaultClient {
       });
     }
 
-    const withdrawIxs: IInstruction[] = [];
+    const withdrawIxs: Instruction[] = [];
     withdrawIxs.push(createAtaIx);
     for (let reserveIndex = 0; reserveIndex < reserveWithSharesAmountToWithdraw.length; reserveIndex++) {
       const reserveWithTokens = reserveWithSharesAmountToWithdraw[reserveIndex];
@@ -1435,7 +1438,7 @@ export class KaminoVaultClient {
    * @param vault - vault to invest from
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
-  async investAllReservesIxs(payer: TransactionSigner, vault: KaminoVault): Promise<IInstruction[]> {
+  async investAllReservesIxs(payer: TransactionSigner, vault: KaminoVault): Promise<Instruction[]> {
     const vaultState = await vault.getState(this.getConnection());
     const minInvestAmount = vaultState.minInvestAmount;
     const allReserves = this.getVaultReserves(vaultState);
@@ -1483,7 +1486,7 @@ export class KaminoVaultClient {
       }
     }
 
-    const investIxsPromises: Promise<IInstruction[]>[] = [];
+    const investIxsPromises: Promise<Instruction[]>[] = [];
     // invest first the reserves from which we disinvest, then the other ones
     for (const reserve of reservesToDisinvestFrom) {
       const reserveState = allReservesStateMap.get(reserve);
@@ -1521,7 +1524,7 @@ export class KaminoVaultClient {
       investIxsPromises.push(investIxsPromise);
     }
 
-    let investIxs: IInstruction[] = [];
+    let investIxs: Instruction[] = [];
     investIxs.push(createAtaIx);
     investIxs = await Promise.all(investIxsPromises).then((ixs) => ixs.flat());
 
@@ -1544,12 +1547,12 @@ export class KaminoVaultClient {
     reserve: ReserveWithAddress,
     vaultReservesMap?: Map<Address, KaminoReserve>,
     createAtaIfNeeded: boolean = true
-  ): Promise<IInstruction[]> {
+  ): Promise<Instruction[]> {
     const vaultState = await vault.getState(this.getConnection());
     const cTokenVault = await getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
     const [lendingMarketAuth] = await lendingMarketAuthPda(reserve.state.lendingMarket, this._kaminoLendProgramId);
 
-    const ixs: IInstruction[] = [];
+    const ixs: Instruction[] = [];
 
     const tokenProgram = await getAccountOwner(this.getConnection(), vaultState.tokenMint);
     const [{ ata: payerTokenAta, createAtaIx }] = await createAtasIdempotent(payer, [
@@ -1579,7 +1582,7 @@ export class KaminoVaultClient {
       reserveCollateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
     };
 
-    let investIx = invest(investAccounts, this._kaminoVaultProgramId);
+    let investIx = invest(investAccounts, undefined, this._kaminoVaultProgramId);
 
     const vaultReserves = this.getVaultReserves(vaultState);
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
@@ -1610,7 +1613,7 @@ export class KaminoVaultClient {
     userTokenAta: Address,
     shareAmountLamports: Decimal,
     vaultReservesState: Map<Address, KaminoReserve>
-  ): Promise<IInstruction> {
+  ): Promise<Instruction> {
     const [lendingMarketAuth] = await lendingMarketAuthPda(marketAddress, this._kaminoLendProgramId);
 
     const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
@@ -1649,7 +1652,7 @@ export class KaminoVaultClient {
       sharesAmount: new BN(shareAmountLamports.floor().toString()),
     };
 
-    let withdrawIxn = withdraw(withdrawArgs, withdrawAccounts, this._kaminoVaultProgramId);
+    let withdrawIxn = withdraw(withdrawArgs, withdrawAccounts, undefined, this._kaminoVaultProgramId);
 
     const vaultReserves = this.getVaultReserves(vaultState);
     withdrawIxn = this.appendRemainingAccountsForVaultReserves(withdrawIxn, vaultReserves, vaultReservesState);
@@ -1664,7 +1667,7 @@ export class KaminoVaultClient {
     userSharesAta: Address,
     userTokenAta: Address,
     shareAmountLamports: Decimal
-  ): Promise<IInstruction> {
+  ): Promise<Instruction> {
     const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
     const withdrawFromAvailableAccounts: WithdrawFromAvailableAccounts = {
       user,
@@ -1686,7 +1689,7 @@ export class KaminoVaultClient {
       sharesAmount: new BN(shareAmountLamports.floor().toString()),
     };
 
-    return withdrawFromAvailable(withdrawFromAvailableArgs, withdrawFromAvailableAccounts, this._kaminoVaultProgramId);
+    return withdrawFromAvailable(withdrawFromAvailableArgs, withdrawFromAvailableAccounts, undefined, this._kaminoVaultProgramId);
   }
 
   private async withdrawPendingFeesIx(
@@ -1696,7 +1699,7 @@ export class KaminoVaultClient {
     marketAddress: Address,
     reserve: ReserveWithAddress,
     adminTokenAta: Address
-  ): Promise<IInstruction> {
+  ): Promise<Instruction> {
     const [lendingMarketAuth] = await lendingMarketAuthPda(marketAddress, this._kaminoLendProgramId);
 
     const withdrawPendingFeesAccounts: WithdrawPendingFeesAccounts = {
@@ -1719,7 +1722,7 @@ export class KaminoVaultClient {
       reserveCollateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
     };
 
-    let withdrawPendingFeesIxn = withdrawPendingFees(withdrawPendingFeesAccounts, this._kaminoVaultProgramId);
+    let withdrawPendingFeesIxn = withdrawPendingFees(withdrawPendingFeesAccounts, undefined, this._kaminoVaultProgramId);
 
     const vaultReserves = this.getVaultReserves(vaultState);
     const vaultReservesState = await this.loadVaultReserves(vaultState);
@@ -1788,7 +1791,7 @@ export class KaminoVaultClient {
       allAccountsToBeInserted.push(vaultState.vaultFarm);
     }
 
-    const setupLUTIfNeededIxs: IInstruction[] = [];
+    const setupLUTIfNeededIxs: Instruction[] = [];
     let lut = vaultState.vaultLookupTable;
     if (lut === DEFAULT_PUBLIC_KEY) {
       const recentSlot = await this.getConnection().getSlot({ commitment: 'confirmed' }).send();
@@ -1805,7 +1808,7 @@ export class KaminoVaultClient {
       setupLUTIfNeededIxs.push(updateVaultConfigIxs.updateVaultConfigIx);
     }
 
-    const ixs: IInstruction[] = [];
+    const ixs: Instruction[] = [];
     let overriddenExistentAccounts: Address[] | undefined = undefined;
     if (vaultState.vaultLookupTable === DEFAULT_PUBLIC_KEY) {
       overriddenExistentAccounts = [];
@@ -1846,7 +1849,7 @@ export class KaminoVaultClient {
     lookupTable: Address,
     keys: Address[],
     accountsInLut?: Address[]
-  ): Promise<IInstruction[]> {
+  ): Promise<Instruction[]> {
     let lutContentsList = accountsInLut;
     if (!accountsInLut) {
       lutContentsList = await getAccountsInLut(this.getConnection(), lookupTable);
@@ -1861,7 +1864,7 @@ export class KaminoVaultClient {
     const missingAccountsList = [...new Set<Address>(missingAccounts)];
 
     const chunkSize = 10;
-    const ixs: IInstruction[] = [];
+    const ixs: Instruction[] = [];
 
     for (let i = 0; i < missingAccountsList.length; i += chunkSize) {
       const chunk = missingAccountsList.slice(i, i + chunkSize);
@@ -2398,7 +2401,11 @@ export class KaminoVaultClient {
 
     reservesAndOracles.forEach(([reserve, oracle], index) => {
       if (!oracle) {
-        throw Error(`Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} reserve`);
+        throw Error(
+          `Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} (${
+            vaultReservesAddresses[index]
+          }) reserve in market ${reserve.lendingMarket}`
+        );
       }
       const kaminoReserve = KaminoReserve.initialize(
         vaultReservesAddresses[index],
@@ -3259,12 +3266,12 @@ export class KaminoVaultClient {
   }
 
   private appendRemainingAccountsForVaultReserves(
-    ix: IInstruction,
+    ix: Instruction,
     vaultReserves: Address[],
     vaultReservesState: Map<Address, KaminoReserve>
-  ): IInstruction {
-    let vaultReservesAccountMetas: IAccountMeta[] = [];
-    let vaultReservesLendingMarkets: IAccountMeta[] = [];
+  ): Instruction {
+    let vaultReservesAccountMetas: AccountMeta[] = [];
+    let vaultReservesLendingMarkets: AccountMeta[] = [];
     vaultReserves.forEach((reserve) => {
       const reserveState = vaultReservesState.get(reserve);
       if (reserveState === undefined) {

package/src/classes/vault_types.ts

@@ -1,40 +1,40 @@
-import { Address, IInstruction } from '@solana/kit';
+import { Address, Instruction } from '@solana/kit';
 import Decimal from 'decimal.js/decimal';
 
 /** the populateLUTIxs should be executed in a separate transaction as we cannot create and populate a lookup table in the same tx */
 export type InitVaultIxs = {
-  createAtaIfNeededIxs: IInstruction[];
-  initVaultIxs: IInstruction[];
-  createLUTIx: IInstruction;
-  populateLUTIxs: IInstruction[];
-  cleanupIxs: IInstruction[];
-  initSharesMetadataIx: IInstruction;
+  createAtaIfNeededIxs: Instruction[];
+  initVaultIxs: Instruction[];
+  createLUTIx: Instruction;
+  populateLUTIxs: Instruction[];
+  cleanupIxs: Instruction[];
+  initSharesMetadataIx: Instruction;
 };
 
 export type AcceptVaultOwnershipIxs = {
-  acceptVaultOwnershipIx: IInstruction;
-  initNewLUTIx: IInstruction;
-  updateLUTIxs: IInstruction[]; // this has to be executed in a transaction after the initNewLUTIx is executed
+  acceptVaultOwnershipIx: Instruction;
+  initNewLUTIx: Instruction;
+  updateLUTIxs: Instruction[]; // this has to be executed in a transaction after the initNewLUTIx is executed
 };
 
 export type UpdateReserveAllocationIxs = {
-  updateReserveAllocationIx: IInstruction;
-  updateLUTIxs: IInstruction[];
+  updateReserveAllocationIx: Instruction;
+  updateLUTIxs: Instruction[];
 };
 
 export type WithdrawAndBlockReserveIxs = {
-  updateReserveAllocationIxs: IInstruction[];
-  investIxs: IInstruction[];
+  updateReserveAllocationIxs: Instruction[];
+  investIxs: Instruction[];
 };
 
 export type DisinvestAllReservesIxs = {
-  updateReserveAllocationIxs: IInstruction[];
-  investIxs: IInstruction[];
+  updateReserveAllocationIxs: Instruction[];
+  investIxs: Instruction[];
 };
 
 export type UpdateVaultConfigIxs = {
-  updateVaultConfigIx: IInstruction;
-  updateLUTIxs: IInstruction[];
+  updateVaultConfigIx: Instruction;
+  updateLUTIxs: Instruction[];
 };
 
 export type VaultComputedAllocation = {
@@ -44,21 +44,21 @@ export type VaultComputedAllocation = {
 
 /** If there are ixs to setup the LUT it means it doesn't already exist and it needs to be created in a separate tx before inserting into it */
 export type SyncVaultLUTIxs = {
-  setupLUTIfNeededIxs: IInstruction[];
-  syncLUTIxs: IInstruction[];
+  setupLUTIfNeededIxs: Instruction[];
+  syncLUTIxs: Instruction[];
 };
 
 /** If the stakeInFarmIfNeededIxs exist they have to be executed after the deposit so the shares received from the deposit are staked in the vault farm */
 export type DepositIxs = {
-  depositIxs: IInstruction[];
-  stakeInFarmIfNeededIxs: IInstruction[];
+  depositIxs: Instruction[];
+  stakeInFarmIfNeededIxs: Instruction[];
 };
 
 /** the ixs to unstake shares from farm and withdraw them from the vault. The `unstakeFromFarmIfNeededIxs` should be in the tx before `withdrawIxs`*/
 export type WithdrawIxs = {
-  unstakeFromFarmIfNeededIxs: IInstruction[];
-  withdrawIxs: IInstruction[];
-  postWithdrawIxs: IInstruction[]; // if needed: wSOL ATA close ix + share ATA close ix
+  unstakeFromFarmIfNeededIxs: Instruction[];
+  withdrawIxs: Instruction[];
+  postWithdrawIxs: Instruction[]; // if needed: wSOL ATA close ix + share ATA close ix
 };
 
 /** The shares an user has in a vault (staked and unstaked), in tokens */

package/src/client/tx/multisig.ts

@@ -6,7 +6,7 @@ import {
   createTransactionMessage,
   getBase58Decoder,
   getCompiledTransactionMessageEncoder,
-  IInstruction,
+  Instruction,
   pipe,
   setTransactionMessageFeePayer,
   setTransactionMessageLifetimeUsingBlockhash,
@@ -20,7 +20,7 @@ const base58Decoder = getBase58Decoder();
 
 export async function printMultisigTx(
   payer: TransactionSigner,
-  ixs: IInstruction[],
+  ixs: Instruction[],
   luts: Account<AddressLookupTable>[] = []
 ) {
   const lutsByAddress: AddressesByLookupTableAddress = {};

package/src/client/tx/priorityFee.ts

@@ -1,4 +1,4 @@
-import { IInstruction } from '@solana/kit';
+import { Instruction } from '@solana/kit';
 import {
   COMPUTE_BUDGET_PROGRAM_ADDRESS,
   getSetComputeUnitLimitInstruction,
@@ -13,7 +13,7 @@ export function getPriorityFeeAndCuIxs({
 }: {
   priorityFeeMultiplier: number;
   computeUnits?: number;
-}): IInstruction[] {
+}): Instruction[] {
   const microLamportsPrioritizationFee = microLamport / computeUnits;
   return [
     getSetComputeUnitLimitInstruction({ units: computeUnits }),
@@ -23,7 +23,7 @@ export function getPriorityFeeAndCuIxs({
   ];
 }
 
-export function removeComputeBudgetProgramInstructions(ixs: IInstruction[]): IInstruction[] {
+export function removeComputeBudgetProgramInstructions(ixs: Instruction[]): Instruction[] {
   const filteredIxs = ixs.filter((ix) => {
     if (ix.programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS) {
       return false;

package/src/client/tx/processor.ts

@@ -1,5 +1,5 @@
 import { CliConnectionPool } from './CliConnectionPool';
-import { Account, IInstruction, TransactionSigner } from '@solana/kit';
+import { Account, Instruction, TransactionSigner } from '@solana/kit';
 import { sendAndConfirmTx } from './tx';
 import { printSimulateTx } from './simulate';
 import { printMultisigTx } from './multisig';
@@ -9,7 +9,7 @@ import { AddressLookupTable } from '@solana-program/address-lookup-table';
 export async function processTx(
   c: CliConnectionPool,
   payer: TransactionSigner,
-  ixs: IInstruction[],
+  ixs: Instruction[],
   mode: SendTxMode,
   luts: Account<AddressLookupTable>[] = []
 ): Promise<void> {

package/src/client/tx/simulate.ts

@@ -1,5 +1,5 @@
 import {
-  IInstruction,
+  Instruction,
   pipe,
   createTransactionMessage,
   setTransactionMessageFeePayer,
@@ -28,7 +28,7 @@ export const INVALID_BUT_SUFFICIENT_FOR_COMPILATION_BLOCKHASH: BlockhashWithHeig
 export async function printSimulateTx(
   c: CliConnectionPool,
   payer: TransactionSigner,
-  ixs: IInstruction[],
+  ixs: Instruction[],
   luts: Account<AddressLookupTable>[] = []
 ) {
   const lutsByAddress: AddressesByLookupTableAddress = {};

package/src/client/tx/tx.ts

@@ -11,7 +11,7 @@ import {
   GetLatestBlockhashApi,
   getSignatureFromTransaction,
   GetSignatureStatusesApi,
-  IInstruction,
+  Instruction,
   pipe,
   RpcSubscriptions,
   sendAndConfirmTransactionFactory,
@@ -32,7 +32,7 @@ import { CliConnectionPool } from './CliConnectionPool';
 export async function sendAndConfirmTx(
   c: CliConnectionPool,
   payer: TransactionSigner,
-  ixs: IInstruction[],
+  ixs: Instruction[],
   luts: Account<AddressLookupTable>[] = []
 ): Promise<Signature> {
   const blockhash = await fetchBlockhash(c.rpc);

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -19,12 +19,12 @@ import {
   uniqueAccountsWithProgramIds,
 } from '../utils';
 import { AddressLookupTable } from '@solana-program/address-lookup-table';
-import { Account, Address, IInstruction, none, Option, Slot, TransactionSigner } from '@solana/kit';
+import { Account, Address, Instruction, none, Option, Slot, TransactionSigner } from '@solana/kit';
 import Decimal from 'decimal.js';
 import { calcMaxWithdrawCollateral, calcRepayAmountWithSlippage } from './repay_with_collateral_calcs';
 
 export type RepayWithCollIxsResponse<QuoteResponse> = {
-  ixs: IInstruction[];
+  ixs: Instruction[];
   lookupTables: Account<AddressLookupTable>[];
   flashLoanInfo: FlashLoanInfo;
   swapInputs: SwapInputs;
@@ -57,7 +57,7 @@ interface RepayWithCollSwapInputsProps<QuoteResponse> {
   currentSlot: Slot;
   repayAmount: Decimal;
   isClosingPosition: boolean;
-  budgetAndPriorityFeeIxs?: IInstruction[];
+  budgetAndPriorityFeeIxs?: Instruction[];
   scopeRefreshConfig?: ScopePriceRefreshConfig;
   useV2Ixs: boolean;
   quoter: SwapQuoteProvider<QuoteResponse>;
@@ -285,7 +285,7 @@ async function buildRepayWithCollateralIxs<QuoteResponse>(
   obligation: KaminoObligation,
   referrer: Option<Address>,
   currentSlot: Slot,
-  budgetAndPriorityFeeIxs: IInstruction[] | undefined,
+  budgetAndPriorityFeeIxs: Instruction[] | undefined,
   scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
   swapQuoteIxsArray: SwapIxs<QuoteResponse>[],
   isClosingPosition: boolean,