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

package/src/classes/reserve.ts

@@ -1134,6 +1134,7 @@ const truncateBorrowCurve = (points: CurvePointFields[]): [number, number][] =>
 export async function createReserveIxs(
   connection: Connection,
   owner: PublicKey,
+  ownerLiquiditySource: PublicKey,
   lendingMarket: PublicKey,
   liquidityMint: PublicKey,
   reserveAddress: PublicKey,
@@ -1166,6 +1167,7 @@ export async function createReserveIxs(
     feeReceiver: feeVault,
     reserveCollateralMint: collateralMint,
     reserveCollateralSupply: collateralSupplyVault,
+    initialLiquiditySource: ownerLiquiditySource,
     liquidityTokenProgram: TOKEN_PROGRAM_ID,
     collateralTokenProgram: TOKEN_PROGRAM_ID,
     systemProgram: SystemProgram.programId,
@@ -1537,7 +1539,7 @@ function handleConfigUpdate(
           mode: UpdateConfigMode.UpdateDepositLimit.discriminator,
           value: updateReserveConfigEncodedValue(
             UpdateConfigMode.UpdateDepositLimit.discriminator,
-            reserveConfig.depositLimit.toNumber()
+            BigInt(reserveConfig.depositLimit.toString())
           ),
         });
       } else if (!reserve.config.depositLimit.eq(reserveConfig.depositLimit)) {
@@ -1545,7 +1547,7 @@ function handleConfigUpdate(
           mode: UpdateConfigMode.UpdateDepositLimit.discriminator,
           value: updateReserveConfigEncodedValue(
             UpdateConfigMode.UpdateDepositLimit.discriminator,
-            reserveConfig.depositLimit.toNumber()
+            BigInt(reserveConfig.depositLimit.toString())
           ),
         });
       }
@@ -1556,7 +1558,7 @@ function handleConfigUpdate(
           mode: UpdateConfigMode.UpdateBorrowLimit.discriminator,
           value: updateReserveConfigEncodedValue(
             UpdateConfigMode.UpdateBorrowLimit.discriminator,
-            reserveConfig.borrowLimit.toNumber()
+            BigInt(reserveConfig.borrowLimit.toString())
           ),
         });
       } else if (!reserve.config.borrowLimit.eq(reserveConfig.borrowLimit)) {
@@ -1564,7 +1566,7 @@ function handleConfigUpdate(
           mode: UpdateConfigMode.UpdateBorrowLimit.discriminator,
           value: updateReserveConfigEncodedValue(
             UpdateConfigMode.UpdateBorrowLimit.discriminator,
-            reserveConfig.borrowLimit.toNumber()
+            BigInt(reserveConfig.borrowLimit.toString())
           ),
         });
       }
@@ -1976,15 +1978,12 @@ function handleConfigUpdate(
             reserveConfig.borrowLimitOutsideElevationGroup.toNumber()
           ),
         });
-      } else if (
-        reserve.config.borrowLimitOutsideElevationGroup.toNumber() !==
-        reserveConfig.borrowLimitOutsideElevationGroup.toNumber()
-      ) {
+      } else if (!reserve.config.borrowLimitOutsideElevationGroup.eq(reserveConfig.borrowLimitOutsideElevationGroup)) {
         updateReserveIxnsArgs.push({
           mode: UpdateConfigMode.UpdateBorrowLimitOutsideElevationGroup.discriminator,
           value: updateReserveConfigEncodedValue(
             UpdateConfigMode.UpdateBorrowLimitOutsideElevationGroup.discriminator,
-            reserveConfig.borrowLimitOutsideElevationGroup.toNumber()
+            BigInt(reserveConfig.borrowLimitOutsideElevationGroup.toString())
           ),
         });
       }
@@ -2106,7 +2105,7 @@ export function parseForChangesReserveConfigAndGetIxs(
 
 export function updateReserveConfigEncodedValue(
   discriminator: number,
-  value: number | number[] | BorrowRateCurve | PublicKey
+  value: number | number[] | bigint | BorrowRateCurve | PublicKey
 ): Uint8Array {
   let buffer: Buffer;
   let valueArray: number[] = [];
@@ -2133,8 +2132,6 @@ export function updateReserveConfigEncodedValue(
       break;
     case UpdateConfigMode.UpdateFeesBorrowFee.discriminator:
     case UpdateConfigMode.UpdateFeesFlashLoanFee.discriminator:
-    case UpdateConfigMode.UpdateDepositLimit.discriminator:
-    case UpdateConfigMode.UpdateBorrowLimit.discriminator:
     case UpdateConfigMode.UpdateTokenInfoLowerHeuristic.discriminator:
     case UpdateConfigMode.UpdateTokenInfoUpperHeuristic.discriminator:
     case UpdateConfigMode.UpdateTokenInfoExpHeuristic.discriminator:
@@ -2147,11 +2144,17 @@ export function updateReserveConfigEncodedValue(
     case UpdateConfigMode.UpdateBorrowFactor.discriminator:
     case UpdateConfigMode.UpdateDeleveragingThresholdDecreaseBpsPerDay.discriminator:
     case UpdateConfigMode.UpdateDeleveragingBonusIncreaseBpsPerDay.discriminator:
-    case UpdateConfigMode.UpdateBorrowLimitOutsideElevationGroup.discriminator:
       value = value as number;
       buffer = Buffer.alloc(8);
       buffer.writeBigUint64LE(BigInt(value), 0);
       break;
+    case UpdateConfigMode.UpdateDepositLimit.discriminator:
+    case UpdateConfigMode.UpdateBorrowLimit.discriminator:
+    case UpdateConfigMode.UpdateBorrowLimitOutsideElevationGroup.discriminator:
+      value = value as bigint;
+      buffer = Buffer.alloc(8);
+      buffer.writeBigUint64LE(value, 0);
+      break;
     case UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator:
     case UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator:
       valueArray = value as number[];

package/src/classes/types.ts

@@ -54,3 +54,8 @@ export type ReserveAllocationOverview = {
   tokenAllocationCap: Decimal;
   ctokenAllocation: Decimal;
 };
+
+export type APYs = {
+  grossAPY: Decimal;
+  netAPY: Decimal;
+}

package/src/classes/utils.ts

@@ -1,8 +1,8 @@
 import { PubkeyHashMap, SLOTS_PER_SECOND, SLOTS_PER_YEAR } from '../utils';
 import Decimal from 'decimal.js';
 import { AccountInfo, PublicKey } from '@solana/web3.js';
-import { MarketOverview, ReserveOverview, SOL_MINTS } from '../lib';
-import { AccountLayout } from '@solana/spl-token';
+import { MarketOverview, ReserveOverview } from '../lib';
+import { AccountLayout, NATIVE_MINT } from '@solana/spl-token';
 import { ReserveAllocationOverview } from './types';
 import axios from 'axios';
 
@@ -188,7 +188,7 @@ export function lamportsToDecimal(amount: Decimal.Value, decimals: Decimal.Value
 }
 
 export const isSolMint = (mint: PublicKey): boolean => {
-  return SOL_MINTS.filter((m) => m.equals(mint)).length > 0;
+  return NATIVE_MINT.equals(mint);
 };
 
 export const valueOrZero = (value: Decimal): Decimal => {

package/src/classes/vault.ts

@@ -11,10 +11,10 @@ import {
   SYSVAR_RENT_PUBKEY,
   TransactionInstruction,
 } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
+import { getAssociatedTokenAddressSync, NATIVE_MINT, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
 import {
   getAssociatedTokenAddress,
-  getDepositWsolIxns,
+  getTransferWsolIxns,
   getTokenOracleData,
   KaminoMarket,
   KaminoReserve,
@@ -22,7 +22,6 @@ import {
   PubkeyHashMap,
   Reserve,
   UserState,
-  WRAPPED_SOL_MINT,
 } from '../lib';
 import {
   DepositAccounts,
@@ -70,6 +69,7 @@ import bs58 from 'bs58';
 import { getAccountOwner, getProgramAccounts } from '../utils/rpc';
 import {
   AcceptVaultOwnershipIxs,
+  APYs,
   DepositIxs,
   InitVaultIxs,
   ReserveAllocationOverview,
@@ -79,7 +79,7 @@ import {
   UserSharesForVault,
   WithdrawIxs,
 } from './types';
-import { collToLamportsDecimal, ZERO } from '@kamino-finance/kliquidity-sdk';
+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';
@@ -98,7 +98,9 @@ export const kaminoVaultStagingId = new PublicKey('STkvh7ostar39Fwr4uZKASs1RNNuY
 const TOKEN_VAULT_SEED = 'token_vault';
 const CTOKEN_VAULT_SEED = 'ctoken_vault';
 const BASE_VAULT_AUTHORITY_SEED = 'authority';
-const SHARES_SEEDS = 'shares';
+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.
@@ -191,10 +193,12 @@ export class KaminoVaultClient {
     )[0];
 
     const sharesMint = PublicKey.findProgramAddressSync(
-      [Buffer.from(SHARES_SEEDS), vaultState.publicKey.toBytes()],
+      [Buffer.from(SHARES_SEED), vaultState.publicKey.toBytes()],
       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,
@@ -694,20 +699,20 @@ export class KaminoVaultClient {
     const userTokenAta = getAssociatedTokenAddress(vaultState.tokenMint, user, true, tokenProgramID);
     const createAtasIxns: TransactionInstruction[] = [];
     const closeAtasIxns: TransactionInstruction[] = [];
-    if (vaultState.tokenMint.equals(WRAPPED_SOL_MINT)) {
+    if (vaultState.tokenMint.equals(NATIVE_MINT)) {
       const [{ ata: wsolAta, createAtaIx: createWsolAtaIxn }] = createAtasIdempotent(user, [
         {
-          mint: WRAPPED_SOL_MINT,
+          mint: NATIVE_MINT,
           tokenProgram: TOKEN_PROGRAM_ID,
         },
       ]);
       createAtasIxns.push(createWsolAtaIxn);
-      const depositWsolIxn = getDepositWsolIxns(
+      const transferWsolIxns = getTransferWsolIxns(
         user,
         wsolAta,
         numberToLamportsDecimal(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil()
       );
-      createAtasIxns.push(...depositWsolIxn);
+      createAtasIxns.push(...transferWsolIxns);
     }
 
     const [{ ata: userSharesAta, createAtaIx: createSharesAtaIxns }] = createAtasIdempotent(user, [
@@ -1005,25 +1010,23 @@ export class KaminoVaultClient {
    */
   async investAllReservesIxs(payer: PublicKey, vault: KaminoVault): Promise<TransactionInstruction[]> {
     const vaultState = await vault.getState(this.getConnection());
+    const minInvestAmount = vaultState.minInvestAmount;
     const allReserves = this.getVaultReserves(vaultState);
     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[] = [];
 
     for (let index = 0; index < allReserves.length; index++) {
       const reservePubkey = allReserves[index];
@@ -1037,8 +1040,15 @@ export class KaminoVaultClient {
         vaultState.tokenMintDecimals.toNumber()
       );
 
-      if (computedAllocation.lt(reserveAllocationLiquidityAmount)) {
-        reservesToDisinvestFrom.push(reservePubkey);
+      const diffInReserveTokens = computedAllocation.sub(reserveAllocationLiquidityAmount);
+      const diffInReserveLamports = collToLamportsDecimal(diffInReserveTokens, vaultState.tokenMintDecimals.toNumber());
+      // if the diff for the reserve is smaller than the min invest amount, we do not need to invest or disinvest
+      if (diffInReserveLamports.abs().gte(new Decimal(minInvestAmount.toString()))) {
+        if (computedAllocation.lt(reserveAllocationLiquidityAmount)) {
+          reservesToDisinvestFrom.push(reservePubkey);
+        } else {
+          reservesToInvestInto.push(reservePubkey);
+        }
       }
     }
 
@@ -1062,24 +1072,22 @@ export class KaminoVaultClient {
       investIxnsPromises.push(investIxsPromise);
     }
 
-    for (const reserve of allReserves) {
-      if (!reservesToDisinvestFrom.includes(reserve)) {
-        const reserveState = allReservesStateMap.get(reserve);
-        if (reserveState === null) {
-          throw new Error(`Reserve ${reserve.toBase58()} not found`);
-        }
-        const investIxsPromise = this.investSingleReserveIxs(
-          payer,
-          vault,
-          {
-            address: reserve,
-            state: reserveState!.state,
-          },
-          allReservesStateMap,
-          false
-        );
-        investIxnsPromises.push(investIxsPromise);
+    for (const reserve of reservesToInvestInto) {
+      const reserveState = allReservesStateMap.get(reserve);
+      if (reserveState === null) {
+        throw new Error(`Reserve ${reserve.toBase58()} not found`);
       }
+      const investIxsPromise = this.investSingleReserveIxs(
+        payer,
+        vault,
+        {
+          address: reserve,
+          state: reserveState!.state,
+        },
+        allReservesStateMap,
+        false
+      );
+      investIxnsPromises.push(investIxsPromise);
     }
 
     let investIxns: TransactionInstruction[] = [];
@@ -1493,6 +1501,21 @@ export class KaminoVaultClient {
     vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>,
     currentSlot?: number
   ): Promise<PubkeyHashMap<PublicKey, Decimal>> {
+    // if there are no vault reserves or all have weight 0 everything has to be in Available
+    const allReservesPubkeys = this.getVaultReserves(vaultState);
+    const reservesAllocations = this.getVaultAllocations(vaultState);
+    const allReservesHaveWeight0 = allReservesPubkeys.every((reserve) => {
+      const allocation = reservesAllocations.get(reserve);
+      return allocation?.targetWeight.isZero();
+    });
+    if (allReservesPubkeys.length === 0 || allReservesHaveWeight0) {
+      const computedHoldings = new PubkeyHashMap<PublicKey, Decimal>();
+      allReservesPubkeys.forEach((reserve) => {
+        computedHoldings.set(reserve, new Decimal(0));
+      });
+      return computedHoldings;
+    }
+
     const holdings = await this.getVaultHoldings(vaultState, slot, vaultReserves, currentSlot);
     const initialVaultAllocations = this.getVaultAllocations(vaultState);
 
@@ -1506,14 +1529,13 @@ 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);
         const targetAllocation = reserveWithWeight!.targetWeight.mul(totalLeftover).div(currentAllocationSum);
         const reserveCap = reserveWithWeight!.tokenAllocationCap;
-        // todo: check if both target and reserveCap
         const amountToInvest = Decimal.min(targetAllocation, reserveCap, totalLeftToInvest);
         totalLeftToInvest = totalLeftToInvest.sub(amountToInvest);
         if (amountToInvest.eq(reserveCap)) {
@@ -1749,6 +1771,26 @@ export class KaminoVaultClient {
     });
   }
 
+  /**
+   * Get a list of kaminoVaults
+   * @param vaults - a list of vaults to get the states for; if not provided, all vaults will be fetched
+   * @returns a list of vaults
+   */
+  async getVaults(vaults?: Array<PublicKey>): Promise<Array<KaminoVault | null>> {
+    if (!vaults) {
+      vaults = (await this.getAllVaults()).map((x) => x.address);
+    }
+    const vaultStates = await batchFetch(vaults, (chunk) => this.getVaultsStates(chunk));
+    return vaults.map((vault, index) => {
+      const state = vaultStates[index];
+      return state ? new KaminoVault(vault, state, this._kaminoVaultProgramId) : null;
+    });
+  }
+
+  private async getVaultsStates(vaults: PublicKey[]): Promise<Array<VaultState | null>> {
+    return await VaultState.fetchMultiple(this.getConnection(), vaults, this._kaminoVaultProgramId);
+  }
+
   /**
    * This will return the amount of token invested from the vault into the given reserve
    * @param vault - the kamino vault to get invested amount in reserve for
@@ -1898,7 +1940,17 @@ export class KaminoVaultClient {
    * @returns a hashmap from each reserve pubkey to the reserve state
    */
   async loadVaultReserves(vaultState: VaultState): Promise<PubkeyHashMap<PublicKey, KaminoReserve>> {
-    const vaultReservesAddresses = this.getVaultReserves(vaultState);
+    return this.loadVaultsReserves([vaultState]);
+  }
+
+  /**
+   * This will load the onchain state for all the reserves that the vaults have allocations for, deduplicating the reserves
+   * @param vaults - the vault states to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  async loadVaultsReserves(vaults: VaultState[]): Promise<PubkeyHashMap<PublicKey, KaminoReserve>> {
+    const vaultReservesAddressesSet = new PublicKeySet(vaults.flatMap((vault) => this.getVaultReserves(vault)));
+    const vaultReservesAddresses = vaultReservesAddressesSet.toArray();
     const reserveAccounts = await this.getConnection().getMultipleAccountsInfo(vaultReservesAddresses, 'processed');
 
     const deserializedReserves = reserveAccounts.map((reserve, i) => {
@@ -2179,7 +2231,7 @@ export class KaminoVaultClient {
     // all the async part of the functions above just read the vaultReservesState which is read beforehand, so excepting vaultCollateralsPromise they should do no additional network calls
     const [
       vaultHoldingsWithUSDValue,
-      vaultTheoreticalAPY,
+      vaultTheoreticalAPYs,
       totalInvestedAndBorrowed,
       vaultCollaterals,
       reservesOverview,
@@ -2195,7 +2247,7 @@ export class KaminoVaultClient {
       holdingsUSD: vaultHoldingsWithUSDValue,
       reservesOverview: reservesOverview,
       vaultCollaterals: vaultCollaterals,
-      theoreticalSupplyAPY: vaultTheoreticalAPY,
+      theoreticalSupplyAPY: vaultTheoreticalAPYs,
       totalBorrowed: totalInvestedAndBorrowed.totalBorrowed,
       utilizationRatio: totalInvestedAndBorrowed.utilizationRatio,
       totalSupplied: totalInvestedAndBorrowed.totalInvested,
@@ -2306,13 +2358,13 @@ export class KaminoVaultClient {
    * @param vault - the kamino vault to get APY for
    * @param slot - current slot
    * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
-   * @returns APY for the vault
+   * @returns a struct containing estimated gross APY and net APY (gross - vault fees) for the vault
    */
   async getVaultTheoreticalAPY(
     vault: VaultState,
     slot: number,
     vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
-  ): Promise<Decimal> {
+  ): Promise<APYs> {
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vault);
 
     let totalWeights = new Decimal(0);
@@ -2334,14 +2386,20 @@ export class KaminoVaultClient {
       totalWeights = totalWeights.add(weight);
     });
     if (totalWeights.isZero()) {
-      return new Decimal(0);
+      return {
+        grossAPY: new Decimal(0),
+        netAPY: new Decimal(0),
+      };
     }
 
     const grossAPY = totalAPY.div(totalWeights);
     const netAPY = grossAPY
       .mul(new Decimal(1).sub(new Decimal(vault.performanceFeeBps.toString()).div(FullBPSDecimal)))
       .mul(new Decimal(1).sub(new Decimal(vault.managementFeeBps.toString()).div(FullBPSDecimal)));
-    return netAPY;
+    return {
+      grossAPY,
+      netAPY,
+    };
   }
 
   /**
@@ -2610,7 +2668,7 @@ export type VaultOverview = {
   holdingsUSD: VaultHoldingsWithUSDValue;
   reservesOverview: PubkeyHashMap<PublicKey, ReserveOverview>;
   vaultCollaterals: PubkeyHashMap<PublicKey, MarketOverview>;
-  theoreticalSupplyAPY: Decimal;
+  theoreticalSupplyAPY: APYs;
   totalBorrowed: Decimal;
   totalSupplied: Decimal;
   utilizationRatio: Decimal;

package/src/client_kamino_manager.ts

@@ -54,6 +54,7 @@ import {
 } from './idl_codegen_kamino_vault/types/VaultConfigField';
 import { getAccountOwner } from './utils/rpc';
 import { printHoldings } from './classes/types_utils';
+import { getAssociatedTokenAddressSync } from '@solana/spl-token';
 
 dotenv.config({
   path: `.env${process.env.ENV ? '.' + process.env.ENV : ''}`,
@@ -87,7 +88,7 @@ async function main() {
         admin: mode === 'multisig' ? multisigPk : env.payer.publicKey,
       });
 
-      const _createMarketSig = await processTxn(env.client, env.payer, createMarketIxns, mode, 2500, [marketKp]);
+      await processTxn(env.client, env.payer, createMarketIxns, mode, 2500, [marketKp]);
 
       mode === 'execute' && console.log('Market created:', marketKp.publicKey.toBase58());
     });
@@ -122,8 +123,14 @@ async function main() {
       const reserveConfig = parseReserveConfigFromFile(reserveConfigFromFile);
       const assetConfig = new AssetReserveConfigCli(tokenMint, tokenMintProgramId, reserveConfig);
 
+      const adminAta =
+        mode === 'multisig'
+          ? getAssociatedTokenAddressSync(tokenMint, multisigPk)
+          : getAssociatedTokenAddressSync(tokenMint, env.payer.publicKey);
+
       const { reserve, txnIxns } = await kaminoManager.addAssetToMarketIxs({
         admin: mode === 'multisig' ? multisigPk : env.payer.publicKey,
+        adminLiquiditySource: adminAta,
         marketAddress: marketAddress,
         assetConfig: assetConfig,
       });
@@ -260,7 +267,7 @@ async function main() {
         2500,
         [vaultKp]
       );
-      await sleep(5000);
+      await sleep(2000);
       const _populateLUTSig = await processTxn(env.client, env.payer, instructions.populateLUTIxs, mode, 2500, []);
 
       mode === 'execute' && console.log('Vault created:', vaultKp.publicKey.toBase58());
@@ -426,7 +433,7 @@ async function main() {
       // if we need to create the LUT we have to do that in a separate tx and wait a little bit after
       if (syncLUTIxs.setupLUTIfNeededIxs.length > 0) {
         const setupLUTSig = await processTxn(env.client, env.payer, syncLUTIxs.setupLUTIfNeededIxs, mode, 2500, []);
-        await sleep(5000);
+        await sleep(2000);
         mode === 'execute' && console.log('LUT created and set to the vault:', setupLUTSig);
       }
       // if there are accounts to be added to the LUT we have to do that in a separate tx