@kamino-finance/kliquidity-sdk 7.0.14 → 8.0.1

package/src/utils/lookupTable.ts

@@ -1,52 +1,79 @@
-import {
-  AddressLookupTableAccount,
-  Connection,
-  MessageV0,
-  PublicKey,
-  TransactionInstruction,
-  TransactionMessage,
-} from '@solana/web3.js';
-import { ADDRESS_LUT_PROGRAM_ID, LUT_OWNER_KEY } from '../constants/pubkeys';
+import { Address, Rpc, GetProgramAccountsApi, Account, GetMultipleAccountsApi } from '@solana/kit';
+import { LUT_OWNER_KEY } from '../constants/pubkeys';
 import { SolanaCluster } from '@hubbleprotocol/hubble-config';
+import {
+  ADDRESS_LOOKUP_TABLE_PROGRAM_ADDRESS,
+  AddressLookupTable,
+  getAddressLookupTableDecoder,
+} from '@solana-program/address-lookup-table';
+
+const lutDecoder = getAddressLookupTableDecoder();
 
 export async function getLookupTable(
   cluster: SolanaCluster,
-  connection: Connection
-): Promise<AddressLookupTableAccount[]> {
+  rpc: Rpc<GetProgramAccountsApi>
+): Promise<Account<AddressLookupTable>[]> {
   if (cluster == 'mainnet-beta' || cluster == 'devnet') {
-    return await connection
-      .getProgramAccounts(ADDRESS_LUT_PROGRAM_ID, {
-        filters: [{ memcmp: { offset: 22, bytes: new PublicKey(LUT_OWNER_KEY).toString() } }],
-      })
-      .then((res) =>
-        res.map((raw) => {
-          return new AddressLookupTableAccount({
-            key: raw.pubkey,
-            state: AddressLookupTableAccount.deserialize(raw.account.data),
-          });
-        })
-      );
-  } else {
-    throw Error('There is no lookup table for localnet yet');
+    return getAllUserLookupTables(rpc, LUT_OWNER_KEY);
   }
+  return [];
 }
 
-export async function getTransactionV2Message(
-  cluster: SolanaCluster,
-  connection: Connection,
-  payer: PublicKey,
-  blockhash: string,
-  instructions: Array<TransactionInstruction>
-): Promise<MessageV0> {
-  if (cluster == 'mainnet-beta' || cluster == 'devnet') {
-    const lookupTable = await getLookupTable(cluster, connection);
-    const v2Tx = new TransactionMessage({
-      payerKey: payer,
-      recentBlockhash: blockhash,
-      instructions: instructions,
-    }).compileToV0Message(lookupTable);
-    return v2Tx;
-  } else {
-    throw Error('No TransactionV2 on localnet as no lookup table was created');
+export async function getAllUserLookupTables(
+  c: Rpc<GetProgramAccountsApi>,
+  user: Address
+): Promise<Account<AddressLookupTable>[]> {
+  const accountInfos = await c
+    .getProgramAccounts(ADDRESS_LOOKUP_TABLE_PROGRAM_ADDRESS, {
+      filters: [
+        {
+          memcmp: {
+            offset: 22n,
+            bytes: user,
+            encoding: 'base58',
+          },
+        },
+      ],
+      encoding: 'base64',
+    })
+    .send();
+
+  return accountInfos.map((info) => {
+    const data = lutDecoder.decode(Buffer.from(info.account.data[0], 'base64'));
+    const acc: Account<AddressLookupTable> = {
+      executable: info.account.executable,
+      programAddress: info.account.owner,
+      lamports: info.account.lamports,
+      address: info.pubkey,
+      data: data,
+      space: info.account.space,
+    };
+    return acc;
+  });
+}
+
+export async function fetchMultipleLookupTableAccounts(
+  rpc: Rpc<GetMultipleAccountsApi>,
+  addresses: Address[]
+): Promise<Account<AddressLookupTable>[]> {
+  const accountInfos = await rpc.getMultipleAccounts(addresses).send();
+  const luts: Account<AddressLookupTable>[] = [];
+  for (let i = 0; i < accountInfos.value.length; i++) {
+    const info = accountInfos.value[i];
+    if (info === null) {
+      throw new Error(`Could not get lookup table ${addresses[i]}`);
+    }
+    const address = addresses[i];
+    const data = lutDecoder.decode(Buffer.from(info.data[0], 'base64'));
+    const acc: Account<AddressLookupTable> = {
+      executable: info.executable,
+      programAddress: info.owner,
+      lamports: info.lamports,
+      address,
+      data: data,
+      space: info.space,
+    };
+    luts.push(acc);
   }
+  return luts;
 }

package/src/utils/meteora.ts

@@ -1,13 +1,16 @@
-import { PublicKey } from '@solana/web3.js';
+import { Address, getAddressEncoder, getProgramDerivedAddress } from '@solana/kit';
 import Decimal from 'decimal.js';
 import { U64_MAX } from '../constants/numericalValues';
-import { BinArray } from '../meteora_client/accounts';
-import { Bin } from '../meteora_client/types';
+import { BinArray } from '../@codegen/meteora/accounts';
+import { Bin } from '../@codegen/meteora/types';
 import { BN } from '@coral-xyz/anchor';
+import { ProgramDerivedAddress } from '@solana/addresses/dist/types/program-derived-address';
 
 const BASIS_POINT_MAX = 10000;
 const MAX_BIN_ARRAY_SIZE = 70;
 
+const addressEncoder = getAddressEncoder();
+
 export function getPriceOfBinByBinId(binId: number, tickSpacing: number): Decimal {
   const binStepNum = new Decimal(tickSpacing).div(new Decimal(BASIS_POINT_MAX));
   return new Decimal(1).add(new Decimal(binStepNum)).pow(new Decimal(binId));
@@ -77,18 +80,22 @@ export function binIdToBinArrayIndex(binId: BN): BN {
   return binId.isNeg() && !mod.isZero() ? idx.sub(new BN(1)) : idx;
 }
 
-export function deriveBinArray(lbPair: PublicKey, index: BN, programId: PublicKey) {
+export async function deriveBinArray(lbPair: Address, index: BN, programId: Address): Promise<ProgramDerivedAddress> {
   let binArrayBytes: Uint8Array;
   if (index.isNeg()) {
     binArrayBytes = new Uint8Array(index.toTwos(64).toBuffer('le', 8));
   } else {
     binArrayBytes = new Uint8Array(index.toBuffer('le', 8));
   }
-  return PublicKey.findProgramAddressSync([Buffer.from('bin_array'), lbPair.toBytes(), binArrayBytes], programId);
+  const pda = await getProgramDerivedAddress({
+    seeds: [Buffer.from('bin_array'), addressEncoder.encode(lbPair), binArrayBytes],
+    programAddress: programId,
+  });
+  return pda;
 }
 
 export type MeteoraPosition = {
-  publicKey: PublicKey;
+  Address: Address;
   amountX: Decimal;
   amountY: Decimal;
 };

package/src/utils/orca.ts

@@ -1,12 +1,15 @@
-import { PublicKey } from '@solana/web3.js';
+import { Address, getAddressEncoder, getProgramDerivedAddress } from '@solana/kit';
+import { ProgramDerivedAddress } from '@solana/addresses/dist/types/program-derived-address';
 
-export function getTickArray(
-  programId: PublicKey,
-  whirlpoolAddress: PublicKey,
+const addressEncoder = getAddressEncoder();
+
+export async function getTickArray(
+  programId: Address,
+  whirlpoolAddress: Address,
   startTick: number
-): [PublicKey, number] {
-  return PublicKey.findProgramAddressSync(
-    [Buffer.from('tick_array'), whirlpoolAddress.toBuffer(), Buffer.from(startTick.toString())],
-    programId
-  );
+): Promise<ProgramDerivedAddress> {
+  return await getProgramDerivedAddress({
+    seeds: [Buffer.from('tick_array'), addressEncoder.encode(whirlpoolAddress), Buffer.from(startTick.toString())],
+    programAddress: programId,
+  });
 }

package/src/utils/tokenUtils.ts

@@ -1,121 +1,78 @@
-import {
-  AccountInfo,
-  Commitment,
-  ComputeBudgetProgram,
-  Connection,
-  PublicKey,
-  sendAndConfirmTransaction,
-  Signer,
-  SystemProgram,
-  Transaction,
-  TransactionInstruction,
-  TransactionSignature,
-} from '@solana/web3.js';
-import { sleep } from './utils';
-import { WhirlpoolStrategy } from '../kamino-client/accounts';
+import { Address, IInstruction, address, TransactionSigner, Rpc, GetAccountInfoApi, Account } from '@solana/kit';
+import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
 import { tickIndexToPrice } from '@orca-so/whirlpool-sdk';
 import Decimal from 'decimal.js';
-import { CollateralInfo } from '../kamino-client/types';
+import { CollateralInfo } from '../@codegen/kliquidity/types';
 import { getPriceOfBinByBinIdWithDecimals } from './meteora';
-import { getAssociatedTokenAddress as getAta, unpackMint } from '@solana/spl-token';
-
-export const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
-export const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  fetchMaybeMint,
+  fetchMaybeToken,
+  findAssociatedTokenPda,
+  getCreateAssociatedTokenInstruction,
+  Token,
+} from '@solana-program/token-2022';
+import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
+import { getSetComputeUnitLimitInstruction } from '@solana-program/compute-budget';
 
 export const SOL_MINTS = [
-  new PublicKey('So11111111111111111111111111111111111111111'),
-  new PublicKey('So11111111111111111111111111111111111111112'),
+  address('So11111111111111111111111111111111111111111'),
+  address('So11111111111111111111111111111111111111112'),
 ];
 export const DECIMALS_SOL = 9;
 
-export async function getAssociatedTokenAddressAndData(
-  connection: Connection,
-  mint: PublicKey,
-  owner: PublicKey,
-  programId = TOKEN_PROGRAM_ID
-): Promise<[PublicKey, AccountInfo<Buffer> | null]> {
-  const ata = await getAssociatedTokenAddress(mint, owner, true, programId);
-  const data = await connection.getAccountInfo(ata);
-  return [ata, data];
+export async function getAssociatedTokenAddressAndAccount(
+  connection: Rpc<GetAccountInfoApi>,
+  mint: Address,
+  owner: Address,
+  programId: Address = TOKEN_PROGRAM_ADDRESS
+): Promise<[Address, Account<Token> | null]> {
+  const ata = await getAssociatedTokenAddress(mint, owner, programId);
+  const account = await fetchMaybeToken(connection, ata);
+  return [ata, account.exists ? account : null];
 }
 
-export function getAssociatedTokenAddress(
-  mint: PublicKey,
-  owner: PublicKey,
-  allowOwnerOffCurve = true,
-  programId = TOKEN_PROGRAM_ID,
-  associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): Promise<PublicKey> {
-  return getAta(mint, owner, allowOwnerOffCurve, programId, associatedTokenProgramId);
+export async function getAssociatedTokenAddress(
+  mint: Address,
+  owner: Address,
+  programId: Address = TOKEN_PROGRAM_ADDRESS,
+  associatedTokenProgramId: Address = ASSOCIATED_TOKEN_PROGRAM_ADDRESS
+): Promise<Address> {
+  const [ata] = await findAssociatedTokenPda(
+    {
+      mint,
+      owner,
+      tokenProgram: programId,
+    },
+    { programAddress: associatedTokenProgramId }
+  );
+  return ata;
 }
 
 export function createAssociatedTokenAccountInstruction(
-  payer: PublicKey,
-  associatedToken: PublicKey,
-  owner: PublicKey,
-  mint: PublicKey,
-  programId = TOKEN_PROGRAM_ID,
-  associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): TransactionInstruction {
-  const keys = [
-    { pubkey: payer, isSigner: true, isWritable: true },
-    { pubkey: associatedToken, isSigner: false, isWritable: true },
-    { pubkey: owner, isSigner: false, isWritable: false },
-    { pubkey: mint, isSigner: false, isWritable: false },
-    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-    { pubkey: programId, isSigner: false, isWritable: false },
-  ];
-
-  return new TransactionInstruction({
-    keys,
-    programId: associatedTokenProgramId,
-    data: Buffer.alloc(0),
-  });
-}
-
-export function createAddExtraComputeUnitsIx(units: number): TransactionInstruction {
-  return ComputeBudgetProgram.setComputeUnitLimit({ units });
-}
-
-export function createTransactionWithExtraBudget(extraUnits: number = 400000) {
-  return new Transaction().add(createAddExtraComputeUnitsIx(extraUnits));
-}
-
-export async function assignBlockInfoToTransaction(connection: Connection, transaction: Transaction, payer: PublicKey) {
-  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
-  transaction.recentBlockhash = blockhash;
-  transaction.feePayer = payer;
-  transaction.lastValidBlockHeight = lastValidBlockHeight;
-  return transaction;
+  payer: TransactionSigner,
+  associatedToken: Address,
+  owner: Address,
+  mint: Address,
+  programId: Address = TOKEN_PROGRAM_ADDRESS,
+  associatedTokenProgramId: Address = ASSOCIATED_TOKEN_PROGRAM_ADDRESS
+): IInstruction {
+  return getCreateAssociatedTokenInstruction(
+    {
+      mint,
+      owner,
+      ata: associatedToken,
+      payer: payer,
+      tokenProgram: programId,
+      systemProgram: SYSTEM_PROGRAM_ADDRESS,
+    },
+    { programAddress: associatedTokenProgramId }
+  );
 }
 
-export async function sendTransactionWithLogs(
-  connection: Connection,
-  tx: Transaction,
-  payer: PublicKey,
-  signers: Signer[],
-  commitment: Commitment = 'processed',
-  skipPreflight: boolean = false
-): Promise<TransactionSignature | null> {
-  const txn = await assignBlockInfoToTransaction(connection, tx, payer);
-  try {
-    const res = await sendAndConfirmTransaction(connection, txn, signers, {
-      commitment: commitment,
-      skipPreflight: skipPreflight,
-    });
-
-    return res;
-  } catch (e) {
-    console.log('ERROR:', e);
-    await sleep(5000);
-    // @ts-ignore
-    const sig = e.toString().split(' failed ')[0].split('Transaction ')[1];
-    const res = await connection.getTransaction(sig, { commitment: 'confirmed' });
-    if (res && res.meta) {
-      console.log('Txn', res.meta.logMessages);
-    }
-    return null;
-  }
+export function createComputeUnitLimitIx(units: number = 400000): IInstruction {
+  return getSetComputeUnitLimitInstruction({ units });
 }
 
 export function getStrategyPriceRangeOrca(
@@ -195,36 +152,17 @@ export function getTokenNameFromCollateralInfo(collateralInfo: CollateralInfo) {
   return String.fromCharCode(...collateralInfo.name.filter((x) => x > 0));
 }
 
-export const isSOLMint = (mint: PublicKey): boolean => {
-  return SOL_MINTS.filter((m) => m.equals(mint)).length > 0;
+export const isSOLMint = (mint: Address): boolean => {
+  return SOL_MINTS.filter((m) => m === mint).length > 0;
 };
 
-export async function getMintDecimals(connection: Connection, mint: PublicKey): Promise<number> {
+export async function getMintDecimals(rpc: Rpc<GetAccountInfoApi>, mint: Address): Promise<number> {
   if (isSOLMint(mint)) {
     return DECIMALS_SOL;
   }
-  const acc = await connection.getAccountInfo(mint);
-  if (!acc) {
-    throw new Error(`Mint ${mint.toBase58()} not found`);
+  const acc = await fetchMaybeMint(rpc, mint);
+  if (!acc.exists) {
+    throw new Error(`Mint ${mint} not found`);
   }
-  const mintInfo = unpackMint(mint, acc, acc.owner);
-  return mintInfo.decimals;
-}
-
-export function removeBudgetAndAtaIxns(ixns: TransactionInstruction[], mints: PublicKey[]): TransactionInstruction[] {
-  return ixns.filter((ixn) => {
-    const { programId, keys } = ixn;
-
-    if (programId.equals(ComputeBudgetProgram.programId)) {
-      return false;
-    }
-
-    if (programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-      const mint = keys[3];
-
-      return !mints.includes(mint.pubkey);
-    }
-
-    return true;
-  });
+  return acc.data.decimals;
 }

package/src/utils/transactions.ts

@@ -1,66 +1,64 @@
 import {
-  AccountInfo,
-  ComputeBudgetProgram,
-  Connection,
-  PublicKey,
-  SystemProgram,
-  Transaction,
-  TransactionInstruction,
-} from '@solana/web3.js';
+  Address,
+  GetAccountInfoApi,
+  GetTokenAccountBalanceApi,
+  IInstruction,
+  Rpc,
+  TransactionSigner,
+} from '@solana/kit';
 import Decimal from 'decimal.js';
-import {
-  ASSOCIATED_TOKEN_PROGRAM_ID,
-  DECIMALS_SOL,
-  createAssociatedTokenAccountInstruction,
-  getAssociatedTokenAddress,
-} from './tokenUtils';
-import { createCloseAccountInstruction, NATIVE_MINT, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { DECIMALS_SOL, createAssociatedTokenAccountInstruction, getAssociatedTokenAddress } from './tokenUtils';
 import { collToLamportsDecimal } from './utils';
 import { CreateAta } from './types';
+import { DEFAULT_PUBLIC_KEY, WRAPPED_SOL_MINT } from '../constants/pubkeys';
+import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+import {
+  COMPUTE_BUDGET_PROGRAM_ADDRESS,
+  getSetComputeUnitLimitInstruction,
+  getSetComputeUnitPriceInstruction,
+} from '@solana-program/compute-budget';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  fetchMaybeToken,
+  getCloseAccountInstruction,
+  getSyncNativeInstruction,
+} from '@solana-program/token-2022';
+import { getTransferSolInstruction } from '@solana-program/system';
 
 export const MAX_ACCOUNTS_PER_TRANSACTION = 64;
 
-export const decodeSerializedTransaction = (tx: string | undefined) => {
-  if (!tx) {
-    return undefined;
-  }
-  return Transaction.from(Buffer.from(tx, 'base64'));
-};
+export const getComputeBudgetAndPriorityFeeIxns = (units: number, priorityFeeLamports?: Decimal): IInstruction[] => {
+  const ixns: IInstruction[] = [];
 
-export const getComputeBudgetAndPriorityFeeIxns = (
-  units: number,
-  priorityFeeLamports?: Decimal
-): TransactionInstruction[] => {
-  const ixns: TransactionInstruction[] = [];
-  ixns.push(ComputeBudgetProgram.setComputeUnitLimit({ units }));
+  ixns.push(getSetComputeUnitLimitInstruction({ units }));
 
   if (priorityFeeLamports && priorityFeeLamports.gt(0)) {
     const unitPrice = priorityFeeLamports.mul(10 ** 6).div(units);
-    ixns.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: BigInt(unitPrice.floor().toString()) }));
+    ixns.push(getSetComputeUnitPriceInstruction({ microLamports: BigInt(unitPrice.floor().toString()) }));
   }
 
   return ixns;
 };
 
 export const createAtaIfMissingIx = async (
-  connection: Connection,
-  mint: PublicKey,
-  owner: PublicKey,
-  programId: PublicKey
-): Promise<TransactionInstruction | undefined> => {
-  const ata = await getAssociatedTokenAddress(mint, owner, true, programId);
+  connection: Rpc<GetAccountInfoApi>,
+  mint: Address,
+  owner: TransactionSigner,
+  programId: Address
+): Promise<IInstruction | undefined> => {
+  const ata = await getAssociatedTokenAddress(mint, owner.address, programId);
   const doesAtaExist = Boolean(await checkIfAccountExists(connection, ata));
   const createIxn = !doesAtaExist
-    ? createAssociatedTokenAccountInstruction(owner, ata, owner, mint, programId)
+    ? createAssociatedTokenAccountInstruction(owner, ata, owner.address, mint, programId)
     : undefined;
   return createIxn;
 };
 
 export const getAtasWithCreateIxnsIfMissing = async (
-  connection: Connection,
-  mints: [PublicKey, PublicKey][],
-  owner: PublicKey
-): Promise<TransactionInstruction[]> => {
+  connection: Rpc<any>,
+  mints: [Address, Address][],
+  owner: TransactionSigner
+): Promise<IInstruction[]> => {
   const requests = mints.map(async ([mint, tokenProgram]) => {
     const createAtaIx = await createAtaIfMissingIx(connection, mint, owner, tokenProgram);
     if (createAtaIx) {
@@ -70,34 +68,36 @@ export const getAtasWithCreateIxnsIfMissing = async (
   });
   const result = (await Promise.all(requests.filter((x) => x !== undefined))).filter(
     (ix) => ix !== undefined
-  ) as TransactionInstruction[];
+  ) as IInstruction[];
 
   return result;
 };
 
 export const createWsolAtaIfMissing = async (
-  connection: Connection,
+  rpc: Rpc<GetAccountInfoApi & GetTokenAccountBalanceApi>,
   amount: Decimal,
-  owner: PublicKey,
+  owner: TransactionSigner,
   method: 'deposit' | 'withdraw' = 'deposit'
 ): Promise<CreateAta> => {
-  const createIxns: TransactionInstruction[] = [];
-  const closeIxns: TransactionInstruction[] = [];
+  const createIxns: IInstruction[] = [];
+  const closeIxns: IInstruction[] = [];
 
-  const wsolAta: PublicKey = await getAssociatedTokenAddress(NATIVE_MINT, owner, true, TOKEN_PROGRAM_ID);
+  const wsolAta: Address = await getAssociatedTokenAddress(WRAPPED_SOL_MINT, owner.address);
 
   const solDeposit = amount.toNumber();
-  const wsolAtaAccountInfo: AccountInfo<Buffer> | null = await connection.getAccountInfo(wsolAta);
+  const wsolAtaTokenAccount = await fetchMaybeToken(rpc, wsolAta);
 
   // This checks if we need to create it
-  if (isWsolInfoInvalid(wsolAtaAccountInfo)) {
-    createIxns.push(createAssociatedTokenAccountInstruction(owner, wsolAta, owner, NATIVE_MINT, TOKEN_PROGRAM_ID));
+  if (!wsolAtaTokenAccount.exists) {
+    createIxns.push(
+      createAssociatedTokenAccountInstruction(owner, wsolAta, owner.address, WRAPPED_SOL_MINT, TOKEN_PROGRAM_ADDRESS)
+    );
   }
 
   let uiAmount = 0;
   try {
-    if (wsolAtaAccountInfo != null) {
-      const tokenBalance = await findAtaBalance(connection, wsolAta);
+    if (wsolAtaTokenAccount.exists) {
+      const tokenBalance = await findAtaBalance(rpc, wsolAta);
       uiAmount = tokenBalance === null ? 0 : tokenBalance;
     }
   } catch (err) {
@@ -106,36 +106,35 @@ export const createWsolAtaIfMissing = async (
 
   if (solDeposit !== null && solDeposit > uiAmount && method === 'deposit') {
     createIxns.push(
-      SystemProgram.transfer({
-        fromPubkey: owner,
-        toPubkey: wsolAta,
-        lamports: BigInt(
+      getTransferSolInstruction({
+        amount: BigInt(
           collToLamportsDecimal(new Decimal(solDeposit - uiAmount), DECIMALS_SOL)
             .floor()
             .toString()
         ),
+        source: owner,
+        destination: wsolAta,
       })
     );
   }
 
   if (createIxns.length > 0) {
     createIxns.push(
-      // Sync Native instruction. @solana/spl-token will release it soon. Here use the raw instruction temporally.
-      new TransactionInstruction({
-        keys: [
-          {
-            pubkey: wsolAta,
-            isSigner: false,
-            isWritable: true,
-          },
-        ],
-        data: Buffer.from(new Uint8Array([17])),
-        programId: TOKEN_PROGRAM_ID,
-      })
+      getSyncNativeInstruction(
+        {
+          account: wsolAta,
+        },
+        { programAddress: TOKEN_PROGRAM_ADDRESS }
+      )
     );
   }
 
-  closeIxns.push(createCloseAccountInstruction(wsolAta, owner, owner, [], TOKEN_PROGRAM_ID));
+  closeIxns.push(
+    getCloseAccountInstruction(
+      { account: wsolAta, owner: owner, destination: owner.address, multiSigners: [] },
+      { programAddress: TOKEN_PROGRAM_ADDRESS }
+    )
+  );
 
   return {
     ata: wsolAta,
@@ -149,35 +148,40 @@ export const isWsolInfoInvalid = (wsolAtaAccountInfo: any): boolean => {
     wsolAtaAccountInfo === null ||
     (wsolAtaAccountInfo !== null &&
       wsolAtaAccountInfo.data.length === 0 &&
-      wsolAtaAccountInfo.owner.toString() === '11111111111111111111111111111111');
+      wsolAtaAccountInfo.owner === DEFAULT_PUBLIC_KEY);
 
   return res;
 };
 
-export async function checkIfAccountExists(connection: Connection, account: PublicKey): Promise<boolean> {
-  return (await connection.getAccountInfo(account)) != null;
+export async function checkIfAccountExists(connection: Rpc<GetAccountInfoApi>, account: Address): Promise<boolean> {
+  return (await connection.getAccountInfo(account, { encoding: 'base64' }).send()).value != null;
 }
 
-export function removeBudgetAndAtaIxns(ixns: TransactionInstruction[], mints: PublicKey[]): TransactionInstruction[] {
+export function removeBudgetAndAtaIxns(ixns: IInstruction[], mints: Address[]): IInstruction[] {
   return ixns.filter((ixn) => {
-    const { programId, keys } = ixn;
+    const { programAddress, accounts } = ixn;
 
-    if (programId.equals(ComputeBudgetProgram.programId)) {
+    if (programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS) {
       return false;
     }
 
-    if (programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-      const mint = keys[3];
-
-      return !mints.includes(mint.pubkey);
+    if (programAddress === ASSOCIATED_TOKEN_PROGRAM_ADDRESS) {
+      if (!accounts || accounts.length < 2) {
+        return true;
+      }
+      const mint = accounts[3];
+      return !mints.includes(mint.address);
     }
 
     return true;
   });
 }
 
-export const findAtaBalance = async (connection: Connection, ata: PublicKey): Promise<number | null> => {
-  const res = await connection.getTokenAccountBalance(ata);
+export const findAtaBalance = async (
+  connection: Rpc<GetTokenAccountBalanceApi>,
+  ata: Address
+): Promise<number | null> => {
+  const res = await connection.getTokenAccountBalance(ata).send();
   if (res && res.value) {
     return res.value.uiAmount;
   }