@wireio/stake 2.0.0 → 2.1.0

package/src/networks/solana/program.ts

@@ -29,6 +29,25 @@ import type { LiqsolCore as LiqSolCoreDevnet } from '../../assets/solana/devnet/
 import type { LiqsolToken as LiqsolTokenDevnet } from '../../assets/solana/devnet/types/liqsol_token';
 import type { ValidatorLeaderboard as ValidatorLeaderboardDevnet } from '../../assets/solana/devnet/types/validator_leaderboard';
 
+// “Client” IDLs = mainnet OR devnet, plus `address` field we add at runtime
+
+export type LiqsolCoreClientIdl =
+    (LiqSolCoreMainnet | LiqSolCoreDevnet) & { address: string };
+
+export type LiqsolTokenClientIdl =
+    (LiqsolTokenMainnet | LiqsolTokenDevnet) & { address: string };
+
+export type ValidatorLeaderboardClientIdl =
+    (ValidatorLeaderboardMainnet | ValidatorLeaderboardDevnet) & { address: string };
+
+export type SolanaProgramIdlMap = {
+    liqsolCore: LiqsolCoreClientIdl;
+    liqsolToken: LiqsolTokenClientIdl;
+    validatorLeaderboard: ValidatorLeaderboardClientIdl;
+};
+
+export type SolanaProgramName = keyof SolanaProgramIdlMap;
+
 type Entry<IDL> = {
     idl: IDL & { address: string };
     address: string;
@@ -65,9 +84,6 @@ const PROGRAMS_BY_CHAIN = {
     },
 } as const;
 
-export type SolanaProgramName =
-    keyof (typeof PROGRAMS_BY_CHAIN)[SolChainID.Mainnet];
-
 export class SolanaProgramService {
     private readonly ids: SolanaProgramIds;
     private readonly programs: (typeof PROGRAMS_BY_CHAIN)[SolChainID.Mainnet];
@@ -90,15 +106,14 @@ export class SolanaProgramService {
         return this.ids;
     }
 
-    /** Anchor Program getter */
+    // Generic getProgram, typed by name → union IDL
     getProgram<K extends SolanaProgramName>(
         name: K,
-    ): Program<(typeof this.programs)[K]['idl']> {
+    ): Program<SolanaProgramIdlMap[K]> {
         const { idl, address } = this.programs[name];
-        const idlWithAddr = { ...idl, address };
-        return new Program(idlWithAddr, this.provider) as Program<
-            (typeof this.programs)[K]['idl']
-        >;
+        const idlWithAddr = { ...(idl as any), address } as SolanaProgramIdlMap[K];
+
+        return new Program(idlWithAddr, this.provider) as Program<SolanaProgramIdlMap[K]>;
     }
 
     listProgramNames(): SolanaProgramName[] {

package/src/networks/solana/solana.ts

@@ -4,12 +4,14 @@ import {
     Connection,
     ConnectionConfig,
     PerfSample,
+    SendTransactionError,
     PublicKey as SolPubKey,
     SystemProgram,
     Transaction,
     TransactionInstruction,
     TransactionMessage,
     TransactionSignature,
+    VersionedTransaction,
 } from '@solana/web3.js';
 import { AnchorProvider, BN } from '@coral-xyz/anchor';
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
@@ -343,15 +345,16 @@ export class SolanaStakingClient implements IStakingClient {
             //     return sent2;
             // }
             // else {
-                const ix = await this.depositClient.buildDepositTx(amountLamports)
-                const tx = new Transaction().add(ix);
-                const prepared = await this.prepareTx(tx);
-                const signed = await this.signTransaction(prepared.tx);
+            const ix = await this.depositClient.buildDepositTx(amountLamports)
+            const tx = new Transaction().add(ix);
+            const prepared = await this.prepareTx(tx);
+            const signed = await this.signTransaction(prepared.tx);
 
-                return this.sendAndConfirmHttp(signed, prepared);
+            return this.sendAndConfirmHttp(signed, prepared);
             // }
         } catch (err) {
-            throw new Error(`Failed to deposit Solana: ${err}`);
+            console.log(`Failed to deposit Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -385,7 +388,8 @@ export class SolanaStakingClient implements IStakingClient {
 
             return this.sendAndConfirmHttp(signed, prepared);
         } catch (err) {
-            throw new Error(`Failed to withdraw Solana: ${err}`);
+            console.log(`Failed to withdraw Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -415,7 +419,8 @@ export class SolanaStakingClient implements IStakingClient {
 
             return this.sendAndConfirmHttp(signed, prepared);
         } catch (err) {
-            throw new Error(`Failed to stake Solana: ${err}`);
+            console.log(`Failed to stake Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -446,7 +451,8 @@ export class SolanaStakingClient implements IStakingClient {
             return this.sendAndConfirmHttp(signed, prepared);
         }
         catch (err) {
-            throw new Error(`Failed to unstake Solana: ${err}`);
+            console.log(`Failed to unstake Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -474,7 +480,8 @@ export class SolanaStakingClient implements IStakingClient {
             return this.sendAndConfirmHttp(signed, prepared);
         }
         catch (err) {
-            throw new Error(`Failed to buy liqSOL pretokens: ${err}`);
+            console.log(`Failed to buy liqSOL pretokens: ${err}`);
+            throw err;
         }
     }
 
@@ -627,7 +634,8 @@ export class SolanaStakingClient implements IStakingClient {
             };
         }
         catch (err) {
-            throw new Error(`Failed to get Solana portfolio: ${err}`);
+            console.log(`Failed to get Solana portfolio: ${err}`);
+            throw err;
         }
     }
 
@@ -689,7 +697,8 @@ export class SolanaStakingClient implements IStakingClient {
             });
         }
         catch (err) {
-            throw new Error(`Failed to build Solana tranche snapshot: ${err}`);
+            console.log(`Failed to build Solana tranche snapshot: ${err}`);
+            throw err;
         }
     }
 
@@ -711,7 +720,8 @@ export class SolanaStakingClient implements IStakingClient {
 
             return apyPercent;
         } catch (err) {
-            throw new Error(`Failed to compute Solana system APY: ${err}`);
+            console.log(`Failed to compute Solana system APY: ${err}`);
+            throw err;
         }
     }
 
@@ -1026,38 +1036,107 @@ export class SolanaStakingClient implements IStakingClient {
     /**
      * Send a signed transaction over HTTP RPC and wait for confirmation.
      * Throws if the transaction fails.
+     *
+     * - Handles benign "already processed" preflight errors.
+     * - Uses getSignatureStatuses() instead of confirmTransaction()
+     *   so we don't care about blockheight expiry.
      */
     private async sendAndConfirmHttp(
         signed: SolanaTransaction,
-        ctx: { blockhash: string; lastValidBlockHeight: number },
+        _ctx: { blockhash: string; lastValidBlockHeight: number },
     ): Promise<string> {
         this.ensureUser();
 
-        const signature = await this.connection.sendRawTransaction(
-            signed.serialize(),
-            {
+        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, {
                 skipPreflight: false,
                 preflightCommitment: commitment,
                 maxRetries: 3,
-            },
-        );
+            });
+        } catch (e: any) {
+            const msg = e?.message ?? '';
+
+            const isSendTxError =
+                e instanceof SendTransactionError || e?.name === 'SendTransactionError';
+
+            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.',
+                );
 
-        const conf = await this.connection.confirmTransaction(
-            {
-                signature,
-                blockhash: ctx.blockhash,
-                lastValidBlockHeight: ctx.lastValidBlockHeight,
-            },
-            commitment,
-        );
+                // Assuming SolanaTransaction is a legacy Transaction here.
+                const legacy = signed as unknown as Transaction;
+                const first = legacy.signatures?.[0]?.signature;
 
-        if (conf.value.err) {
-            throw new Error(
-                `Transaction failed: ${JSON.stringify(conf.value.err)}`,
-            );
+                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;
+            }
         }
 
-        return signature;
+        // -------------------------------------------------------------
+        // 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;
+                }
+            }
+
+            // 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}`,
+                );
+            }
+
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
     }
 
     /**