Rename to just sendTransaction()

- Its cleaner
- Covered some potential edge cases if transaction already signed or has computeInstructions already

Author: Woody4618

CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.7
+
+- Added `sendTransaction()` to send transactions with compute unit optimization and automatic retries.
+- Removed `sendTransactionWithRetry()` as sendTransaction() is more convenient.
+
 ## 2.6
 
 - Added Transaction send helpers. `prepareTransactionWithCompute()` and `sendTransactionWithRetry()`

README.md

@@ -496,77 +496,73 @@ To just run tests matching the name `getCustomErrorMessage`.
 
 ### Transaction Utilities
 
-#### `sendTransactionWithRetry`
+#### `sendTransaction`
 
-Sends a transaction with automatic retries and status updates. This function implements a robust retry mechanism that:
+Sends a transaction with compute unit optimization and automatic retries. This function:
 
-1. Signs the transaction (if signers are provided)
-2. Sends the transaction only once
-3. Monitors the transaction status until confirmation
-4. Retries on failure with a fixed delay
-5. Provides detailed status updates through a callback
+1. Automatically sets compute units based on simulation
+2. Adds priority fees for faster processing
+3. Handles retries and confirmation
+4. Provides detailed status updates
 
 ```typescript
-const signature = await sendTransactionWithRetry(
+const signature = await sendTransaction(connection, transaction, [payer]);
+```
+
+The function is also customizable if you do not like the defaults:
+
+```typescript
+const signature = await sendTransaction(
   connection,
   transaction,
-  signers,
+  [payer],
+  10000, // priority fee in microLamports
   {
-    commitment: "confirmed",
+    computeUnitBuffer: { multiplier: 1.1 }, // add 10% buffer to compute units
     onStatusUpdate: (status) => console.log(status),
-    maxRetries: 30,
+    commitment: "confirmed",
+    maxRetries: 10,
     initialDelayMs: 2000,
   },
 );
 ```
 
-Best combined with `prepareTransactionWithCompute` to ensure the transaction requests the minimum compute units and sets priority fees.
+The function will:
 
-```typescript
-// This could be really nice if RPC providers would all have the same API...
-// Please fall back to the fee api of your favourite RPC provider to get a good value.
-const priorityFee = 1000;
+- Skip compute preparation if transaction is already signed
+- Skip compute preparation if transaction already has compute budget instructions
+- Add compute budget instructions if needed
+- Handle retries and confirmation automatically
+- Provide status updates: "created" → "signed" → "sent" → "confirmed"
 
-await prepareTransactionWithCompute(
-  connection,
-  tx,
-  keyPair.publicKey,
-  priorityFee
-);
-
-// can either sign the transaction here, or in the sendTransactionWithRetry function
-tx.sign(keyPair);
-
-var signature = await sendTransactionWithRetry(connection, tx, [], {
-  onStatusUpdate: (status) => {
-    console.log("Transaction status:", status);
-  },
-});
+For RPC providers that support priority fees:
 
-```
+- Helius: minimum 10000 microLamports
+- Triton: see their [priority fee API](https://docs.triton.one/chains/solana/improved-priority-fees-api)
+- Quicknode: see their [priority fee estimation](https://www.quicknode.com/docs/solana/qn_estimatePriorityFees)
 
 #### `prepareTransactionWithCompute`
 
-Prepares a transaction with compute unit calculations and limits. This function:
-
-1. Simulates the transaction to determine required compute units
-2. Adds compute budget instructions for both price and unit limit
-3. Supports buffer settings to add safety margins (This is useful when inteacting with defi for examples where the price or route may change during the transaction)
+If you need more control, you can prepare compute units separately:
 
 ```typescript
 await prepareTransactionWithCompute(
   connection,
   transaction,
   payer.publicKey,
-  1000, // priority fee in microLamports
+  10000, // priority fee
   {
     multiplier: 1.1, // add 10% buffer
     fixed: 100, // add fixed amount of CUs
   },
 );
 ```
 
-Both functions help with common transaction handling tasks in Solana, making it easier to send reliable transactions with appropriate compute unit settings.
+This will:
+
+1. Simulate the transaction to determine required compute units
+2. Add compute budget instructions for both price and unit limit
+3. Apply any specified compute unit buffers
 
 ## Anchor IDL Utilities
 

src/lib/transaction.ts

@@ -82,7 +82,10 @@ export const getSimulationComputeUnits = async (
 
   if (rpcResponse?.value?.err) {
     const logs = rpcResponse.value.logs?.join("\n  • ") || "No logs available";
-    throw new Error(`Transaction simulation failed:\n  •${logs}`);
+    throw new Error(
+      `Transaction simulation failed:\n  •${logs}` +
+        JSON.stringify(rpcResponse?.value?.err),
+    );
   }
 
   return rpcResponse.value.unitsConsumed || null;
@@ -188,7 +191,7 @@ export const DEFAULT_SEND_OPTIONS: Required<
  * );
  * ```
  */
-export async function sendTransactionWithRetry(
+async function sendTransactionWithRetry(
   connection: Connection,
   transaction: Transaction,
   signers: Keypair[],
@@ -643,25 +646,25 @@ function formatData(data: any): any {
  * @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 priorityFee - Priority fee in microLamports (default: 10000 which is the minimum required for helius to see a transaction as priority)
  * @param options - Optional configuration for retry mechanism and compute units
  * @returns Promise that resolves to the transaction signature
  *
  * @example
  * ```typescript
- * const signature = await sendTransactionWithRetryAndPriorityFees(
+ * const signature = await sendTransaction(
  *   connection,
  *   transaction,
  *   [payer],
- *   1000,
+ *   10000,
  *   {
  *     computeUnitBuffer: { multiplier: 1.1 },
  *     onStatusUpdate: (status) => console.log(status),
  *   }
  * );
  * ```
  */
-export async function sendTransactionWithRetryAndPriorityFees(
+export async function sendTransaction(
   connection: Connection,
   transaction: Transaction,
   signers: Keypair[],
@@ -691,6 +694,26 @@ export async function sendTransactionWithRetryAndPriorityFees(
     transaction.feePayer = signers[0].publicKey;
   }
 
+  // Skip compute preparation if transaction is already signed or has compute instructions
+  if (transaction.signatures.length > 0) {
+    console.log("Transaction already signed, skipping compute preparation");
+    return sendTransactionWithRetry(connection, transaction, signers, {
+      commitment,
+      ...sendOptions,
+    });
+  }
+
+  const hasComputeInstructions = transaction.instructions.some(ix => 
+    ix.programId.equals(ComputeBudgetProgram.programId)
+  );
+
+  if (hasComputeInstructions) {
+    console.log("Transaction already has compute instructions, skipping compute preparation"); 
+    return sendTransactionWithRetry(connection, transaction, signers, {
+      commitment,
+      ...sendOptions,
+    });
+  }
   await prepareTransactionWithCompute(
     connection,
     transaction,

tests/src/transaction.test.ts

@@ -14,8 +14,7 @@ import {
   confirmTransaction,
   getSimulationComputeUnits,
   prepareTransactionWithCompute,
-  sendTransactionWithRetry,
-  sendTransactionWithRetryAndPriorityFees,
+  sendTransaction,
 } from "../../src";
 import { sendAndConfirmTransaction } from "@solana/web3.js";
 import assert from "node:assert";
@@ -101,7 +100,7 @@ describe("getSimulationComputeUnits", () => {
 });
 
 describe("Transaction utilities", () => {
-  test("sendTransactionWithRetry should send and confirm a transaction", async () => {
+  test("sendTransaction without priority fee should send and confirm a transaction", async () => {
     const connection = new Connection(LOCALHOST);
     const sender = Keypair.generate();
     await airdropIfRequired(
@@ -126,10 +125,11 @@ describe("Transaction utilities", () => {
     transaction.feePayer = sender.publicKey;
 
     const statusUpdates: any[] = [];
-    const signature = await sendTransactionWithRetry(
+    const signature = await sendTransaction(
       connection,
       transaction,
       [sender],
+      0,
       {
         onStatusUpdate: (status) => {
           statusUpdates.push(status);
@@ -195,7 +195,7 @@ describe("Transaction utilities", () => {
     });
   });
 
-  test("sendTransactionWithRetryAndPriorityFees should prepare and send a transaction", async () => {
+  test("sendTransaction should prepare and send a transaction and add priority fee instructions", async () => {
     const connection = new Connection(LOCALHOST);
     const sender = Keypair.generate();
     await airdropIfRequired(
@@ -215,7 +215,7 @@ describe("Transaction utilities", () => {
     );
 
     const statusUpdates: any[] = [];
-    const signature = await sendTransactionWithRetryAndPriorityFees(
+    const signature = await sendTransaction(
       connection,
       transaction,
       [sender],