Combine prepareCompute and Retries

- Added a new helper to make sending transactions only one line: sendTransactionWithRetryAndPriorityFees

Author: Woody4618

src/lib/transaction.ts

@@ -207,6 +207,18 @@ export async function sendTransactionWithRetry(
     transaction.sign(...signers);
   }
 
+  if (transaction.recentBlockhash === undefined) {
+    console.log("No blockhash provided. Setting recent blockhash");
+    const { blockhash } = await connection.getLatestBlockhash(commitment);
+    transaction.recentBlockhash = blockhash;
+  }
+  if (transaction.feePayer === undefined) {
+    if (signers.length === 0) {
+      throw new Error("No signers or fee payer provided");
+    }
+    transaction.feePayer = signers[0].publicKey;
+  }
+
   onStatusUpdate?.({ status: "signed" });
 
   let signature: string | null = null;
@@ -624,3 +636,72 @@ function formatData(data: any): any {
   }
   return data;
 }
+
+/**
+ * Sends a transaction with compute unit optimization and automatic retries
+ *
+ * @param connection - The Solana connection object
+ * @param transaction - The transaction to send
+ * @param signers - Array of signers needed for the transaction
+ * @param priorityFee - Priority fee in microLamports
+ * @param options - Optional configuration for retry mechanism and compute units
+ * @returns Promise that resolves to the transaction signature
+ *
+ * @example
+ * ```typescript
+ * const signature = await sendTransactionWithRetryAndPriorityFees(
+ *   connection,
+ *   transaction,
+ *   [payer],
+ *   1000,
+ *   {
+ *     computeUnitBuffer: { multiplier: 1.1 },
+ *     onStatusUpdate: (status) => console.log(status),
+ *   }
+ * );
+ * ```
+ */
+export async function sendTransactionWithRetryAndPriorityFees(
+  connection: Connection,
+  transaction: Transaction,
+  signers: Keypair[],
+  priorityFee: number = 10000,
+  options: SendTransactionOptions & {
+    computeUnitBuffer?: ComputeUnitBuffer;
+  } = {},
+): Promise<string> {
+  const {
+    computeUnitBuffer: userComputeBuffer, // Rename to make clear it's user provided
+    commitment = "confirmed",
+    ...sendOptions
+  } = options;
+
+  // Use user provided buffer or default to 1.1 multiplier
+  const computeUnitBuffer = userComputeBuffer ?? { multiplier: 1.1 };
+
+  if (transaction.recentBlockhash === undefined) {
+    console.log("No blockhash provided. Setting recent blockhash");
+    const { blockhash } = await connection.getLatestBlockhash(commitment);
+    transaction.recentBlockhash = blockhash;
+  }
+  if (transaction.feePayer === undefined) {
+    if (signers.length === 0) {
+      throw new Error("No signers or fee payer provided");
+    }
+    transaction.feePayer = signers[0].publicKey;
+  }
+
+  await prepareTransactionWithCompute(
+    connection,
+    transaction,
+    transaction.feePayer,
+    priorityFee,
+    computeUnitBuffer,
+    commitment,
+  );
+
+  return sendTransactionWithRetry(connection, transaction, signers, {
+    commitment,
+    ...sendOptions,
+  });
+}

tests/src/transaction.test.ts

@@ -7,13 +7,15 @@ import {
   SystemProgram,
   TransactionInstruction,
   PublicKey,
+  ComputeBudgetProgram,
 } from "@solana/web3.js";
 import {
   airdropIfRequired,
   confirmTransaction,
   getSimulationComputeUnits,
   prepareTransactionWithCompute,
   sendTransactionWithRetry,
+  sendTransactionWithRetryAndPriorityFees,
 } from "../../src";
 import { sendAndConfirmTransaction } from "@solana/web3.js";
 import assert from "node:assert";
@@ -192,4 +194,52 @@ describe("Transaction utilities", () => {
       );
     });
   });
+
+  test("sendTransactionWithRetryAndPriorityFees should prepare and send a transaction", async () => {
+    const connection = new Connection(LOCALHOST);
+    const sender = Keypair.generate();
+    await airdropIfRequired(
+      connection,
+      sender.publicKey,
+      2 * LAMPORTS_PER_SOL,
+      1 * LAMPORTS_PER_SOL,
+    );
+    const recipient = Keypair.generate();
+
+    const transaction = new Transaction().add(
+      SystemProgram.transfer({
+        fromPubkey: sender.publicKey,
+        toPubkey: recipient.publicKey,
+        lamports: LAMPORTS_PER_SOL * 0.1,
+      }),
+    );
+
+    const statusUpdates: any[] = [];
+    const signature = await sendTransactionWithRetryAndPriorityFees(
+      connection,
+      transaction,
+      [sender],
+      1000,
+      {
+        computeUnitBuffer: { multiplier: 1.1 },
+        onStatusUpdate: (status) => {
+          statusUpdates.push(status);
+          console.log("status", status);
+        },
+      },
+    );
+
+    assert.ok(signature);
+    assert.deepEqual(
+      statusUpdates.map((s) => s.status),
+      ["created", "signed", "sent", "confirmed"],
+    );
+
+    // Verify compute budget instructions were added
+    assert.equal(transaction.instructions.length, 3); // transfer + 2 compute budget instructions
+    const computeInstructions = transaction.instructions.filter((ix) =>
+      ix.programId.equals(ComputeBudgetProgram.programId),
+    );
+    assert.equal(computeInstructions.length, 2);
+  });
 });