@wireio/stake 2.4.4 → 2.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireio/stake",
-    "version": "2.4.4",
+    "version": "2.5.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/clients/outpost.client.ts

@@ -14,6 +14,7 @@ import { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
 import {
     OutpostAccounts,
     buildOutpostAccounts,
+    safeFetch,
 } from '../utils';
 
 import {
@@ -74,11 +75,37 @@ export class OutpostClient {
      * Internal helper: get raw token balance (BN) for a given ATA.
      */
     private async getTokenBalance(ata: PublicKey): Promise<BN> {
+        const bal = await this.connection.getTokenAccountBalance(ata);
+        return new BN(bal.value.amount);
+    }
+
+    /**
+     * Fetch an OutpostAccount, handling legacy accounts that pre-date the
+     * three trailing Option<u64> fields.  If the normal decode throws a
+     * RangeError we re-fetch the raw data, pad it to the expected size
+     * (zeros → Option::None for each missing field), and let Anchor's
+     * coder decode the padded buffer.
+     */
+    private async fetchOutpostAccount(address: PublicKey) {
         try {
-            const bal = await this.connection.getTokenAccountBalance(ata);
-            return new BN(bal.value.amount);
-        } catch {
-            return new BN(0);
+            return await this.program.account.outpostAccount.fetchNullable(address);
+        } catch (e) {
+            if (!(e instanceof RangeError)) throw e;
+
+            const info = await this.connection.getAccountInfo(address);
+            if (!info) return null;
+
+            // 3 × Option<u64> encoded as 1-byte tag (0x00 = None) = 3 bytes
+            // when present (Some) each is 9 bytes, but None is just 0x00
+            const EXPECTED_SIZE = info.data.length + 3;
+            const padded = Buffer.alloc(EXPECTED_SIZE);
+            info.data.copy(padded);
+            // trailing bytes are already 0x00 → Option::None for each field
+
+            return this.program.coder.accounts.decode(
+                'outpostAccount',
+                padded,
+            );
         }
     }
 
@@ -87,48 +114,40 @@ export class OutpostClient {
      */
     async fetchWireState(user?: PublicKey): Promise<OutpostWireStateSnapshot> {
         const userPk = user ?? this.wallet.publicKey;
-        if (!userPk) {
-            throw new Error('OutpostClient.fetchWireState: wallet not connected');
-        }
+        if (!userPk) throw new Error('OutpostClient.fetchWireState: wallet not connected');
 
         const pdas = await this.buildAccounts(userPk);
+        const [
+            globalState,
+            outpostAccount,
+            distributionState,
+            userPretokenRecord,
+            trancheState,
+            liqsolPoolBalance,
+            userLiqsolBalance,
+        ] = await Promise.all([
+            safeFetch(this.program.account.globalState.fetch(pdas.globalState), 'globalState'),
+            safeFetch(this.fetchOutpostAccount(pdas.outpostAccount), 'outpostAccount'),
+            safeFetch(this.program.account.distributionState.fetchNullable(pdas.distributionState), 'distributionState'),
+            safeFetch(this.program.account.userPretokenRecord.fetchNullable(pdas.userPretokenRecord), 'userPretokenRecord'),
+            safeFetch(this.program.account.trancheState.fetchNullable(pdas.trancheState), 'trancheState'),
+            safeFetch(this.getTokenBalance(pdas.liqsolPoolAta), 'liqsolPoolAta'),
+            safeFetch(this.getTokenBalance(pdas.userAta), 'userAta'),
+        ]);
 
-        try {
-            const [
-                globalState,
-                outpostAccount,
-                distributionState,
-                userPretokenRecord,
-                trancheState,
-            ] = await Promise.all([
-                this.program.account.globalState.fetch(pdas.globalState),
-                this.program.account.outpostAccount.fetchNullable(pdas.outpostAccount),
-                this.program.account.distributionState.fetchNullable(pdas.distributionState),
-                this.program.account.userPretokenRecord.fetchNullable(pdas.userPretokenRecord),
-                this.program.account.trancheState.fetchNullable(pdas.trancheState),
-            ]);
-
-            const [liqsolPoolBalance, userLiqsolBalance] = await Promise.all([
-                this.getTokenBalance(pdas.liqsolPoolAta),
-                this.getTokenBalance(pdas.userAta),
-            ]);
-
-            return {
-                globalState,
-                outpostAccount,
-                distributionState,
-                trancheState,
-                userPretokenRecord,
-                liqsolPoolBalance,
-                userLiqsolBalance,
-            };
-        }
-        catch (err) {
-            console.error('Error fetching Outpost wire state:', err);
-            throw err;
-        }
+        return {
+            globalState,
+            outpostAccount,
+            distributionState,
+            trancheState,
+            userPretokenRecord,
+            liqsolPoolBalance,
+            userLiqsolBalance,
+        };
     }
 
+
+
     // -------------------------------------------------------------------------
     // Outpost stake / unstake builders (synd / desynd)
     // -------------------------------------------------------------------------
@@ -301,4 +320,4 @@ export class OutpostClient {
         const decPart = valueStr.slice(valueStr.length - decimals);
         return `${intPart}.${decPart}`;
     }
-}
+}

package/src/networks/solana/types.ts

@@ -34,7 +34,11 @@ export type ParsedAccountInfo = {
  */
 
 export type OutpostWireStateSnapshot = {
-    globalState: GlobalState;
+    /**
+     * Global Wire/outpost state.
+     * May be null if the fetch fails.
+     */
+    globalState: GlobalState | null;
 
     /**
      * Per-user Outpost account (old “wire receipt”), or null if user
@@ -60,11 +64,11 @@ export type OutpostWireStateSnapshot = {
     userPretokenRecord: UserPretokenRecord | null;
 
     // Balances
-    /** liqSOL in the pool ATA (Token-2022 raw amount) */
-    liqsolPoolBalance: BN;
+    /** liqSOL in the pool ATA (Token-2022 raw amount), or null on fetch failure */
+    liqsolPoolBalance: BN | null;
 
-    /** liqSOL in the user’s ATA (Token-2022 raw amount) */
-    userLiqsolBalance: BN;
+    /** liqSOL in the user’s ATA (Token-2022 raw amount), or null on fetch failure */
+    userLiqsolBalance: BN | null;
 };
 
 /**
@@ -750,4 +754,4 @@ export type ReceiptData = {
 
     /** Flag indicating whether this receipt has been fulfilled/claimed (bool) */
     fulfilled: boolean;
-};
+};

package/src/networks/solana/utils.ts

@@ -562,3 +562,11 @@ export function normalizeToBigInt(x: any): bigint {
     if (typeof x === 'number') return BigInt(x);
     throw new Error(`normalizeToBigInt: unsupported type ${typeof x}`);
 }
+
+export const safeFetch = async <T>(promise: Promise<T>, label?: string): Promise<T | null> => {
+    try { return await promise; }
+    catch (err) {
+        console.error(`Safe Fetch Failed${label ? ` (${label})` : ''}:`,err);
+        return null;
+    }
+};