solana: Added client-side tx rebroadcast logic

Author: kev1n-peters

platforms/solana/src/platform.ts

@@ -24,7 +24,9 @@ import type {
   Commitment,
   ConnectionConfig,
   ParsedAccountData,
+  RpcResponseAndContext,
   SendOptions,
+  SignatureResult,
 } from '@solana/web3.js';
 import { Connection, PublicKey } from '@solana/web3.js';
 import { SolanaAddress, SolanaZeroAddress } from './address.js';
@@ -176,41 +178,74 @@ export class SolanaPlatform<N extends Network>
     stxns: SignedTx[],
     opts?: SendOptions,
   ): Promise<TxHash[]> {
-    const { blockhash, lastValidBlockHeight } = await this.latestBlock(rpc);
-    const txhashes = await Promise.all(
-      stxns.map((stxn) =>
-        rpc.sendRawTransaction(
-          stxn,
-          // Set the commitment level to match the rpc commitment level
-          // otherwise, it defaults to finalized
-          opts ?? { preflightCommitment: rpc.commitment },
-        ),
-      ),
-    );
-
     const results = await Promise.all(
-      txhashes.map((signature) => {
-        return rpc.confirmTransaction(
-          {
-            signature,
-            blockhash,
-            lastValidBlockHeight,
-          },
-          rpc.commitment,
-        );
-      }),
+      stxns.map((stxn) => this.sendTxWithRetry(rpc, stxn, opts)),
     );
 
+    const txhashes = results.map((r) => r.signature);
+
     const erroredTxs = results
-      .filter((result) => result.value.err)
-      .map((result) => result.value.err);
+      .filter((r) => r.response.value.err)
+      .map((r) => r.response.value.err);
 
     if (erroredTxs.length > 0)
       throw new Error(`Failed to confirm transaction: ${erroredTxs}`);
 
     return txhashes;
   }
 
+  static async sendTxWithRetry(
+    rpc: Connection,
+    tx: SignedTx,
+    sendOpts: SendOptions = {},
+    retryInterval = 5000,
+  ): Promise<{
+    signature: string;
+    response: RpcResponseAndContext<SignatureResult>;
+  }> {
+    const commitment = sendOpts.preflightCommitment ?? rpc.commitment;
+    const signature = await rpc.sendRawTransaction(tx, {
+      ...sendOpts,
+      skipPreflight: false, // The first send should not skip preflight to catch any errors
+      maxRetries: 0,
+      preflightCommitment: commitment,
+    });
+    // TODO: Use the lastValidBlockHeight that corresponds to the blockhash used in the transaction.
+    const { blockhash, lastValidBlockHeight } = await rpc.getLatestBlockhash();
+    const confirmTransactionPromise = rpc.confirmTransaction(
+      {
+        signature,
+        blockhash,
+        lastValidBlockHeight,
+      },
+      commitment,
+    );
+    // This loop will break once the transaction has been confirmed or the block height is exceeded.
+    // An exception will be thrown if the block height is exceeded by the confirmTransactionPromise.
+    // The transaction will be resent if it hasn't been confirmed after the interval.
+    let confirmedTx: RpcResponseAndContext<SignatureResult> | null = null;
+    while (!confirmedTx) {
+      confirmedTx = await Promise.race([
+        confirmTransactionPromise,
+        new Promise<null>((resolve) =>
+          setTimeout(() => {
+            resolve(null);
+          }, retryInterval),
+        ),
+      ]);
+      if (confirmedTx) {
+        break;
+      }
+      await rpc.sendRawTransaction(tx, {
+        ...sendOpts,
+        skipPreflight: true,
+        maxRetries: 0,
+        preflightCommitment: commitment,
+      });
+    }
+    return { signature, response: confirmedTx };
+  }
+
   static async latestBlock(
     rpc: Connection,
     commitment?: Commitment,

platforms/solana/src/signer.ts

@@ -203,25 +203,27 @@ export class SolanaSendSigner<
       for (let i = 0; i < this._maxResubmits; i++) {
         try {
           if (isVersionedTransaction(transaction)) {
-            if (priorityFeeIx) {
+            if (priorityFeeIx && i === 0) {
               const msg = TransactionMessage.decompile(transaction.message);
               msg.instructions.push(...priorityFeeIx);
               transaction.message = msg.compileToV0Message();
             }
             transaction.message.recentBlockhash = blockhash;
             transaction.sign([this._keypair, ...(extraSigners ?? [])]);
           } else {
-            if (priorityFeeIx) transaction.add(...priorityFeeIx);
+            if (priorityFeeIx && i === 0) transaction.add(...priorityFeeIx);
             transaction.recentBlockhash = blockhash;
+            transaction.lastValidBlockHeight = lastValidBlockHeight;
             transaction.partialSign(this._keypair, ...(extraSigners ?? []));
           }
 
           if (this._debug) console.log('Submitting transactions ');
-          const txid = await this._rpc.sendRawTransaction(
+          const { signature } = await SolanaPlatform.sendTxWithRetry(
+            this._rpc,
             transaction.serialize(),
             this._sendOpts,
           );
-          txids.push(txid);
+          txids.push(signature);
           break;
         } catch (e) {
           // No point checking if retryable if we're on the last retry