@haven-fi/solauto-sdk 1.0.310 → 1.0.312

package/dist/utils/switchboardUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"switchboardUtils.d.ts","sourceRoot":"","sources":["../../src/utils/switchboardUtils.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,UAAU,EACV,SAAS,EAGV,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAkB,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAAE,MAAM,EAAsB,MAAM,0BAA0B,CAAC;AAMtE,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,SAAS,EACf,MAAM,CAAC,EAAE,SAAS,YAsBnB;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC,CAiB5C"}
+{"version":3,"file":"switchboardUtils.d.ts","sourceRoot":"","sources":["../../src/utils/switchboardUtils.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,UAAU,EACV,SAAS,EAGV,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAkB,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAAE,MAAM,EAAsB,MAAM,0BAA0B,CAAC;AAOtE,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,SAAS,EACf,MAAM,CAAC,EAAE,SAAS,YAsBnB;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC,CAsB5C;AAED,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,SAAS,EAAE,GACjB,OAAO,CAAC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,CAAC,CAuB/D;AAED,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,SAAS,EAAE,GACjB,OAAO,CAAC,MAAM,EAAE,CAAC,CAiBnB"}

package/dist/utils/switchboardUtils.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPullFeed = getPullFeed;
 exports.buildSwbSubmitResponseTx = buildSwbSubmitResponseTx;
+exports.getSwitchboardFeedData = getSwitchboardFeedData;
+exports.getSwitchboardPrices = getSwitchboardPrices;
 const anchor_1 = require("@coral-xyz/anchor");
 const switchboard_json_1 = __importDefault(require("../idls/switchboard.json"));
 const web3_js_1 = require("@solana/web3.js");
@@ -12,6 +14,7 @@ const on_demand_1 = require("@switchboard-xyz/on-demand");
 const switchboardConstants_1 = require("../constants/switchboardConstants");
 const umi_1 = require("@metaplex-foundation/umi");
 const umi_web3js_adapters_1 = require("@metaplex-foundation/umi-web3js-adapters");
+const generalUtils_1 = require("./generalUtils");
 function getPullFeed(conn, mint, wallet) {
     const dummyWallet = {
         publicKey: wallet ?? new web3_js_1.PublicKey("11111111111111111111111111111111"),
@@ -25,9 +28,9 @@ function getPullFeed(conn, mint, wallet) {
 async function buildSwbSubmitResponseTx(conn, signer, mint) {
     const crossbar = new on_demand_1.CrossbarClient("https://crossbar.switchboard.xyz");
     const feed = getPullFeed(conn, mint, (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(signer.publicKey));
-    const [pullIx, responses] = await feed.fetchUpdateIx({
+    const [pullIx, responses] = await (0, generalUtils_1.retryWithExponentialBackoff)(async () => await feed.fetchUpdateIx({
         crossbarClient: crossbar,
-    });
+    }), 8, 200);
     return {
         tx: (0, umi_1.transactionBuilder)().add({
             bytesCreatedOnChain: 0,
@@ -39,3 +42,25 @@ async function buildSwbSubmitResponseTx(conn, signer, mint) {
             .map((x) => x.oracle.lut.key.toString()),
     };
 }
+async function getSwitchboardFeedData(conn, mints) {
+    if (mints.length === 0) {
+        return [];
+    }
+    const currSlot = await (0, generalUtils_1.retryWithExponentialBackoff)(async () => await conn.getSlot("confirmed"), 5);
+    const results = await Promise.all(mints.map(async (mint) => {
+        const feed = getPullFeed(conn, mint);
+        const result = await feed.loadData();
+        const price = Number(result.result.value) / Math.pow(10, 18);
+        const stale = currSlot > result.result.slot.toNumber() + result.maxStaleness;
+        return { mint, price, stale };
+    }));
+    return results;
+}
+async function getSwitchboardPrices(mints) {
+    if (mints.length === 0) {
+        return [];
+    }
+    const crossbar = new on_demand_1.CrossbarClient("https://crossbar.switchboard.xyz");
+    const results = await (0, generalUtils_1.retryWithExponentialBackoff)(async () => await crossbar.simulateSolanaFeeds("mainnet", mints.map((x) => switchboardConstants_1.SWITCHBOARD_PRICE_FEED_IDS[x.toString()])), 8, 200);
+    return results.flatMap((x) => x.results[0]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haven-fi/solauto-sdk",
-  "version": "1.0.310",
+  "version": "1.0.312",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "Typescript SDK for the Solauto program on the Solana blockchain",
@@ -26,6 +26,7 @@
     "@solana/spl-token": "^0.4.0",
     "@solana/web3.js": "^1.95.4",
     "@switchboard-xyz/on-demand": "^1.2.51",
+    "axios": "^1.7.8",
     "bs58": "^5.0.0",
     "cross-fetch": "^4.0.0",
     "rpc-websockets": "7.11.0"

package/src/constants/solautoConstants.ts

@@ -9,7 +9,6 @@ import {
   ASSOCIATED_TOKEN_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
 } from "@solana/spl-token";
-// import { JitoRpcConnection } from "jito-ts";
 import { SOLAUTO_MANAGER } from "./generalAccounts";
 import { JUPITER_PROGRAM_ID } from "../jupiter-sdk";
 
@@ -46,8 +45,4 @@ export const STANDARD_LUT_ACCOUNTS = [
   JUPITER_PROGRAM_ID,
 ].map((x) => x.toString());
 
-// export const JITO_BLOCK_ENGINE = "ny.mainnet.block-engine.jito.wtf";
-// export const JITO_CONNECTION = new JitoRpcConnection(
-//   `https://${JITO_BLOCK_ENGINE}`,
-//   "finalized"
-// );
+export const JITO_BLOCK_ENGINE = "https://mainnet.block-engine.jito.wtf";

package/src/transactions/transactionUtils.ts

@@ -646,6 +646,9 @@ export async function buildSolautoRebalanceTransaction(
   attemptNum?: number
 ): Promise<TransactionItemInputs | undefined> {
   client.solautoPositionState = await client.getFreshPositionState();
+  const supplyPrice = safeGetPrice(client.supplyMint) ?? 0;
+  const debtPrice = safeGetPrice(client.debtMint) ?? 0;
+
   if (
     (client.solautoPositionState?.supply.amountUsed.baseUnit === BigInt(0) &&
       client.livePositionUpdates.supplyAdjustment === BigInt(0)) ||
@@ -654,7 +657,10 @@ export async function buildSolautoRebalanceTransaction(
         client.solautoPositionState!,
         client.solautoPositionSettings(),
         client.solautoPositionActiveDca(),
-        currentUnixSeconds()
+        currentUnixSeconds(),
+        supplyPrice,
+        debtPrice,
+        0
       ))
   ) {
     client.log("Not eligible for a rebalance");
@@ -666,8 +672,8 @@ export async function buildSolautoRebalanceTransaction(
     client.solautoPositionSettings(),
     client.solautoPositionActiveDca(),
     currentUnixSeconds(),
-    safeGetPrice(client.supplyMint)!,
-    safeGetPrice(client.debtMint)!,
+    supplyPrice,
+    debtPrice,
     targetLiqUtilizationRateBps
   );
   client.log("Rebalance values: ", values);

package/src/transactions/transactionsManager.ts

@@ -28,8 +28,8 @@ import {
   TransactionExpiredBlockheightExceededError,
 } from "@solana/web3.js";
 import { SWITCHBOARD_PRICE_FEED_IDS } from "../constants/switchboardConstants";
-import { buildSwbSubmitResponseTx, getSwitchboardPrices } from "../utils";
-// import { sendJitoBundledTransactions } from "../utils/jitoUtils";
+import { buildSwbSubmitResponseTx, getSwitchboardFeedData } from "../utils";
+import { sendJitoBundledTransactions } from "../utils/jitoUtils";
 
 const CHORES_TX_NAME = "account chores";
 
@@ -220,6 +220,7 @@ export class TransactionsManager {
     private statusCallback?: (statuses: TransactionManagerStatuses) => void,
     private txType?: TransactionRunType,
     private priorityFeeSetting: PriorityFeeSetting = PriorityFeeSetting.Min,
+    private atomically: boolean = false,
     private errorsToThrow?: ErrorsToThrow,
     private retries: number = 4,
     private retryDelay: number = 150
@@ -404,7 +405,7 @@ export class TransactionsManager {
           (x) => SWITCHBOARD_PRICE_FEED_IDS[x] === swbOracle
         )!
       );
-      const stale = (await getSwitchboardPrices(client.connection, [mint]))[0]
+      const stale = (await getSwitchboardFeedData(client.connection, [mint]))[0]
         .stale;
 
       if (stale) {
@@ -489,15 +490,81 @@ export class TransactionsManager {
       return [];
     }
 
-    let currentIndex = 0;
-    while (currentIndex < itemSets.length) {
-      await this.processTransactionSet(itemSets, currentIndex);
-      currentIndex++;
+    if (itemSets.length > 1 && this.atomically) {
+      await this.processTransactionsAtomically(itemSets);
+    } else {
+      let currentIndex = 0;
+      while (currentIndex < itemSets.length) {
+        await this.processTransactionSet(itemSets, currentIndex);
+        currentIndex++;
+      }
     }
 
     return this.statuses;
   }
 
+  private async processTransactionsAtomically(itemSets: TransactionSet[]) {
+    let num = 0;
+
+    await retryWithExponentialBackoff(
+      async (attemptNum) => {
+        num = attemptNum;
+
+        let transactions = [];
+        for (const set of itemSets) {
+          transactions.push(await set.getSingleTransaction());
+        }
+
+        itemSets.forEach((x) =>
+          this.updateStatus(x.name(), TransactionStatus.Processing, attemptNum)
+        );
+        const txSigs = await sendJitoBundledTransactions(
+          this.txHandler.umi,
+          this.txHandler.signer,
+          transactions,
+          false,
+          this.priorityFeeSetting
+        );
+        if (txSigs) {
+          itemSets.forEach((x, i) =>
+            this.updateStatus(
+              x.name(),
+              TransactionStatus.Successful,
+              attemptNum,
+              txSigs[i]
+            )
+          );
+        } else {
+          itemSets.forEach((x) =>
+            this.updateStatus(
+              x.name(),
+              TransactionStatus.Failed,
+              attemptNum,
+              undefined,
+              true
+            )
+          );
+          throw new Error("Unknown error");
+        }
+      },
+      this.retries,
+      this.retryDelay,
+      this.errorsToThrow
+    ).catch((e: Error) => {
+      itemSets.forEach((x) =>
+        this.updateStatus(
+          x.name(),
+          TransactionStatus.Failed,
+          num,
+          undefined,
+          true,
+          e.message
+        )
+      );
+      throw e;
+    });
+  }
+
   private async processTransactionSet(
     itemSets: TransactionSet[],
     currentIndex: number

package/src/utils/jitoUtils.ts

@@ -1,68 +1,47 @@
-// import { SolautoClient } from "../clients/solautoClient";
-// import { Keypair, PublicKey, VersionedTransaction } from "@solana/web3.js";
-// import { SimulatedBundleTransactionResult } from "jito-ts";
-// import { toWeb3JsTransaction } from "@metaplex-foundation/umi-web3js-adapters";
-// import {
-//   JITO_BLOCK_ENGINE,
-//   JITO_CONNECTION,
-//   UMI,
-// } from "../constants/solautoConstants";
-// import {
-//   Signer,
-//   TransactionBuilder,
-//   WrappedInstruction,
-// } from "@metaplex-foundation/umi";
-// import {
-//   assembleFinalTransaction,
-//   getComputeUnitPriceEstimate,
-//   getSecretKey,
-//   systemTransferUmiIx,
-// } from "./solanaUtils";
-// import { Bundle } from "jito-ts/dist/sdk/block-engine/types";
-// import {
-//   SearcherClient,
-//   searcherClient,
-// } from "jito-ts/dist/sdk/block-engine/searcher";
-// import { BundleResult } from "jito-ts/dist/gen/block-engine/bundle";
-
-// export function getSearcherClient(): SearcherClient {
-//   return searcherClient(
-//     JITO_BLOCK_ENGINE,
-//     Keypair.fromSecretKey(getSecretKey("jito-bundles"))
-//   );
-// }
-
-// export async function getRandomTipAccount(): Promise<PublicKey> {
-//   const tipAccounts = await getSearcherClient().getTipAccounts();
-//   const randomInt = Math.floor(Math.random() * tipAccounts.length);
-//   return new PublicKey(tipAccounts[randomInt]);
-// }
-
-// export async function waitUntilJitoNextLeader(
-//   distanceFromJitoSlot: number = 5
-// ) {
-//   let searcher = getSearcherClient();
-//   let isLeaderSlot = false;
-
-//   while (!isLeaderSlot) {
-//     const nextLeader = await searcher.getNextScheduledLeader();
-//     const numSlots = nextLeader.nextLeaderSlot - nextLeader.currentSlot;
-//     isLeaderSlot = numSlots <= distanceFromJitoSlot && numSlots > 1;
-//     consoleLog(`Next jito leader slot in ${numSlots} slots`);
-//     await new Promise((r) => setTimeout(r, 500));
-//   }
-// }
-
-// async function getTipInstruction(
-//   client: SolautoClient,
-//   tipLamports: number
-// ): Promise<WrappedInstruction> {
-//   return systemTransferUmiIx(
-//     client.signer,
-//     await getRandomTipAccount(),
-//     BigInt(tipLamports)
-//   );
-// }
+import { PublicKey, VersionedTransaction } from "@solana/web3.js";
+import { toWeb3JsTransaction } from "@metaplex-foundation/umi-web3js-adapters";
+import { JITO_BLOCK_ENGINE } from "../constants/solautoConstants";
+import {
+  Signer,
+  TransactionBuilder,
+  Umi,
+  WrappedInstruction,
+} from "@metaplex-foundation/umi";
+import {
+  assembleFinalTransaction,
+  getComputeUnitPriceEstimate,
+  systemTransferUmiIx,
+} from "./solanaUtils";
+import { consoleLog } from "./generalUtils";
+import { PriorityFeeSetting } from "../types";
+import axios from "axios";
+import base58 from "bs58";
+
+export async function getRandomTipAccount(): Promise<PublicKey> {
+  const tipAccounts = [
+    "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
+    "HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe",
+    "Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY",
+    "ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49",
+    "DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh",
+    "ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt",
+    "DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL",
+    "3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT",
+  ];
+  const randomInt = Math.floor(Math.random() * tipAccounts.length);
+  return new PublicKey(tipAccounts[randomInt]);
+}
+
+async function getTipInstruction(
+  signer: Signer,
+  tipLamports: number
+): Promise<WrappedInstruction> {
+  return systemTransferUmiIx(
+    signer,
+    await getRandomTipAccount(),
+    BigInt(tipLamports)
+  );
+}
 
 // async function simulateJitoBundle(
 //   txs: VersionedTransaction[]
@@ -85,104 +64,125 @@
 //   return simulationResult.value.transactionResults;
 // }
 
-// async function umiToVersionedTransactions(
-//   signer: Signer,
-//   txs: TransactionBuilder[],
-//   feeEstimates: number[],
-//   computeUnitLimits?: number[]
-// ): Promise<VersionedTransaction[]> {
-//   return await Promise.all(
-//     txs.map(async (tx, i) => {
-//       const versionedTx = toWeb3JsTransaction(
-//         await (
-//           await assembleFinalTransaction(
-//             signer,
-//             tx,
-//             feeEstimates[i],
-//             computeUnitLimits ? computeUnitLimits[i] : undefined
-//           ).setLatestBlockhash(UMI)
-//         ).buildAndSign(UMI)
-//       );
-//       return versionedTx;
-//     })
-//   );
-// }
-
-// async function sendJitoBundle(bundle: Bundle): Promise<BundleResult> {
-//   await waitUntilJitoNextLeader();
-//   let searcher = getSearcherClient();
-
-//   consoleLog("Sending bundle...");
-//   try {
-//     const resp = await searcher.sendBundle(bundle);
-//     consoleLog("Send bundle response:", resp);
-//   } catch (e) {
-//     console.error("Error sending bundle:", e);
-//   }
-
-//   return await new Promise((resolve, reject) => {
-//     searcher.onBundleResult(
-//       (res) => {
-//         if (res.accepted || res.processed || res.finalized) {
-//           resolve(res);
-//         } else {
-//           consoleLog(res);
-//           return reject("Bundle not accepted");
-//         }
-//       },
-//       (err) => {
-//         consoleLog("Error: ", err);
-//         return reject(err);
-//       }
-//     );
-//   });
-// }
-
-// interface JitoTransactionsResult {
-//   bundleResult: BundleResult;
-//   txSigs: Uint8Array[];
-// }
-
-// export async function sendJitoBundledTransactions(
-//   client: SolautoClient,
-//   txs: TransactionBuilder[],
-//   simulateOnly?: boolean
-// ): Promise<JitoTransactionsResult | undefined> {
-//   client.log("Sending Jito bundle...");
-//   client.log("Transactions: ", txs.length);
-//   client.log(
-//     "Transaction sizes: ",
-//     txs.map((x) => x.getTransactionSize(UMI))
-//   );
-
-//   txs[0] = txs[0].prepend(await getTipInstruction(client, 1000000));
-//   const feeEstimates = await Promise.all(txs.map(getComputeUnitPriceEstimate));
-
-//   let builtTxs = await umiToVersionedTransactions(
-//     client.signer,
-//     txs,
-//     feeEstimates,
-//     // Array(txs.length).fill(1_400_000)
-//   );
-//   // // TODO: Skip over this for now, and instead don't specify a compute unit limit in the final bundle transactions
-//   // const simulationResults = await simulateJitoBundle(builtTxs);
-
-//   if (!simulateOnly) {
-//     // let builtTxs = await umiToVersionedTransactions(
-//     //   client.signer,
-//     //   txs,
-//     //   feeEstimates,
-//     //   simulationResults.map((x) => x.unitsConsumed! * 1.15)
-//     // );
-
-//     const bundleResult = await sendJitoBundle(
-//       new Bundle(builtTxs, 100)
-//     );
-//     return {
-//       bundleResult,
-//       txSigs: builtTxs.map((x) => x.signatures).flat(),
-//     };
-//   }
-
-//   return undefined;
-// }
+async function umiToVersionedTransactions(
+  umi: Umi,
+  signer: Signer,
+  txs: TransactionBuilder[],
+  feeEstimates: number[],
+  computeUnitLimits?: number[]
+): Promise<VersionedTransaction[]> {
+  return await Promise.all(
+    txs.map(async (tx, i) => {
+      const versionedTx = toWeb3JsTransaction(
+        await (
+          await assembleFinalTransaction(
+            signer,
+            tx,
+            feeEstimates[i],
+            computeUnitLimits ? computeUnitLimits[i] : undefined
+          ).setLatestBlockhash(umi)
+        ).buildAndSign(umi)
+      );
+      return versionedTx;
+    })
+  );
+}
+
+async function getBundleStatus(bundleId: string) {
+  const res = await axios.post(`${JITO_BLOCK_ENGINE}/api/v1/bundles`, {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "getBundleStatuses",
+    params: [[bundleId]],
+  });
+  if (res.data.error) {
+    throw new Error(`Failed to get bundle status: ${res.data.error}`);
+  }
+
+  return res.data.result;
+}
+
+async function pollBundleStatus(
+  bundleId: string,
+  interval = 1000,
+  timeout = 40000
+): Promise<string[]> {
+  const endTime = Date.now() + timeout;
+  while (Date.now() < endTime) {
+    await new Promise((resolve) => setTimeout(resolve, interval));
+    const statuses = await getBundleStatus(bundleId);
+    if (statuses?.value?.length > 0) {
+      const status = statuses.value[0].confirmation_status;
+      if (status === "confirmed") {
+        return statuses?.value[0].transactions as string[];
+      }
+    }
+  }
+  return [];
+}
+
+async function sendJitoBundle(transactions: string[]): Promise<string[]> {
+  consoleLog("Sending bundle...");
+  const resp = await axios.post<{ result: string }>(
+    `${JITO_BLOCK_ENGINE}/api/v1/bundles`,
+    {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendBundle",
+      params: [transactions],
+    }
+  );
+
+  const bundleId = resp.data.result;
+  return await pollBundleStatus(bundleId);
+}
+
+export async function sendJitoBundledTransactions(
+  umi: Umi,
+  signer: Signer,
+  txs: TransactionBuilder[],
+  simulateOnly?: boolean,
+  priorityFeeSetting: PriorityFeeSetting = PriorityFeeSetting.Min
+): Promise<string[] | undefined> {
+  consoleLog("Sending Jito bundle...");
+  consoleLog("Transactions: ", txs.length);
+  consoleLog(
+    "Transaction sizes: ",
+    txs.map((x) => x.getTransactionSize(umi))
+  );
+
+  txs[0] = txs[0].prepend(await getTipInstruction(signer, 150_000));
+  const feeEstimates = await Promise.all(
+    txs.map(
+      async (x) =>
+        (await getComputeUnitPriceEstimate(umi, x, priorityFeeSetting)) ??
+        1000000
+    )
+  );
+
+  let builtTxs = await umiToVersionedTransactions(
+    umi,
+    signer,
+    txs,
+    feeEstimates
+    // Array(txs.length).fill(1_400_000)
+  );
+  // // TODO: Skip over this for now, and instead don't specify a compute unit limit in the final bundle transactions
+  // const simulationResults = await simulateJitoBundle(builtTxs);
+
+  if (!simulateOnly) {
+    // let builtTxs = await umiToVersionedTransactions(
+    //   client.signer,
+    //   txs,
+    //   feeEstimates,
+    //   simulationResults.map((x) => x.unitsConsumed! * 1.15)
+    // );
+
+    const txSigs = await sendJitoBundle(
+      builtTxs.map((x) => base58.encode(x.serialize()))
+    );
+    return txSigs.length > 0 ? txSigs : undefined;
+  }
+
+  return undefined;
+}

package/src/utils/jupiterUtils.ts

@@ -94,12 +94,6 @@ export async function getJupSwapTransaction(
       )
     ).toString();
   }
-  // else {
-  //   quoteResponse.inAmount = (
-  //     parseInt(quoteResponse.inAmount) +
-  //     Math.ceil(parseInt(quoteResponse.inAmount) * fromBps(priceImpactBps))
-  //   ).toString();
-  // }
 
   consoleLog("Getting jup instructions...");
   const instructions = await retryWithExponentialBackoff(