@wireio/stake 1.1.0 → 1.1.69

package/src/networks/solana/clients/outpost.client.ts

@@ -9,21 +9,24 @@ import {
     TOKEN_2022_PROGRAM_ID,
 } from '@solana/spl-token';
 
-import liqsolCoreIDL from '../../../assets/solana/idl/liqsol_core.json';
-import { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
-
 import {
     OutpostAccounts,
     buildOutpostAccounts,
+    safeFetch,
 } from '../utils';
 
 import {
+    DistributionState,
+    GlobalState,
+    OutpostAccount,
     OutpostWireStateSnapshot,
     SharesPreview,
     TrancheState,
+    UserPretokenRecord,
     WalletLike,
 } from '../types';
-import { INDEX_SCALE, PROGRAM_IDS } from '../constants';
+import { INDEX_SCALE } from '../constants';
+import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
 
 /**
  * OutpostClient
@@ -41,12 +44,13 @@ import { INDEX_SCALE, PROGRAM_IDS } from '../constants';
  * in sync with the on-chain PDAs and capital-staking Wire utils.
  */
 export class OutpostClient {
-    private readonly program: Program<LiqsolCore>;
+    private readonly program: Program<LiqsolCoreClientIdl>;
 
     constructor(
         private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService,
     ) {
-        this.program = new Program(liqsolCoreIDL as any, provider);
+        this.program = pgs.getProgram('liqsolCore');
     }
 
     get connection() {
@@ -57,14 +61,6 @@ export class OutpostClient {
         return this.provider.wallet as unknown as WalletLike;
     }
 
-    /**
-     * Expose the raw Program in case callers need to build custom
-     * instructions outside this client.
-     */
-    get liqsolCoreProgram(): Program<LiqsolCore> {
-        return this.program;
-    }
-
     /**
      * Build all outpost-related PDAs / ATAs for a given user.
      * Defaults to the connected wallet.
@@ -74,18 +70,45 @@ export class OutpostClient {
         if (!userPk) {
             throw new Error('OutpostClient.buildAccounts: wallet not connected');
         }
-        return buildOutpostAccounts(this.connection, userPk);
+        return buildOutpostAccounts(this.connection, userPk, this.pgs);
     }
 
     /**
      * 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) {
+        const program: any = this.program;
         try {
-            const bal = await this.connection.getTokenAccountBalance(ata);
-            return new BN(bal.value.amount);
-        } catch {
-            return new BN(0);
+            return await 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 program.coder.accounts.decode(
+                'outpostAccount',
+                padded,
+            );
         }
     }
 
@@ -93,102 +116,114 @@ export class OutpostClient {
      * Fetch the core "Wire state" for Outpost / pretokens for a given user.
      */
     async fetchWireState(user?: PublicKey): Promise<OutpostWireStateSnapshot> {
+        const program: any = this.program;
         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(program.account.globalState.fetch(pdas.globalState), 'globalState'),
+            safeFetch(this.fetchOutpostAccount(pdas.outpostAccount), 'outpostAccount'),
+            safeFetch(program.account.distributionState.fetchNullable(pdas.distributionState), 'distributionState'),
+            safeFetch(program.account.userPretokenRecord.fetchNullable(pdas.userPretokenRecord), 'userPretokenRecord'),
+            safeFetch(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: globalState as GlobalState | null,
+            outpostAccount: outpostAccount as OutpostAccount | null,
+            distributionState: distributionState as DistributionState | null,
+            trancheState: trancheState as TrancheState | null,
+            userPretokenRecord: userPretokenRecord as UserPretokenRecord | null,
+            liqsolPoolBalance,
+            userLiqsolBalance,
+        };
     }
 
+
+
     // -------------------------------------------------------------------------
-    // Outpost stake / unstake builders (synd / desynd)
+    // Outpost stake / unstake builders (syndicate_liqsol_to_wire / desynd)
     // -------------------------------------------------------------------------
 
     /**
-     * Build the `synd` (stake) instruction:
-     *   user liqSOL ATA → liqSOL pool ATA
+     * Build the `syndicate_liqsol_to_wire` (stake) instruction:
+     *   user liqSOL ATA → liqSOL pool ATA, bridged to the Wire chain.
+     *
+     * @param amountLamports  Amount of liqSOL to stake (in lamports / base units).
+     * @param user            Solana signer. Defaults to the connected wallet.
+     * @param wireAccount     Wire chain recipient account name. Required.
      */
     async buildStakeIx(
         amountLamports: bigint,
-        user?: PublicKey,
+        user: PublicKey = this.wallet.publicKey,
+        wireAccount?: string,
     ): Promise<TransactionInstruction> {
-        const userPk = user ?? this.wallet.publicKey;
-        if (!userPk) {
+        const program: any = this.program;
+        if (!user) {
             throw new Error('OutpostClient.buildStakeIx: wallet not connected');
         }
+        if (!wireAccount?.trim()) {
+            throw new Error('OutpostClient.buildStakeIx: wireAccount is required');
+        }
 
-        const a = await this.buildAccounts(userPk);
+        const a = await this.buildAccounts(user);
 
-        return this.program.methods
-            .synd(new BN(amountLamports.toString()))
+        return program.methods
+            .syndicateLiqsolToWire(wireAccount.trim(), new BN(amountLamports.toString()))
             .accounts({
-                user: userPk,
+                user,
                 liqsolMint: a.liqsolMint,
-                globalState: a.globalState,
                 distributionState: a.distributionState,
+                globalState: a.globalState,
                 userAta: a.userAta,
+                senderUserRecord: a.userUserRecord,
                 poolAuthority: a.poolAuthority,
+                liqsolPoolAta: a.liqsolPoolAta,
+                poolUserRecord: a.liqsolPoolUserRecord,
+                bridgeState: a.bridgeState,
+                extraAccountMetaList: a.extraAccountMetaList,
+                liqsolCoreProgram: this.pgs.PROGRAM_IDS.LIQSOL_CORE,
+                transferHookProgram: this.pgs.PROGRAM_IDS.TRANSFER_HOOK,
                 bucketAuthority: a.bucketAuthority,
                 bucketTokenAccount: a.bucketTokenAccount,
                 bucketUserRecord: a.bucketUserRecord,
-                senderUserRecord: a.userUserRecord,
-                receiverUserRecord: a.liqsolPoolUserRecord,
-                extraAccountMetaList: a.extraAccountMetaList,
-                liqsolCoreProgram: PROGRAM_IDS.LIQSOL_CORE,
-                transferHookProgram: PROGRAM_IDS.TRANSFER_HOOK,
-                liqsolPoolAta: a.liqsolPoolAta,
-                outpostAccount: a.outpostAccount,
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
                 systemProgram: SystemProgram.programId,
+                globalConfig: a.globalConfig,
+                oppEpochState: a.oppEpochState,
+                pendingAttestations: a.pendingAttestations,
             })
             .instruction();
     }
 
     /**
-     * Build the `desynd` (unstake) instruction:
+     * Build the `desynd` (unstake / desync) instruction:
      *   liqSOL pool ATA → user liqSOL ATA
+     *
+     * When Wire is in PostLaunch mode this instruction emits a `DesyncRequest`
+     * OPP attestation and does NOT immediately return tokens.  The Wire chain
+     * relay picks up the attestation, and an admin subsequently executes
+     * `complete_withdraw` to deliver the tokens to the user.
+     *
+     * In PreLaunch mode the tokens are returned directly.
      */
     async buildUnstakeIx(
         amountLamports: bigint,
         user?: PublicKey,
     ): Promise<TransactionInstruction> {
+        const program: any = this.program;
         const userPk = user ?? this.wallet.publicKey;
         if (!userPk) {
             throw new Error('OutpostClient.buildUnstakeIx: wallet not connected');
@@ -196,7 +231,7 @@ export class OutpostClient {
 
         const a = await this.buildAccounts(userPk);
 
-        return this.program.methods
+        return program.methods
             .desynd(new BN(amountLamports.toString()))
             .accounts({
                 user: userPk,
@@ -211,12 +246,17 @@ export class OutpostClient {
                 senderUserRecord: a.liqsolPoolUserRecord,
                 receiverUserRecord: a.userUserRecord,
                 extraAccountMetaList: a.extraAccountMetaList,
-                liqsolCoreProgram: PROGRAM_IDS.LIQSOL_CORE,
-                transferHookProgram: PROGRAM_IDS.TRANSFER_HOOK,
+                liqsolCoreProgram: this.pgs.PROGRAM_IDS.LIQSOL_CORE,
+                transferHookProgram: this.pgs.PROGRAM_IDS.TRANSFER_HOOK,
                 liqsolPoolAta: a.liqsolPoolAta,
                 outpostAccount: a.outpostAccount,
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 systemProgram: SystemProgram.programId,
+                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+                globalConfig: a.globalConfig,
+                oppEpochState: a.oppEpochState,
+                pendingAttestations: a.pendingAttestations,
+                pretokenPurchaseHistory: a.pretokenPurchaseHistory,
             })
             .instruction();
     }
@@ -277,7 +317,7 @@ export class OutpostClient {
      *   if remainder > 0 → shares + 1
      */
     static tokensToShares(amount: BN, currentIndex: BN): BN {
-        const numerator = amount.mul(INDEX_SCALE);
+        const numerator = amount.mul(new BN(INDEX_SCALE));
         const shares = numerator.div(currentIndex);
         const remainder = numerator.mod(currentIndex);
         return remainder.eqn(0) ? shares : shares.addn(1);
@@ -306,4 +346,4 @@ export class OutpostClient {
         const decPart = valueStr.slice(valueStr.length - decimals);
         return `${intPart}.${decPart}`;
     }
-}
+}

package/src/networks/solana/clients/token.client.ts

@@ -11,8 +11,7 @@ import {
     type OutpostAccounts,
 } from '../utils';
 
-import { SolanaProgramService } from '../program';
-import type { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
+import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
 
 import {
     GlobalState,
@@ -24,16 +23,12 @@ import {
 } from '../types';
 
 import {
-    derivePriceHistoryPda,
     CHAINLINK_FEED,
     CHAINLINK_PROGRAM,
-    PROGRAM_IDS,
-    deriveExtraAccountMetaListPda,
 } from '../constants';
 
-
 export class TokenClient {
-    private readonly program: Program<LiqsolCore>;
+    private readonly program: Program<LiqsolCoreClientIdl>;
 
     get wallet(): WalletLike {
         return this.provider.wallet;
@@ -43,9 +38,11 @@ export class TokenClient {
         return this.provider.connection;
     }
 
-    constructor(private readonly provider: AnchorProvider) {
-        const svc = new SolanaProgramService(provider);
-        this.program = svc.getProgram('liqsolCore');
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('liqsolCore');
     }
 
     // ---------------------------------------------------------------------------
@@ -53,17 +50,19 @@ export class TokenClient {
     // ---------------------------------------------------------------------------
 
     async getAccounts(user: PublicKey): Promise<OutpostAccounts> {
-        return buildOutpostAccounts(this.provider.connection, user);
+        return buildOutpostAccounts(this.provider.connection, user, this.pgs);
     }
 
     async fetchGlobalState(): Promise<GlobalState> {
+        const program: any = this.program;
         const { globalState } = await this.getAccounts(this.wallet.publicKey);
-        return this.program.account.globalState.fetch(globalState);
+        return program.account.globalState.fetch(globalState);
     }
 
     async fetchTrancheState(): Promise<TrancheState> {
+        const program: any = this.program;
         const { trancheState } = await this.getAccounts(this.wallet.publicKey);
-        return this.program.account.trancheState.fetch(trancheState);
+        return program.account.trancheState.fetch(trancheState);
     }
 
     /**
@@ -71,8 +70,9 @@ export class TokenClient {
      * Returns null if the user has never interacted with Outpost.
      */
     async fetchOutpostAccount(user: PublicKey): Promise<OutpostAccount | null> {
+        const program: any = this.program;
         const { outpostAccount } = await this.getAccounts(user);
-        return this.program.account.outpostAccount.fetchNullable(outpostAccount);
+        return program.account.outpostAccount.fetchNullable(outpostAccount);
     }
 
     /**
@@ -82,8 +82,9 @@ export class TokenClient {
     async fetchUserPretokenRecord(
         user: PublicKey,
     ): Promise<UserPretokenRecord | null> {
+        const program: any = this.program;
         const { userPretokenRecord } = await this.getAccounts(user);
-        return this.program.account.userPretokenRecord.fetchNullable(
+        return program.account.userPretokenRecord.fetchNullable(
             userPretokenRecord,
         );
     }
@@ -102,13 +103,16 @@ export class TokenClient {
         amountLamports: bigint,
         user = this.wallet.publicKey,
     ): Promise<TransactionInstruction> {
+        const program: any = this.program;
+        console.log('build purchase for', user.toBase58());
+        
         const a = await this.getAccounts(user);
 
-        const extraAccountMetaList = deriveExtraAccountMetaListPda(a.liqsolMint);
-        const liqsolCoreProgram = PROGRAM_IDS.LIQSOL_CORE;
-        const transferHookProgram = PROGRAM_IDS.TRANSFER_HOOK;
+        const extraAccountMetaList = this.pgs.deriveExtraAccountMetaListPda(a.liqsolMint);
+        const liqsolCoreProgram = this.pgs.PROGRAM_IDS.LIQSOL_CORE;
+        const transferHookProgram = this.pgs.PROGRAM_IDS.TRANSFER_HOOK;
 
-        return this.program.methods
+        return program.methods
             .purchase(new BN(amountLamports.toString()))
             .accounts({
                 user: a.user,
@@ -147,6 +151,12 @@ export class TokenClient {
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
                 systemProgram: SystemProgram.programId,
+
+                pretokenPurchaseHistory: a.pretokenPurchaseHistory,
+
+                globalConfig: a.globalConfig,
+                oppEpochState: a.oppEpochState, 
+                pendingAttestations: a.pendingAttestations
             })
             .instruction();
     }
@@ -177,8 +187,9 @@ export class TokenClient {
      * Uses the ring-buffer semantics from capital-staking.
      */
     async getSolPriceUsd(): Promise<bigint> {
-        const priceHistoryPda = derivePriceHistoryPda();
-        const history = (await this.program.account.priceHistory.fetch(
+        const program: any = this.program;
+        const priceHistoryPda = this.pgs.derivePriceHistoryPda();
+        const history = (await program.account.priceHistory.fetch(
             priceHistoryPda,
         )) as PriceHistory;
 
@@ -206,4 +217,4 @@ export class TokenClient {
 
         return BigInt(latest.toString());
     }
-}
+}