@wireio/stake 2.7.3 → 3.0.0

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

@@ -1,4 +1,4 @@
-import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import { AnchorProvider, BN } from '@coral-xyz/anchor';
 import {
     PublicKey,
     SystemProgram,
@@ -9,8 +9,6 @@ import {
     TOKEN_2022_PROGRAM_ID,
 } from '@solana/spl-token';
 
-import { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
-
 import {
     OutpostAccounts,
     buildOutpostAccounts,
@@ -18,13 +16,52 @@ import {
 } from '../utils';
 
 import {
+    DistributionState,
+    GlobalState,
+    OutpostAccount,
     OutpostWireStateSnapshot,
     SharesPreview,
     TrancheState,
+    UserPretokenRecord,
     WalletLike,
 } from '../types';
 import { INDEX_SCALE } from '../constants';
-import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
+import { SolanaProgramService } from '../program';
+
+export function buildSolanaSyndicateAccounts(params: {
+    user: PublicKey;
+    accounts: OutpostAccounts;
+    liqsolCoreProgram: PublicKey;
+    transferHookProgram: PublicKey;
+}) {
+    const { user, accounts, liqsolCoreProgram, transferHookProgram } = params;
+
+    return {
+        user,
+        liqsolMint: accounts.liqsolMint,
+        distributionState: accounts.distributionState,
+        globalState: accounts.globalState,
+        userAta: accounts.userAta,
+        senderUserRecord: accounts.userUserRecord,
+        bridgeAuthority: accounts.bridgeAuthority,
+        bridgeVaultAta: accounts.bridgeVaultAta,
+        bridgeUserRecord: accounts.bridgeUserRecord,
+        bridgeState: accounts.bridgeState,
+        outpostAccount: accounts.outpostAccount,
+        extraAccountMetaList: accounts.extraAccountMetaList,
+        liqsolCoreProgram,
+        transferHookProgram,
+        bucketAuthority: accounts.bucketAuthority,
+        bucketTokenAccount: accounts.bucketTokenAccount,
+        bucketUserRecord: accounts.bucketUserRecord,
+        tokenProgram: TOKEN_2022_PROGRAM_ID,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId,
+        globalConfig: accounts.globalConfig,
+        oppEpochState: accounts.oppEpochState,
+        pendingAttestations: accounts.pendingAttestations,
+    };
+}
 
 /**
  * OutpostClient
@@ -42,7 +79,7 @@ import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
  * in sync with the on-chain PDAs and capital-staking Wire utils.
  */
 export class OutpostClient {
-    private readonly program: Program<LiqsolCoreClientIdl>;
+    private readonly program: any;
 
     constructor(
         private readonly provider: AnchorProvider,
@@ -75,8 +112,26 @@ 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);
+        try {
+            const bal = await this.connection.getTokenAccountBalance(ata);
+            return new BN(bal.value.amount);
+        } catch (error) {
+            if (this.isMissingTokenAccountError(error)) {
+                return new BN(0);
+            }
+            throw error;
+        }
+    }
+
+    private isMissingTokenAccountError(error: unknown): boolean {
+        const message = String(
+            (error as { message?: string } | null)?.message ?? '',
+        ).toLowerCase();
+
+        return (
+            message.includes('failed to get token account balance') &&
+            message.includes('could not find account')
+        );
     }
 
     /**
@@ -87,8 +142,9 @@ export class OutpostClient {
      * coder decode the padded buffer.
      */
     private async fetchOutpostAccount(address: PublicKey) {
+        const program = this.program;
         try {
-            return await this.program.account.outpostAccount.fetchNullable(address);
+            return await program.account.outpostAccount.fetchNullable(address);
         } catch (e) {
             if (!(e instanceof RangeError)) throw e;
 
@@ -102,7 +158,7 @@ export class OutpostClient {
             info.data.copy(padded);
             // trailing bytes are already 0x00 → Option::None for each field
 
-            return this.program.coder.accounts.decode(
+            return program.coder.accounts.decode(
                 'outpostAccount',
                 padded,
             );
@@ -113,6 +169,7 @@ export class OutpostClient {
      * Fetch the core "Wire state" for Outpost / pretokens for a given user.
      */
     async fetchWireState(user?: PublicKey): Promise<OutpostWireStateSnapshot> {
+        const program = this.program;
         const userPk = user ?? this.wallet.publicKey;
         if (!userPk) throw new Error('OutpostClient.fetchWireState: wallet not connected');
 
@@ -126,21 +183,21 @@ export class OutpostClient {
             liqsolPoolBalance,
             userLiqsolBalance,
         ] = await Promise.all([
-            safeFetch(this.program.account.globalState.fetch(pdas.globalState), 'globalState'),
+            safeFetch(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(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'),
         ]);
 
         return {
-            globalState,
-            outpostAccount,
-            distributionState,
-            trancheState,
-            userPretokenRecord,
+            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,
         };
@@ -149,58 +206,61 @@ export class OutpostClient {
 
 
     // -------------------------------------------------------------------------
-    // 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 = this.wallet.publicKey,
+        wireAccount?: string,
     ): Promise<TransactionInstruction> {
+        const program = 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(user);
 
-        return this.program.methods
-            .synd(new BN(amountLamports.toString()))
-            .accounts({
-                user,
-                liqsolMint: a.liqsolMint,
-                globalState: a.globalState,
-                distributionState: a.distributionState,
-                userAta: a.userAta,
-                poolAuthority: a.poolAuthority,
-                bucketAuthority: a.bucketAuthority,
-                bucketTokenAccount: a.bucketTokenAccount,
-                bucketUserRecord: a.bucketUserRecord,
-                senderUserRecord: a.userUserRecord,
-                receiverUserRecord: a.liqsolPoolUserRecord,
-                extraAccountMetaList: a.extraAccountMetaList,
-                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,
-                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-                systemProgram: SystemProgram.programId,
-                pretokenPurchaseHistory: a.pretokenPurchaseHistory,
-            })
+        return program.methods
+            .syndicateLiqsolToWire(wireAccount.trim(), new BN(amountLamports.toString()))
+            .accounts(
+                buildSolanaSyndicateAccounts({
+                    user,
+                    accounts: a,
+                    liqsolCoreProgram: this.pgs.PROGRAM_IDS.LIQSOL_CORE,
+                    transferHookProgram: this.pgs.PROGRAM_IDS.TRANSFER_HOOK,
+                }),
+            )
             .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 = this.program;
         const userPk = user ?? this.wallet.publicKey;
         if (!userPk) {
             throw new Error('OutpostClient.buildUnstakeIx: wallet not connected');
@@ -208,7 +268,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,
@@ -230,6 +290,9 @@ export class OutpostClient {
                 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();

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

@@ -1,4 +1,4 @@
-import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import { AnchorProvider, BN } from '@coral-xyz/anchor';
 import type { TransactionInstruction, Connection } from '@solana/web3.js';
 import { PublicKey, SystemProgram } from '@solana/web3.js';
 import {
@@ -11,8 +11,7 @@ import {
     type OutpostAccounts,
 } from '../utils';
 
-import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
-import type { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
+import { SolanaProgramService } from '../program';
 
 import {
     GlobalState,
@@ -29,7 +28,7 @@ import {
 } from '../constants';
 
 export class TokenClient {
-    private readonly program: Program<LiqsolCoreClientIdl>;
+    private readonly program: any;
 
     get wallet(): WalletLike {
         return this.provider.wallet;
@@ -55,13 +54,15 @@ export class TokenClient {
     }
 
     async fetchGlobalState(): Promise<GlobalState> {
+        const program = 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 = this.program;
         const { trancheState } = await this.getAccounts(this.wallet.publicKey);
-        return this.program.account.trancheState.fetch(trancheState);
+        return program.account.trancheState.fetch(trancheState);
     }
 
     /**
@@ -69,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 = this.program;
         const { outpostAccount } = await this.getAccounts(user);
-        return this.program.account.outpostAccount.fetchNullable(outpostAccount);
+        return program.account.outpostAccount.fetchNullable(outpostAccount);
     }
 
     /**
@@ -80,8 +82,9 @@ export class TokenClient {
     async fetchUserPretokenRecord(
         user: PublicKey,
     ): Promise<UserPretokenRecord | null> {
+        const program = this.program;
         const { userPretokenRecord } = await this.getAccounts(user);
-        return this.program.account.userPretokenRecord.fetchNullable(
+        return program.account.userPretokenRecord.fetchNullable(
             userPretokenRecord,
         );
     }
@@ -100,6 +103,7 @@ export class TokenClient {
         amountLamports: bigint,
         user = this.wallet.publicKey,
     ): Promise<TransactionInstruction> {
+        const program = this.program;
         console.log('build purchase for', user.toBase58());
         
         const a = await this.getAccounts(user);
@@ -108,7 +112,7 @@ export class TokenClient {
         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,
@@ -149,6 +153,10 @@ export class TokenClient {
                 systemProgram: SystemProgram.programId,
 
                 pretokenPurchaseHistory: a.pretokenPurchaseHistory,
+
+                globalConfig: a.globalConfig,
+                oppEpochState: a.oppEpochState, 
+                pendingAttestations: a.pendingAttestations
             })
             .instruction();
     }
@@ -179,8 +187,9 @@ export class TokenClient {
      * Uses the ring-buffer semantics from capital-staking.
      */
     async getSolPriceUsd(): Promise<bigint> {
+        const program = this.program;
         const priceHistoryPda = this.pgs.derivePriceHistoryPda();
-        const history = (await this.program.account.priceHistory.fetch(
+        const history = (await program.account.priceHistory.fetch(
             priceHistoryPda,
         )) as PriceHistory;
 
@@ -208,4 +217,4 @@ export class TokenClient {
 
         return BigInt(latest.toString());
     }
-}
+}

package/src/networks/solana/constants.ts

@@ -1,6 +1,6 @@
 // src/networks/solana/constants.ts
+import { ChainID, SolChainID } from '@wireio/core';
 import { PublicKey, StakeProgram } from '@solana/web3.js';
-import { SolChainID } from '@wireio/core';
 
 import mainnetLiqsolCoreIDL from '../../assets/solana/mainnet/idl/liqsol_core.json';
 import mainnetLiqSolTokenIDL from '../../assets/solana/mainnet/idl/liqsol_token.json';
@@ -11,7 +11,11 @@ import devnetLiqsolCoreIDL from '../../assets/solana/devnet/idl/liqsol_core.json
 import devnetLiqSolTokenIDL from '../../assets/solana/devnet/idl/liqsol_token.json';
 import devnetValidatorLeaderboardIDL from '../../assets/solana/devnet/idl/validator_leaderboard.json';
 import devnetTransferHookIDL from '../../assets/solana/devnet/idl/transfer_hook.json';
-import { SupportedSolChainID } from '../../types';
+import wiredevLiqsolCoreIDL from '../../assets/solana/wiredev/idl/liqsol_core.json';
+import wiredevLiqSolTokenIDL from '../../assets/solana/wiredev/idl/liqsol_token.json';
+import wiredevValidatorLeaderboardIDL from '../../assets/solana/wiredev/idl/validator_leaderboard.json';
+import wiredevTransferHookIDL from '../../assets/solana/wiredev/idl/transfer_hook.json';
+import { SOL_WIRE_DEVNET_CHAIN_ID, type SupportedSolProgramChainID } from '../../chains';
 
 /**
  * Per-chain program IDs (NOT global anymore).
@@ -37,16 +41,25 @@ const DEVNET_PROGRAM_IDS: SolanaProgramIds = {
     LIQSOL_TOKEN: new PublicKey(devnetLiqSolTokenIDL.address),
     VALIDATOR_LEADERBOARD: new PublicKey(devnetValidatorLeaderboardIDL.address),
     TRANSFER_HOOK: new PublicKey(devnetTransferHookIDL.address),
-    ALT: new PublicKey("AZQmTbacBuAsJpncg2N2AwcZsLG1Sxeohbau9vjezmTz")
+    ALT: new PublicKey("9WhQt82Ym5LDDaGEB6eV86MUV6BtUxZQbw1R4uuhVPSt")
 };
 
-export const PROGRAM_IDS_BY_CHAIN: Record<SupportedSolChainID, SolanaProgramIds> = {
+const WIREDEV_PROGRAM_IDS: SolanaProgramIds = {
+    LIQSOL_CORE: new PublicKey(wiredevLiqsolCoreIDL.address),
+    LIQSOL_TOKEN: new PublicKey(wiredevLiqSolTokenIDL.address),
+    VALIDATOR_LEADERBOARD: new PublicKey(wiredevValidatorLeaderboardIDL.address),
+    TRANSFER_HOOK: new PublicKey(wiredevTransferHookIDL.address),
+    ALT: new PublicKey("9WhQt82Ym5LDDaGEB6eV86MUV6BtUxZQbw1R4uuhVPSt")
+};
+
+export const PROGRAM_IDS_BY_CHAIN: Record<SupportedSolProgramChainID, SolanaProgramIds> = {
     [SolChainID.Mainnet]: MAINNET_PROGRAM_IDS,
     [SolChainID.Devnet]: DEVNET_PROGRAM_IDS,
+    [SOL_WIRE_DEVNET_CHAIN_ID]: WIREDEV_PROGRAM_IDS,
 };
 
-export const getProgramIds = (chainId: SolChainID): SolanaProgramIds => {
-    const ids = PROGRAM_IDS_BY_CHAIN[chainId];
+export const getProgramIds = (chainId: ChainID | string): SolanaProgramIds => {
+    const ids = PROGRAM_IDS_BY_CHAIN[chainId as SupportedSolProgramChainID];
     if (!ids) throw new Error(`Unsupported Solana chainId=${chainId}`);
     return ids;
 };
@@ -112,6 +125,13 @@ export const PDA_SEEDS = {
 
     // New
     PRETOKEN_PURCHASE_HISTORY: 'pretoken_purchase_history',
+
+    // OPP (outpost protocol pipeline)
+    OPP_EPOCH_STATE: 'opp_epoch_state',
+    PENDING_ATTESTATIONS: 'pending_attestations',
+    EPOCH_HEADER: 'epoch_header',
+    EPOCH_MESSAGE: 'epoch_message',
+    OPP_BRIDGE_STATE: 'opp_bridge_state',
 } as const;
 
 /**
@@ -153,4 +173,4 @@ export const lamportsToSol = (lamports: number | bigint): number =>
     Number(lamports) / LAMPORTS_PER_SOL;
 
 export const solToLamports = (sol: number): bigint =>
-    BigInt(Math.round(sol * LAMPORTS_PER_SOL));
+    BigInt(Math.round(sol * LAMPORTS_PER_SOL));

package/src/networks/solana/program.ts

@@ -1,13 +1,14 @@
 // src/networks/solana/programs.ts
 import { AnchorProvider, Program } from '@coral-xyz/anchor';
 import { ChainID, SolChainID } from '@wireio/core';
-import { PublicKey, StakeProgram } from '@solana/web3.js';
+import { Connection, PublicKey, StakeProgram } from '@solana/web3.js';
 
 import {
     PDA_SEEDS,
     getProgramIds,
     SolanaProgramIds,
 } from './constants';
+import { SOL_WIRE_DEVNET_CHAIN_ID } from '../../chains';
 
 // Mainnet IDLs
 import liqsolCoreMainnetJson from '../../assets/solana/mainnet/idl/liqsol_core.json';
@@ -18,6 +19,9 @@ import validatorLeaderboardMainnetJson from '../../assets/solana/mainnet/idl/val
 import liqsolCoreDevnetJson from '../../assets/solana/devnet/idl/liqsol_core.json';
 import liqsolTokenDevnetJson from '../../assets/solana/devnet/idl/liqsol_token.json';
 import validatorLeaderboardDevnetJson from '../../assets/solana/devnet/idl/validator_leaderboard.json';
+import liqsolCoreWiredevJson from '../../assets/solana/wiredev/idl/liqsol_core.json';
+import liqsolTokenWiredevJson from '../../assets/solana/wiredev/idl/liqsol_token.json';
+import validatorLeaderboardWiredevJson from '../../assets/solana/wiredev/idl/validator_leaderboard.json';
 
 // Mainnet types
 import type { LiqsolCore as LiqSolCoreMainnet } from '../../assets/solana/mainnet/types/liqsol_core';
@@ -28,17 +32,19 @@ import type { ValidatorLeaderboard as ValidatorLeaderboardMainnet } from '../../
 import type { LiqsolCore as LiqSolCoreDevnet } from '../../assets/solana/devnet/types/liqsol_core';
 import type { LiqsolToken as LiqsolTokenDevnet } from '../../assets/solana/devnet/types/liqsol_token';
 import type { ValidatorLeaderboard as ValidatorLeaderboardDevnet } from '../../assets/solana/devnet/types/validator_leaderboard';
+import type { LiqsolCore as LiqSolCoreWiredev } from '../../assets/solana/wiredev/types/liqsol_core';
+import type { LiqsolToken as LiqsolTokenWiredev } from '../../assets/solana/wiredev/types/liqsol_token';
+import type { ValidatorLeaderboard as ValidatorLeaderboardWiredev } from '../../assets/solana/wiredev/types/validator_leaderboard';
 
-// “Client” IDLs = mainnet OR devnet, plus `address` field we add at runtime
+// Anchor's generated Program<T> type becomes excessively deep once the same
+// client can select among mainnet, public devnet, and Wire devnet IDLs. Keep the
+// runtime IDL selection strict and expose a shallow client IDL type at this
+// boundary.
+type ClientIdl = any;
 
-export type LiqsolCoreClientIdl =
-    (LiqSolCoreMainnet | LiqSolCoreDevnet) & { address: string };
-
-export type LiqsolTokenClientIdl =
-    (LiqsolTokenMainnet | LiqsolTokenDevnet) & { address: string };
-
-export type ValidatorLeaderboardClientIdl =
-    (ValidatorLeaderboardMainnet | ValidatorLeaderboardDevnet) & { address: string };
+export type LiqsolCoreClientIdl = ClientIdl;
+export type LiqsolTokenClientIdl = ClientIdl;
+export type ValidatorLeaderboardClientIdl = ClientIdl;
 
 export type SolanaProgramIdlMap = {
     liqsolCore: LiqsolCoreClientIdl;
@@ -82,17 +88,33 @@ const PROGRAMS_BY_CHAIN = {
             address: validatorLeaderboardDevnetJson.address,
         } as Entry<ValidatorLeaderboardDevnet>,
     },
+    [SOL_WIRE_DEVNET_CHAIN_ID]: {
+        liqsolCore: {
+            idl: liqsolCoreWiredevJson,
+            address: liqsolCoreWiredevJson.address,
+        } as Entry<LiqSolCoreWiredev>,
+        liqsolToken: {
+            idl: liqsolTokenWiredevJson,
+            address: liqsolTokenWiredevJson.address,
+        } as Entry<LiqsolTokenWiredev>,
+        validatorLeaderboard: {
+            idl: validatorLeaderboardWiredevJson,
+            address: validatorLeaderboardWiredevJson.address,
+        } as Entry<ValidatorLeaderboardWiredev>,
+    },
 } as const;
 
+type SolanaProgramEntries = (typeof PROGRAMS_BY_CHAIN)[keyof typeof PROGRAMS_BY_CHAIN];
+
 export class SolanaProgramService {
     private readonly ids: SolanaProgramIds;
-    private readonly programs: (typeof PROGRAMS_BY_CHAIN)[SolChainID.Mainnet];
+    private readonly programs: SolanaProgramEntries;
 
     constructor(
         private provider: AnchorProvider,
         private chainId: ChainID,
     ) {
-        const solChain = chainId as SolChainID;
+        const solChain = chainId as keyof typeof PROGRAMS_BY_CHAIN;
         this.ids = getProgramIds(solChain);
         const programs = PROGRAMS_BY_CHAIN[solChain];
         if (!programs) {
@@ -106,14 +128,14 @@ export class SolanaProgramService {
         return this.ids;
     }
 
-    // Generic getProgram, typed by name → union IDL
-    getProgram<K extends SolanaProgramName>(
-        name: K,
-    ): Program<SolanaProgramIdlMap[K]> {
+    // Anchor's fluent builder types are intentionally erased here. The SDK
+    // performs dynamic IDL selection by chain, and callers keep their runtime
+    // account/method wiring unchanged.
+    getProgram(name: SolanaProgramName): any {
         const { idl, address } = this.programs[name];
-        const idlWithAddr = { ...(idl as any), address } as SolanaProgramIdlMap[K];
+        const idlWithAddr = { ...(idl as any), address };
 
-        return new Program(idlWithAddr, this.provider) as Program<SolanaProgramIdlMap[K]>;
+        return new Program(idlWithAddr, this.provider) as any;
     }
 
     listProgramNames(): SolanaProgramName[] {
@@ -383,6 +405,69 @@ export class SolanaProgramService {
         )[0];
     }
 
+    // --- OPP (outpost protocol pipeline) ---
+
+    deriveOppEpochStatePda(): PublicKey {
+        return PublicKey.findProgramAddressSync(
+            [Buffer.from(PDA_SEEDS.OPP_EPOCH_STATE)],
+            this.ids.LIQSOL_CORE,
+        )[0];
+    }
+
+    derivePendingAttestationsPda(epochNumber: number): PublicKey {
+        const epochBuf = Buffer.alloc(4);
+        epochBuf.writeUInt32LE(epochNumber, 0);
+        return PublicKey.findProgramAddressSync(
+            [Buffer.from(PDA_SEEDS.PENDING_ATTESTATIONS), epochBuf],
+            this.ids.LIQSOL_CORE,
+        )[0];
+    }
+
+    deriveEpochHeaderPda(epochNumber: number): PublicKey {
+        const epochBuf = Buffer.alloc(4);
+        epochBuf.writeUInt32LE(epochNumber, 0);
+        return PublicKey.findProgramAddressSync(
+            [Buffer.from(PDA_SEEDS.EPOCH_HEADER), epochBuf],
+            this.ids.LIQSOL_CORE,
+        )[0];
+    }
+
+    deriveEpochMessagePda(epochNumber: number, messageIndex: number): PublicKey {
+        const epochBuf = Buffer.alloc(4);
+        epochBuf.writeUInt32LE(epochNumber, 0);
+        const indexBuf = Buffer.alloc(4);
+        indexBuf.writeUInt32LE(messageIndex, 0);
+        return PublicKey.findProgramAddressSync(
+            [Buffer.from(PDA_SEEDS.EPOCH_MESSAGE), epochBuf, indexBuf],
+            this.ids.LIQSOL_CORE,
+        )[0];
+    }
+
+    /**
+     * Fetch the current OPP epoch number from the on-chain OppEpochState account.
+     *
+     * Layout (after 8-byte Anchor discriminator):
+     *   [u32 nextEpochNumber] — little-endian
+     *
+     * This is used to derive the `pending_attestations` PDA for synd / desynd.
+     */
+    async fetchOppEpochNumber(connection: Connection): Promise<number> {
+        const pda = this.deriveOppEpochStatePda();
+        const info = await connection.getAccountInfo(pda);
+        if (!info?.data) {
+            throw new Error(`OPP epoch state account not found: ${pda.toBase58()}`);
+        }
+        // Skip 8-byte Anchor discriminator; nextEpochNumber is the first u32 field.
+        return Buffer.from(info.data).readUInt32LE(8);
+    }
+
+    deriveOppBridgeStatePda(): PublicKey {
+        return PublicKey.findProgramAddressSync(
+            [Buffer.from(PDA_SEEDS.OPP_BRIDGE_STATE)],
+            this.ids.LIQSOL_CORE,
+        )[0];
+    }
+
     // --- Transfer-hook extra metas ---
 
     deriveExtraAccountMetaListPda(liqsolMint: PublicKey): PublicKey {
@@ -405,4 +490,4 @@ export class SolanaProgramService {
         const seedStr = `ephemeral_${seed}`;
         return PublicKey.createWithSeed(user, seedStr, StakeProgram.programId);
     }
-}
+}