@wireio/stake 1.0.1 → 1.0.69

package/src/networks/solana/types.ts

@@ -11,8 +11,8 @@ export type SolanaTransaction = Transaction | VersionedTransaction;
 
 export type WalletLike = {
     publicKey: PublicKey;
-    signTransaction: (tx: Transaction) => Promise<Transaction>;
-    signAllTransactions?: (txs: Transaction[]) => Promise<Transaction[]>;
+    signTransaction: <T extends SolanaTransaction>(tx: T) => Promise<T>;
+    signAllTransactions?: <T extends SolanaTransaction>(txs: T[]) => Promise<T[]>;
 };
 
 export type ParsedAccountInfo = {
@@ -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;
 };
 
 /**
@@ -238,10 +242,10 @@ export type GlobalState = {
     currentIndex: BN;
 
     /**
-     * Last observed liqSOL pool balance
-     * used for computing incremental yield.
+     * Replaced legacy `lastPoolLiqsolBalance`
+     * with expected balance based on total shares and current index.
      */
-    lastPoolLiqsolBalance: BN;
+    expectedPoolBalance: BN;
 
     /**
      * Accumulated liqSOL yield available to the protocol
@@ -262,7 +266,7 @@ export type GlobalState = {
     roleWarmupDuration: BN;
 
     /** Wire lifecycle state (preLaunch / postLaunch / refund) */
-    wireState: WireState;
+    wireState: WireState | any;
 
     /** PDA bump */
     bump: number;
@@ -615,7 +619,7 @@ export type LeaderboardState = {
      * Per-validator scores (i64 on-chain).
      * Index corresponds to `registryIndex` in ValidatorRecord.
      */
-    scores: BN[];
+    scores: number[];
 
     /**
      * Sorted indices into `scores[]` / `voteAccounts[]`,
@@ -628,7 +632,7 @@ export type LeaderboardState = {
      * `voteAccounts[i]` is the vote account for validator with
      * `registryIndex == i`.
      */
-    voteAccounts: PublicKey[];
+    voteAccounts: { bytes: number[]; }[];
 
     /**
      * Number of active validators currently tracked in the leaderboard.
@@ -643,7 +647,7 @@ export type LeaderboardState = {
      * Reserved padding / future-proofing on-chain (u64[8]).
      * Not used by client logic, but surfaced for completeness.
      */
-    padding: BN[];
+    padding: number[];
 };
 
 /**
@@ -728,4 +732,26 @@ export type ValidatorRecord = {
      * PDA bump seed for validatorRecord.
      */
     bump: number;
-};
+};
+
+/**
+ * IDL: `receiptData`
+ *
+ * Withdrawal receipt data structure tracking pending withdrawals.
+ * Each receipt represents a user's request to withdraw liqSOL,
+ * with the withdrawal contingent on sufficient encumbered funds
+ * being available at the serviceable epoch.
+ */
+export type ReceiptData = {
+    /** Unique receipt identifier (monotonically increasing, u64) */
+    receiptId: bigint;
+
+    /** Amount of liqSOL requested for withdrawal (Token-2022 raw amount, u64) */
+    liqports: bigint;
+
+    /** Epoch at which this receipt becomes claimable (u64) */
+    epoch: bigint;
+
+    /** Flag indicating whether this receipt has been fulfilled/claimed (bool) */
+    fulfilled: boolean;
+};

package/src/networks/solana/utils.ts

@@ -1,56 +1,27 @@
 import { Program, BN, AnchorProvider } from '@coral-xyz/anchor';
-
 import {
     Connection,
     Keypair,
     PublicKey,
-    SystemProgram,
-    StakeProgram,
 } from '@solana/web3.js';
 import {
     TOKEN_2022_PROGRAM_ID,
-    ASSOCIATED_TOKEN_PROGRAM_ID,
     getAssociatedTokenAddress,
 } from '@solana/spl-token';
 
 import {
-    LIQSOL_CORE,
-    LIQSOL_TOKEN,
-    PAY_RATE_SCALE_FACTOR,
     DEFAULT_AVERAGE_PAY_RATE,
     EPHEMERAL_RENT_EXEMPTION,
-    LAMPORTS_PER_SOL,
-    lamportsToSol,
     solToLamports,
-    deriveDepositAuthorityPda,
-    deriveLiqsolMintPda,
-    deriveLiqsolMintAuthorityPda,
-    deriveVaultPda,
-    deriveReservePoolPda,
-    deriveStakeControllerStatePda,
-    derivePayoutStatePda,
-    deriveBucketAuthorityPda,
-    deriveDistributionStatePda,
-    deriveUserRecordPda,
-    derivePayRateHistoryPda,
-    deriveStakeControllerVaultPda,
-    deriveEphemeralStakeAddress,
     DEFAULT_PAY_RATE_LOOKBACK,
-    deriveOutpostGlobalStatePda,
-    deriveOutpostPoolAuthorityPda,
-    deriveOutpostAccountPda,
-    deriveTrancheStatePda,
-    deriveUserPretokenRecordPda,
     CHAINLINK_FEED,
     CHAINLINK_PROGRAM,
-    deriveExtraAccountMetaListPda,
 } from './constants';
 
-import liqsolCoreIDL from '../../assets/solana/idl/liqsol_core.json';
-import { LiqsolCore } from '../../assets/solana/types/liqsol_core';
 import { GlobalState, TrancheState } from './types';
 import { TrancheLadderItem, TrancheSnapshot } from '../../types';
 import { ChainID } from '@wireio/core';
+import { SolanaProgramService } from './program';
 
 // -----------------------------------------------------------------------------
 // Tranche Support
@@ -268,265 +239,6 @@ export function buildSolanaTrancheSnapshot(options: {
     };
 }
 
-
-// -----------------------------------------------------------------------------
-// Read-only liqsol_core Program helper
-// -----------------------------------------------------------------------------
-
-let _liqsolCoreProgram: Program<LiqsolCore> | null = null;
-
-export function getLiqsolCoreProgram(
-    connection: Connection,
-): Program<LiqsolCore> {
-    if (_liqsolCoreProgram && _liqsolCoreProgram.provider.connection === connection) {
-        return _liqsolCoreProgram;
-    }
-
-    // Dummy wallet – we're only doing read-only account fetches here.
-    const tmpKeypair = Keypair.generate();
-    const wallet: any = {
-        publicKey: tmpKeypair.publicKey,
-        signAllTransactions: async () => [],
-        signTransaction: async () => tmpKeypair,
-    };
-
-    const provider = new AnchorProvider(connection, wallet, {
-        commitment: 'confirmed',
-    });
-
-    const program = new Program(
-        liqsolCoreIDL,
-        provider,
-    ) as Program<LiqsolCore>;
-
-    _liqsolCoreProgram = program;
-    return program;
-}
-
-
-// -----------------------------------------------------------------------------
-// Balance + state getters (UI-friendly)
-// -----------------------------------------------------------------------------
-
-export async function getUserLiqSolBalance(
-    connection: Connection,
-    user: PublicKey,
-): Promise<number> {
-    const liqsolMint = deriveLiqsolMintPda();
-    const ata = await getAssociatedTokenAddress(
-        liqsolMint,
-        user,
-        false,
-        TOKEN_2022_PROGRAM_ID,
-    );
-
-    try {
-        const bal = await connection.getTokenAccountBalance(ata);
-        return Number(bal.value.amount); // raw lamports, not decimals-adjusted
-    } catch {
-        return 0;
-    }
-}
-
-export async function getBucketLiqSolBalance(
-    connection: Connection,
-): Promise<number> {
-    const liqsolMint = deriveLiqsolMintPda();
-    const bucketAuthority = deriveBucketAuthorityPda();
-    const ata = await getAssociatedTokenAddress(
-        liqsolMint,
-        bucketAuthority,
-        true,
-        TOKEN_2022_PROGRAM_ID,
-    );
-
-    try {
-        const bal = await connection.getTokenAccountBalance(ata);
-        return Number(bal.value.amount);
-    } catch {
-        return 0;
-    }
-}
-
-export async function getReservePoolBalance(
-    connection: Connection,
-): Promise<number> {
-    const reservePool = deriveReservePoolPda();
-    try {
-        const lamports = await connection.getBalance(reservePool);
-        return lamports;
-    } catch {
-        return 0;
-    }
-}
-
-/**
- * Raw account info for the stake_controller state (Anchor decode is left
- * to the caller so the SDK can stay IDL-agnostic at this layer).
- */
-export async function getStakeControllerStateRaw(
-    connection: Connection,
-): Promise<Uint8Array | null> {
-    const pda = deriveStakeControllerStatePda();
-    const info = await connection.getAccountInfo(pda);
-    return info?.data ?? null;
-}
-
-/**
- * Raw account info for the payout-state account.
- */
-export async function getPayoutStateRaw(
-    connection: Connection,
-): Promise<Uint8Array | null> {
-    const pda = derivePayoutStatePda();
-    const info = await connection.getAccountInfo(pda);
-    return info?.data ?? null;
-}
-
-/**
- * Raw account info for a user's distribution user_record.
- *
- * NOTE: user_record is keyed by the TOKEN ACCOUNT (ATA), not the wallet.
- * Here we derive the user's liqSOL ATA and then its user_record PDA.
- */
-export async function getUserRecordRaw(
-    connection: Connection,
-    user: PublicKey,
-): Promise<Uint8Array | null> {
-    const liqsolMint = deriveLiqsolMintPda();
-    const userAta = await getAssociatedTokenAddress(
-        liqsolMint,
-        user,
-        false,
-        TOKEN_2022_PROGRAM_ID,
-    );
-    const pda = deriveUserRecordPda(userAta);
-    const info = await connection.getAccountInfo(pda);
-    return info?.data ?? null;
-}
-
-
-// -----------------------------------------------------------------------------
-// Pay-rate & fee utilities (on-chain compatible)
-// -----------------------------------------------------------------------------
-
-export async function getAveragePayRate(
-    connection: Connection,
-    lookback: number = DEFAULT_PAY_RATE_LOOKBACK,
-): Promise<bigint> {
-    const program = getLiqsolCoreProgram(connection);
-    const payRateHistoryPda = derivePayRateHistoryPda();
-
-    try {
-        const anyProgram = program;
-        const payRateHistoryAccount = await anyProgram.account.payRateHistory.fetch(
-            payRateHistoryPda,
-        );
-
-        const entries = payRateHistoryAccount.entries ?? [];
-        const totalEntriesAdded = Number(
-            payRateHistoryAccount.totalEntriesAdded ?? 0,
-        );
-        const currentIndex: number = payRateHistoryAccount.currentIndex ?? 0;
-        const maxEntries: number =
-            payRateHistoryAccount.maxEntries ?? entries.length;
-
-        if (!entries.length) {
-            return DEFAULT_AVERAGE_PAY_RATE;
-        }
-
-        const entriesToFetch = Math.min(lookback, maxEntries, entries.length);
-
-        let idx: number;
-        if (totalEntriesAdded === 0) {
-            idx = 0;
-        } else if (currentIndex === 0) {
-            idx = maxEntries - 1;
-        } else {
-            idx = currentIndex - 1;
-        }
-
-        let sum = BigInt(0);
-        let validCount = BigInt(0);
-
-        for (let i = 0; i < entriesToFetch; i++) {
-            const entry = entries[idx];
-            if (entry && typeof entry.scaledRate !== 'undefined') {
-                const rate = BigInt(entry.scaledRate.toString());
-                if (rate > BigInt(0)) {
-                    sum += rate;
-                    validCount += BigInt(1);
-                }
-            }
-
-            if (totalEntriesAdded === 0) {
-                idx = (idx + 1) % maxEntries;
-            } else {
-                idx = idx === 0 ? maxEntries - 1 : idx - 1;
-            }
-        }
-
-        if (validCount === BigInt(0)) {
-            return DEFAULT_AVERAGE_PAY_RATE;
-        }
-
-        return sum / validCount;
-    } catch (err) {
-        // Fallback to default when history missing/unavailable
-        return DEFAULT_AVERAGE_PAY_RATE;
-    }
-}
-
-/**
- * On-chain fee formula:
- *   fee = (average_pay_rate * 4 * deposit_amount_lamports) / 10^12
- */
-export function calculateExpectedFee(
-    depositAmountLamports: BN,
-    averagePayRate: BN,
-): BN {
-    return averagePayRate
-        .mul(new BN(4))
-        .mul(depositAmountLamports)
-        .div(new BN(1_000_000_000_000)); // 10^12
-}
-
-/**
- * Convenience helper to preview how a deposit splits between user + bucket
- * and how much goes into the reserve, assuming the simple model:
- *
- * - userLiqSol = amount - fee + EPHEMERAL_RENT_EXEMPTION
- * - bucketLiqSol = fee
- * - reserveLamports = amount + EPHEMERAL_RENT_EXEMPTION
- */
-export function previewDepositEffects(params: {
-    depositAmountLamports: BN;
-    averagePayRate: BN;
-    rentExemptionLamports?: number;
-}): {
-    feeLamports: BN;
-    userLiqSolLamports: BN;
-    bucketLiqSolLamports: BN;
-    reserveIncreaseLamports: BN;
-} {
-    const { depositAmountLamports, averagePayRate } = params;
-    const rent = new BN(
-        params.rentExemptionLamports ?? EPHEMERAL_RENT_EXEMPTION,
-    );
-
-    const fee = calculateExpectedFee(depositAmountLamports, averagePayRate);
-    const userLiqSol = depositAmountLamports.sub(fee).add(rent);
-    const bucketLiqSol = fee;
-    const reserveIncrease = depositAmountLamports.add(rent);
-
-    return {
-        feeLamports: fee,
-        userLiqSolLamports: userLiqSol,
-        bucketLiqSolLamports: bucketLiqSol,
-        reserveIncreaseLamports: reserveIncrease,
-    };
-}
-
 /**
  * ---------------------------------------------------------------------------
  * Outpost-specific helpers
@@ -564,22 +276,35 @@ export interface OutpostAccounts {
 
     // Transfer hook extra accounts
     extraAccountMetaList: PublicKey;
+
+    // New
+    pretokenPurchaseHistory: PublicKey;
+
+    // OPP (outpost protocol pipeline)
+    globalConfig: PublicKey;
+    oppEpochState: PublicKey;
+    pendingAttestations: PublicKey;
+    bridgeState: PublicKey;
+    bridgeAuthority: PublicKey;
+    bridgeVaultAta: PublicKey;
+    bridgeUserRecord: PublicKey;
 }
 
 export async function buildOutpostAccounts(
     connection: Connection,
     user: PublicKey,
+    pgs: SolanaProgramService,
 ): Promise<OutpostAccounts> {
-    const globalState = deriveOutpostGlobalStatePda();
-    const poolAuthority = deriveOutpostPoolAuthorityPda();
-    const liqsolMint = deriveLiqsolMintPda();
-    const distributionState = deriveDistributionStatePda();
-    const bucketAuthority = deriveBucketAuthorityPda();
-    const trancheState = deriveTrancheStatePda();
+    const globalState = pgs.deriveOutpostGlobalStatePda();
+    const poolAuthority = pgs.deriveOutpostPoolAuthorityPda();
+    const liqsolMint = pgs.deriveLiqsolMintPda();
+    const distributionState = pgs.deriveDistributionStatePda();
+    const bucketAuthority = pgs.deriveBucketAuthorityPda();
+    const trancheState = pgs.deriveTrancheStatePda();
 
     // Outpost / pretoken PDAs
-    const outpostAccount = deriveOutpostAccountPda(user);
-    const userPretokenRecord = deriveUserPretokenRecordPda(user);
+    const outpostAccount = pgs.deriveOutpostAccountPda(user);
+    const userPretokenRecord = pgs.deriveUserPretokenRecordPda(user);
 
     // ATAs
     const liqsolPoolAta = await getAssociatedTokenAddress(
@@ -599,23 +324,43 @@ export async function buildOutpostAccounts(
     const userAta = await getAssociatedTokenAddress(
         liqsolMint,
         user,
-        false,
+        true, // allow off curve in case squadsx vault
         TOKEN_2022_PROGRAM_ID,
     );
 
     // user_record PDAs keyed by TOKEN ACCOUNTS (matches capital-staking)
-    const bucketUserRecord = deriveUserRecordPda(bucketTokenAccount);
-    const liqsolPoolUserRecord = deriveUserRecordPda(liqsolPoolAta);
-    const userUserRecord = deriveUserRecordPda(userAta);
-
-    const extraAccountMetaList = deriveExtraAccountMetaListPda(liqsolMint);
+    const bucketUserRecord = pgs.deriveUserRecordPda(bucketTokenAccount);
+    const liqsolPoolUserRecord = pgs.deriveUserRecordPda(liqsolPoolAta);
+    const userUserRecord = pgs.deriveUserRecordPda(userAta);
+
+    const extraAccountMetaList = pgs.deriveExtraAccountMetaListPda(liqsolMint);
+
+    const pretokenPurchaseHistory = pgs.derivePretokenPurchaseHistoryPda(poolAuthority);
+
+    // OPP (outpost protocol pipeline)
+    const globalConfig = pgs.deriveGlobalConfigPda();
+    const oppEpochState = pgs.deriveOppEpochStatePda();
+    const epochNumber = await pgs.fetchOppEpochNumber(connection);
+    const pendingAttestations = pgs.derivePendingAttestationsPda(epochNumber);
+    const bridgeState = pgs.deriveOppBridgeStatePda();
+    const bridgeAuthority = PublicKey.findProgramAddressSync(
+        [Buffer.from('opp_bridge_vault')],
+        pgs.PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+    const bridgeVaultAta = await getAssociatedTokenAddress(
+        liqsolMint,
+        bridgeAuthority,
+        true,
+        TOKEN_2022_PROGRAM_ID,
+    );
+    const bridgeUserRecord = pgs.deriveUserRecordPda(bridgeVaultAta);
 
     // Chainlink program feeds
     let chainLinkFeed = CHAINLINK_FEED;
     let chainLinkProgram = CHAINLINK_PROGRAM;
 
     try {
-        const program = getLiqsolCoreProgram(connection);
+        const program: any = pgs.getProgram('liqsolCore');
         const ts: TrancheState =
             await program.account.trancheState.fetch(trancheState);
 
@@ -650,7 +395,15 @@ export async function buildOutpostAccounts(
         trancheState,
         chainLinkFeed,
         chainLinkProgram,
-        extraAccountMetaList
+        extraAccountMetaList,
+        pretokenPurchaseHistory,
+        globalConfig,
+        oppEpochState,
+        pendingAttestations,
+        bridgeState,
+        bridgeAuthority,
+        bridgeVaultAta,
+        bridgeUserRecord,
     };
 }
 // -----------------------------------------------------------------------------
@@ -833,4 +586,19 @@ export function ceilDiv(n: BN, d: BN): BN {
         throw new Error('Division by zero in ceilDiv');
     }
     return n.add(d.subn(1)).div(d);
-}
+}
+
+export function normalizeToBigInt(x: any): bigint {
+    if (typeof x === 'bigint') return x;
+    if (x != null && typeof x === 'object' && 'toString' in x) return BigInt(x.toString());
+    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;
+    }
+};

package/src/staker.ts

@@ -35,12 +35,26 @@ export class Staker {
         // console.log('STAKER INIT', config);
 
         config.forEach((cfg) => {
+            // if (+cfg.network.chainId === 31337){
+            //     console.log('ETH Wire Devnet chainId detected, remapping to hoodi for staker config');
+            //     cfg.network.chainId = EvmChainID.Hoodi; // remap local devnet to "Hoodi" chainId for now
+            // }
+
+            // if ((cfg.network.chainId as any) === 'devnet-wire'){
+            //     console.log('SOL Wire Devnet chainId detected, remapping to devnet-wire for staker config');
+            //     cfg.network.chainId = SolChainID.Devnet; // remap "devnet-wire" to Solana devnet chainId for now
+            // }
+
             switch (cfg.network.chainId) {
                 case SolChainID.Mainnet:
+                case SolChainID.Devnet:
+                case 'devnet-wire' as any:
                     this.clients.set(cfg.network.chainId, new SolanaStakingClient(cfg));
                     break;
 
                 case EvmChainID.Ethereum:
+                case EvmChainID.Hoodi:
+                case 31337 as any:
                     this.clients.set(cfg.network.chainId, new EthereumStakingClient(cfg));
                     break;
 
@@ -52,13 +66,20 @@ export class Staker {
 
         this.selectedChainID = selectedChainID;
     }
-    
+
     /**
      * Select a chain. Returns true if a client exists for it, false otherwise.
      * (We still record the selectedChainID so the UI can reflect the chosen chain.)
      */
     setChain(chainID: ChainID): boolean {
+        const hasClient = this.clients.has(chainID);
+
+        if (!hasClient) {
+            console.warn(`[Staker] setChain: no client configured for chain ${chainID}`);
+            return false;
+        }
+
         this.selectedChainID = chainID;
-        return this.clients.has(chainID);
+        return true;
     }
 }