@wireio/stake 2.1.0 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireio/stake",
-    "version": "2.1.0",
+    "version": "2.1.1",
     "description": "LIQ Staking Module for Wire Network",
     "homepage": "https://gitea.gitgo.app/Wire/sdk-stake",
     "license": "FSL-1.1-Apache-2.0",

package/src/networks/solana/solana.ts

@@ -1034,12 +1034,13 @@ export class SolanaStakingClient implements IStakingClient {
     // ---------------------------------------------------------------------
 
     /**
-     * Send a signed transaction over HTTP RPC and wait for confirmation.
-     * Throws if the transaction fails.
+     * Send a signed transaction over HTTP RPC.
      *
-     * - Handles benign "already processed" preflight errors.
-     * - Uses getSignatureStatuses() instead of confirmTransaction()
-     *   so we don't care about blockheight expiry.
+     * - Returns immediately on successful sendRawTransaction.
+     * - If sendRawTransaction throws a SendTransactionError with
+     *   "already been processed", we treat it as success and
+     *   just return a derived signature.
+     * - No confirmTransaction / polling / blockheight handling.
      */
     private async sendAndConfirmHttp(
         signed: SolanaTransaction,
@@ -1048,94 +1049,42 @@ export class SolanaStakingClient implements IStakingClient {
         this.ensureUser();
 
         const rawTx = signed.serialize();
-        let signature: string;
 
-        // -------------------------------------------------------------
-        // 1) Send the raw transaction
-        //    Handle "already been processed" as a soft success.
-        // -------------------------------------------------------------
         try {
-            signature = await this.connection.sendRawTransaction(rawTx, {
+            // Normal happy path: RPC accepts the tx and returns a signature
+            const signature = await this.connection.sendRawTransaction(rawTx, {
                 skipPreflight: false,
                 preflightCommitment: commitment,
                 maxRetries: 3,
             });
+            return signature;
         } catch (e: any) {
             const msg = e?.message ?? '';
-
             const isSendTxError =
                 e instanceof SendTransactionError || e?.name === 'SendTransactionError';
 
+            // Benign duplicate case: tx is already in the ledger / cache
             if (isSendTxError && msg.includes('already been processed')) {
-                // Preflight is telling us this exact txid already landed.
-                // Derive the signature from the signed tx and continue to confirmation.
                 console.warn(
-                    'sendRawTransaction preflight says "already been processed"; ' +
-                    'treating as success and deriving signature from signed tx.',
+                    'sendRawTransaction reports "already been processed"; ' +
+                    'treating as success without further confirmation.',
                 );
 
-                // Assuming SolanaTransaction is a legacy Transaction here.
+                // Try to derive a signature from the signed Transaction.
+                // If SolanaTransaction is a legacy Transaction, this works.
                 const legacy = signed as unknown as Transaction;
                 const first = legacy.signatures?.[0]?.signature;
 
-                if (!first) {
-                    // No way to recover the txid → rethrow
-                    throw e;
-                }
-
-                signature = bs58.encode(first);
-            } else {
-                // Any other send error is a real failure
-                throw e;
-            }
-        }
-
-        // -------------------------------------------------------------
-        // 2) Poll getSignatureStatuses until confirmed/finalized or timeout
-        // -------------------------------------------------------------
-        const start = Date.now();
-        const timeoutMs = 30_000;      // tune this if you want longer for devnet
-        const pollIntervalMs = 500;    // 0.5s between polls
-
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const { value } = await this.connection.getSignatureStatuses(
-                [signature],
-                { searchTransactionHistory: true },
-            );
-            const status = value[0];
-
-            if (status) {
-                if (status.err) {
-                    // On-chain error (instruction error, etc.)
-                    throw new Error(
-                        `Transaction failed: ${JSON.stringify(status.err)}`,
-                    );
-                }
-
-                const confirmations = status.confirmations;
-                const confirmationStatus = status.confirmationStatus;
-
-                const satisfied =
-                    confirmationStatus === 'confirmed' ||
-                    confirmationStatus === 'finalized' ||
-                    confirmations === null ||                 // rooted
-                    (confirmations ?? 0) > 0;                 // at least 1 confirmation
-
-                if (satisfied) {
-                    // We consider this successfully confirmed
-                    return signature;
+                if (first) {
+                    return bs58.encode(first);
                 }
-            }
 
-            // Timeout guard so we don't spin forever on a tx that never lands
-            if (Date.now() - start > timeoutMs) {
-                throw new Error(
-                    `Transaction confirmation timed out for ${signature}`,
-                );
+                // Fallback: return a dummy string
+                return 'already-processed';
             }
 
-            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            // Any other send error is a real failure
+            throw e;
         }
     }