@wireio/stake 0.0.5 → 0.0.69

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

@@ -1,179 +1,101 @@
-// src/solana/clients/ValidatorLeaderboardClient.ts
-import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
-import { PublicKey, Transaction, TransactionInstruction, SystemProgram, VersionedTransaction } from '@solana/web3.js';
-import {
-    deriveLeaderboardHeadPDA,
-    deriveValidatorRecordPDA,
-    deriveTop10CachePDA,
-} from '../utils';
-import { VALIDATOR_LEADERBOARD_PROGRAM_ID, ValidatorLeaderboard, ValidatorLeaderboardIDL } from '../constants';
-
-export class ValidatorLeaderboardClient {
-    constructor(private provider: AnchorProvider) { }
-
-    /**
-     * Wrapped Anchor Program for ValidatorLeaderboard
-     */
-    private get program(): Program<ValidatorLeaderboard> {
-        const idlWithAddress = {
-            ...JSON.parse(JSON.stringify(ValidatorLeaderboardIDL)),
-            address: VALIDATOR_LEADERBOARD_PROGRAM_ID.toString(),
-        };
-        return new Program(idlWithAddress as any, this.provider) as Program<ValidatorLeaderboard>;
-    }
-
-    /** Derive the PDA for the leaderboard head */
-    deriveHeadPDA(): PublicKey {
-        return deriveLeaderboardHeadPDA()[0];
-    }
-
-    /** Derive the PDA for a given validator record */
-    deriveRecordPDA(voteAccount: PublicKey): PublicKey {
-        return deriveValidatorRecordPDA(voteAccount)[0];
-    }
-
-    /**
-     * Build the initialize instruction as a Transaction
-     */
-    async buildInitializeTransaction(authority: PublicKey): Promise<Transaction> {
-        const [headPda] = deriveLeaderboardHeadPDA();
-        const ix = await this.program.methods
-            .initialize()
-            .accounts({
-                authority,
-                leaderboardHead: headPda,
-                systemProgram: SystemProgram.programId,
-            } as any)
-            .instruction();
-
-        return new Transaction().add(ix);
-    }
-
-    /**
-     * Build an updateValidator transaction
-     */
-    async buildUpdateValidatorTransaction(params: {
-        authority: PublicKey;
-        registrant: PublicKey;
-        voteAccount: PublicKey;
-        vpp: number;
-        insertAfter?: PublicKey;
-        insertBefore?: PublicKey;
-        currentPrev?: PublicKey;
-        currentNext?: PublicKey;
-    }): Promise<Transaction> {
-        const { authority, registrant, voteAccount, vpp, insertAfter, insertBefore, currentPrev, currentNext } = params;
-        const [headPda] = deriveLeaderboardHeadPDA();
-        const [recPda] = deriveValidatorRecordPDA(voteAccount);
-
-        const accounts: any = {
-            registrant,
-            voteAccount,
-            validatorRecord: recPda,
-            leaderboardHead: headPda,
-            systemProgram: SystemProgram.programId,
-            ...(insertAfter && { insertAfter }),
-            ...(insertBefore && { insertBefore }),
-            ...(currentPrev && { currentPrev }),
-            ...(currentNext && { currentNext }),
-        };
-
-        const ix = await this.program.methods
-            .updateValidator(new BN(vpp))
-            .accounts(accounts)
-            .instruction();
-
-        return new Transaction().add(ix);
-    }
-
-    /**
-     * Build an updateTop10Cache transaction
-     */
-    async buildUpdateTop10CacheTransaction(params: {
-        authority: PublicKey;
-        top10Validators: PublicKey[];
-    }): Promise<Transaction> {
-        const { authority, top10Validators } = params;
-        if (top10Validators.length !== 10) {
-            throw new Error('Must supply exactly 10 validators');
-        }
-        const [cachePda] = deriveTop10CachePDA();
-        const ix = await this.program.methods
-            .updateTop10Cache(top10Validators)
-            .accounts({ authority, cache: cachePda, systemProgram: SystemProgram.programId } as any)
-            .instruction();
-
-        return new Transaction().add(ix);
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+
+import { SolanaProgramService, ValidatorLeaderboardClientIdl } from '../program';
+import { LeaderboardState, ValidatorRecord } from '../types';
+
+/**
+ * Simple read client for the validator_leaderboard program.
+ *
+ * Adjust account names/fields to match your IDL (state, validatorRecord, etc).
+ */
+export class LeaderboardClient {
+    private program: Program<ValidatorLeaderboardClientIdl>;
+
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('validatorLeaderboard');
     }
 
-    /**
-     * Fetch the cached top 10 validators via a view call
-     */
-    async getCachedTop10(): Promise<PublicKey[]> {
-        const [cachePda] = deriveTop10CachePDA();
-        return this.program.methods
-            .getCachedTop10()
-            .accounts({ cache: cachePda } as any)
-            .view();
-    }
-
-    /**
-     * Traverse the on-chain linked list and return the sequence of PublicKeys
-     */
-    async getLeaderboard(): Promise<PublicKey[]> {
-        const [headPda] = deriveLeaderboardHeadPDA();
-        let headAccount;
+    async getState(): Promise<LeaderboardState | null> {
+        const pda = this.pgs.deriveLeaderboardStatePda();
         try {
-            headAccount = await this.program.account.leaderboardHead.fetch(headPda);
+            // Assumes account name "leaderboardState"
+            return await this.program.account.leaderboardState.fetch(pda);
         } catch {
-            return [];
-        }
-        const result: PublicKey[] = [];
-        let cursor: PublicKey = headAccount.nextValidator;
-        while (cursor && !cursor.equals(PublicKey.default)) {
-            result.push(cursor);
-            const rec = await this.program.account.validatorRecord.fetch(cursor);
-            cursor = rec.nextValidator;
+            return null;
         }
-        return result;
     }
 
-    /**
-     * Fetch a single validator record or null
-     */
-    async getRecord(voteAccount: PublicKey): Promise<any | null> {
-        const [recPda] = deriveValidatorRecordPDA(voteAccount);
+    async getValidatorRecord(voteAccount: PublicKey): Promise<ValidatorRecord | null> {
+        const pda = this.pgs.deriveValidatorRecordPda(voteAccount);
         try {
-            return await this.program.account.validatorRecord.fetch(recPda);
+            // Assumes account name "validatorRecord"
+            return await this.program.account.validatorRecord.fetchNullable(pda);
         } catch {
             return null;
         }
     }
 
     /**
-     * Send & confirm a single-IX Transaction; returns the signature
-     */
-    async sendTransaction(
-        tx: Transaction,
-        signers: import('@solana/web3.js').Signer[] = []
-    ): Promise<string> {
-        tx.feePayer = this.provider.wallet.publicKey;
-        const { blockhash } = await this.provider.connection.getLatestBlockhash();
-        tx.recentBlockhash = blockhash;
-        return this.provider.sendAndConfirm(tx, signers);
-    }
-
-    /**
-     * Simulate a single-IX Transaction; returns any err + compute units consumed
+     * Convenience helper to fetch and return top validators ordered
+     * by the on-chain leaderboard scores.
+     *
+     * Uses:
+     *  - `leaderboardState.scores`
+     *  - `leaderboardState.sortedIndices`
+     *  - `validatorRecord.registryIndex`
+     *
+     * Fallback: if leaderboardState can't be fetched, we sort by
+     * `creditsObserved` descending.
      */
-    async simulateTransaction(
-        tx: Transaction
-    ): Promise<{ err: any; unitsConsumed: number }> {
-        tx.feePayer = this.provider.wallet.publicKey;
-        const { blockhash } = await this.provider.connection.getLatestBlockhash();
-        tx.recentBlockhash = blockhash;
-        const versioned = new VersionedTransaction(tx.compileMessage());
-        const sim = await this.provider.connection.simulateTransaction(versioned, { sigVerify: false });
-        return { err: sim.value.err, unitsConsumed: sim.value.unitsConsumed! };
+    async getTopValidators(limit = 20): Promise<ValidatorRecord[]> {
+        // Try to use the leaderboard state first
+        try {
+            const leaderboardPda = this.pgs.deriveLeaderboardStatePda();
+            const leaderboard: LeaderboardState 
+                = await this.program.account.leaderboardState.fetch(leaderboardPda);
+
+            const all = await this.program.account.validatorRecord.all();
+            const byIndex = new Map<number, ValidatorRecord>();
+
+            for (const r of all) {
+                const vr = r.account;
+                byIndex.set(vr.registryIndex, vr);
+            }
+
+            const max = Math.min(
+                limit,
+                leaderboard.numValidators,
+                leaderboard.sortedIndices.length,
+            );
+
+            const top: ValidatorRecord[] = [];
+            for (let i = 0; i < max; i++) {
+                const idx = leaderboard.sortedIndices[i];
+                const rec = byIndex.get(idx);
+                if (rec) {
+                    top.push(rec);
+                }
+            }
+
+            return top;
+        } catch (e) {
+            // Fallback: no leaderboardState available, sort by creditsObserved.
+            const all = await this.program.account.validatorRecord.all();
+
+            all.sort((a, b) => {
+                const va = a.account;
+                const vb = b.account;
+                const ca = va.creditsObserved;
+                const cb = vb.creditsObserved;
+                // BN.cmp: -1 if a < b, 0 if equal, 1 if a > b
+                return cb.cmp(ca);
+            });
+
+            return all.slice(0, limit).map(r => r.account);
+        }
     }
-}
+}

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

@@ -0,0 +1,325 @@
+import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import {
+    PublicKey,
+    SystemProgram,
+    TransactionInstruction,
+} from '@solana/web3.js';
+import {
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    TOKEN_2022_PROGRAM_ID,
+} from '@solana/spl-token';
+
+import {
+    OutpostAccounts,
+    buildOutpostAccounts,
+    safeFetch,
+} from '../utils';
+
+import {
+    OutpostWireStateSnapshot,
+    SharesPreview,
+    TrancheState,
+    WalletLike,
+} from '../types';
+import { INDEX_SCALE } from '../constants';
+import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
+
+/**
+ * OutpostClient
+ *
+ * Read-only + preview helper for:
+ *  - Outpost config + per-user pretokens
+ *  - Tranche ladder snapshot
+ *  - Pretoken preview math
+ *
+ * Write helpers:
+ *  - buildStakeIx   → liqsol_core::synd
+ *  - buildUnstakeIx → liqsol_core::desynd
+ *
+ * All PDAs / ATAs are sourced via buildOutpostAccounts, which is kept
+ * in sync with the on-chain PDAs and capital-staking Wire utils.
+ */
+export class OutpostClient {
+    private readonly program: Program<LiqsolCoreClientIdl>;
+
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService,
+    ) {
+        this.program = pgs.getProgram('liqsolCore');
+    }
+
+    get connection() {
+        return this.provider.connection;
+    }
+
+    get wallet(): WalletLike {
+        return this.provider.wallet as unknown as WalletLike;
+    }
+
+    /**
+     * Build all outpost-related PDAs / ATAs for a given user.
+     * Defaults to the connected wallet.
+     */
+    async buildAccounts(user?: PublicKey): Promise<OutpostAccounts> {
+        const userPk = user ?? this.wallet.publicKey;
+        if (!userPk) {
+            throw new Error('OutpostClient.buildAccounts: wallet not connected');
+        }
+        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) {
+        try {
+            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,
+            );
+        }
+    }
+
+    /**
+     * Fetch the core "Wire state" for Outpost / pretokens for a given user.
+     */
+    async fetchWireState(user?: PublicKey): Promise<OutpostWireStateSnapshot> {
+        const userPk = user ?? this.wallet.publicKey;
+        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'),
+        ]);
+
+        return {
+            globalState,
+            outpostAccount,
+            distributionState,
+            trancheState,
+            userPretokenRecord,
+            liqsolPoolBalance,
+            userLiqsolBalance,
+        };
+    }
+
+
+
+    // -------------------------------------------------------------------------
+    // Outpost stake / unstake builders (synd / desynd)
+    // -------------------------------------------------------------------------
+
+    /**
+     * Build the `synd` (stake) instruction:
+     *   user liqSOL ATA → liqSOL pool ATA
+     */
+    async buildStakeIx(
+        amountLamports: bigint,
+        user: PublicKey = this.wallet.publicKey,
+    ): Promise<TransactionInstruction> {
+        if (!user) {
+            throw new Error('OutpostClient.buildStakeIx: wallet not connected');
+        }
+
+        const a = await this.buildAccounts(user);
+
+        const globalConfig = this.pgs.deriveGlobalConfigPda();
+
+
+        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,
+                globalConfig: globalConfig,
+            } as any)
+            .instruction();
+    }
+
+    /**
+     * Build the `desynd` (unstake) instruction:
+     *   liqSOL pool ATA → user liqSOL ATA
+     */
+    async buildUnstakeIx(
+        amountLamports: bigint,
+        user?: PublicKey,
+    ): Promise<TransactionInstruction> {
+        const userPk = user ?? this.wallet.publicKey;
+        if (!userPk) {
+            throw new Error('OutpostClient.buildUnstakeIx: wallet not connected');
+        }
+
+        const a = await this.buildAccounts(userPk);
+
+        return this.program.methods
+            .desynd(new BN(amountLamports.toString()))
+            .accounts({
+                user: userPk,
+                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.liqsolPoolUserRecord,
+                receiverUserRecord: a.userUserRecord,
+                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,
+                systemProgram: SystemProgram.programId,
+                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+                pretokenPurchaseHistory: a.pretokenPurchaseHistory,
+            } as any)
+            .instruction();
+    }
+
+    // -------------------------------------------------------------------------
+    // Pretoken preview helper (unchanged)
+    // -------------------------------------------------------------------------
+
+    /**
+     * Local preview for "how many pretokens would I get for this liqSOL
+     * amount at the current tranche price and SOL/USD price?"
+     *
+     *   SCALE = 1e8
+     *   usdValue = solAmountLamports * solPriceUsd / 1e9
+     *   pretokens = usdValue * SCALE / pretokenPriceUsd
+     *
+     * All values are BN integers; solPriceUsd and pretokenPriceUsd are 1e8 scaled.
+     */
+    previewPretokens(params: {
+        liqsolAmountLamports: BN;
+        solPriceUsd: BN; // 1e8 scale
+        trancheState: TrancheState;
+    }): SharesPreview {
+        const { liqsolAmountLamports, solPriceUsd, trancheState } = params;
+
+        // Current tranche price in USD (1e8 scale)
+        const pretokenPriceUsd = new BN(
+            trancheState.currentTranchePriceUsd.toString(),
+        );
+
+        const SCALE = new BN('100000000'); // 1e8
+
+        // usdValue = (lamports * solPriceUsd) / 1e9
+        const usdValue = liqsolAmountLamports
+            .mul(solPriceUsd)
+            .div(new BN(1_000_000_000));
+
+        const estimatedPretokens = usdValue.mul(SCALE).div(pretokenPriceUsd);
+
+        return {
+            liqsolAmountLamports,
+            solPriceUsd,
+            pretokenPriceUsd,
+            estimatedPretokens,
+        };
+    }
+
+    /**
+     * Convert liqSOL tokens (lamports) → Outpost “shares”, rounding UP
+     * when there is any remainder.
+     *
+     * This matches the on-chain logic and the capital-staking helper:
+     *
+     *   INDEX_SCALE = 1e12
+     *   numerator   = amount * INDEX_SCALE
+     *   shares      = numerator / currentIndex
+     *   remainder   = numerator % currentIndex
+     *   if remainder > 0 → shares + 1
+     */
+    static tokensToShares(amount: BN, currentIndex: BN): BN {
+        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);
+    }
+
+    /**
+     * Format a 1e8-scaled integer (e.g. USD price, pretokens, etc.)
+     * into a fixed 8-decimal string.
+     *
+     * Examples:
+     *   0          -> "0.00000000"
+     *   1          -> "0.00000001"
+     *   100000000  -> "1.00000000"
+     *   123456789  -> "1.23456789"
+     */
+    static formatScale8(value: BN): string {
+        const decimals = 8;
+        const valueStr = value.toString();
+
+        if (valueStr.length <= decimals) {
+            const padding = '0'.repeat(decimals - valueStr.length);
+            return `0.${padding}${valueStr}`;
+        }
+
+        const intPart = valueStr.slice(0, valueStr.length - decimals);
+        const decPart = valueStr.slice(valueStr.length - decimals);
+        return `${intPart}.${decPart}`;
+    }
+}