@wireio/stake 2.0.0 → 2.1.1

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;
         }
     }
 
@@ -1024,40 +1034,58 @@ 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.
+     *
+     * - 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,
-        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();
+
+        try {
+            // 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')) {
+                console.warn(
+                    'sendRawTransaction reports "already been processed"; ' +
+                    'treating as success without further confirmation.',
+                );
 
-        const conf = await this.connection.confirmTransaction(
-            {
-                signature,
-                blockhash: ctx.blockhash,
-                lastValidBlockHeight: ctx.lastValidBlockHeight,
-            },
-            commitment,
-        );
+                // 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 (conf.value.err) {
-            throw new Error(
-                `Transaction failed: ${JSON.stringify(conf.value.err)}`,
-            );
-        }
+                if (first) {
+                    return bs58.encode(first);
+                }
+
+                // Fallback: return a dummy string
+                return 'already-processed';
+            }
 
-        return signature;
+            // Any other send error is a real failure
+            throw e;
+        }
     }
 
     /**