@haven-fi/solauto-sdk 1.0.309 → 1.0.311

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/priceUtils.ts

@@ -1,4 +1,4 @@
-import { Connection, PublicKey } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
 import { PublicKey as UmiPublicKey } from "@metaplex-foundation/umi";
 import { PYTH_PRICE_FEED_IDS } from "../constants/pythConstants";
 import { fromBaseUnit, toBaseUnit } from "./numberUtils";
@@ -9,7 +9,7 @@ import {
   retryWithExponentialBackoff,
   zip,
 } from "./generalUtils";
-import { getPullFeed } from "./switchboardUtils";
+import { getSwitchboardPrices } from "./switchboardUtils";
 
 export async function fetchTokenPrices(
   mints: PublicKey[]
@@ -32,7 +32,7 @@ export async function fetchTokenPrices(
 
   const [pythData, switchboardData] = await Promise.all([
     zip(pythMints, await getPythPrices(pythMints)),
-    zip(switchboardMints, await getJupTokenPrices(switchboardMints)),
+    zip(switchboardMints, await getSwitchboardPrices(switchboardMints)),
   ]);
 
   const prices = mints.map((mint) => {
@@ -94,34 +94,6 @@ export async function getPythPrices(mints: PublicKey[]) {
   return prices;
 }
 
-export async function getSwitchboardPrices(
-  conn: Connection,
-  mints: PublicKey[]
-): Promise<{ mint: PublicKey; price: number; stale: boolean }[]> {
-  if (mints.length === 0) {
-    return [];
-  }
-
-  const currSlot = await 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;
-}
-
 export function safeGetPrice(
   mint: PublicKey | UmiPublicKey | undefined
 ): number | undefined {
@@ -140,12 +112,14 @@ export async function getJupTokenPrices(mints: PublicKey[]) {
     const res = (
       await fetch(
         "https://api.jup.ag/price/v2?ids=" +
-          mints.map((x) => x.toString()).join(",")
+          mints.map((x) => x.toString()).join(",") + "&showExtraInfo=true"
       )
     ).json();
     return res;
   }, 6);
 
+  console.log(data.data[mints[0].toString()].extraInfo.quotedPrice);
+
   const prices = Object.values(data.data as { [key: string]: any }).map(
     (x) => parseFloat(x.price as string) as number
   );

package/src/utils/solanaUtils.ts

@@ -317,7 +317,7 @@ async function spamSendTransactionUntilConfirmed(
   connection: Connection,
   transaction: Transaction | VersionedTransaction,
   blockhash: BlockhashWithExpiryBlockHeight,
-  spamInterval: number = 3000
+  spamInterval: number = 1500
 ): Promise<string> {
   let transactionSignature: string | null = null;
 

package/src/utils/switchboardUtils.ts

@@ -14,6 +14,7 @@ import {
   fromWeb3JsInstruction,
   toWeb3JsPublicKey,
 } from "@metaplex-foundation/umi-web3js-adapters";
+import { retryWithExponentialBackoff } from "./generalUtils";
 
 export function getPullFeed(
   conn: Connection,
@@ -49,9 +50,14 @@ export async function buildSwbSubmitResponseTx(
 ): Promise<TransactionItemInputs | undefined> {
   const crossbar = new CrossbarClient("https://crossbar.switchboard.xyz");
   const feed = getPullFeed(conn, mint, toWeb3JsPublicKey(signer.publicKey));
-  const [pullIx, responses] = await feed.fetchUpdateIx({
-    crossbarClient: crossbar,
-  });
+  const [pullIx, responses] = await retryWithExponentialBackoff(
+    async () =>
+      await feed.fetchUpdateIx({
+        crossbarClient: crossbar,
+      }),
+    8,
+    200
+  );
 
   return {
     tx: transactionBuilder().add({
@@ -64,3 +70,52 @@ export async function buildSwbSubmitResponseTx(
       .map((x) => x.oracle.lut!.key.toString()),
   };
 }
+
+export async function getSwitchboardFeedData(
+  conn: Connection,
+  mints: PublicKey[]
+): Promise<{ mint: PublicKey; price: number; stale: boolean }[]> {
+  if (mints.length === 0) {
+    return [];
+  }
+
+  const currSlot = await 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;
+}
+
+export async function getSwitchboardPrices(
+  mints: PublicKey[]
+): Promise<number[]> {
+  if (mints.length === 0) {
+    return [];
+  }
+
+  const crossbar = new CrossbarClient("https://crossbar.switchboard.xyz");
+  const results = await retryWithExponentialBackoff(
+    async () =>
+      await crossbar.simulateSolanaFeeds(
+        "mainnet",
+        mints.map((x) => SWITCHBOARD_PRICE_FEED_IDS[x.toString()])
+      ),
+    8,
+    200
+  );
+
+  return results.flatMap((x) => x.results[0]);
+}