@wireio/stake 0.0.6 → 0.1.1

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

@@ -1,179 +1,59 @@
-// 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();
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
 
-        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();
+import { SolanaProgramService } from '../program';
+import type { ValidatorLeaderboard } from '../../../assets/solana/types/validator_leaderboard';
+import {
+    deriveLeaderboardStatePda,
+    deriveValidatorRecordPda,
+} from '../constants';
 
-        return new Transaction().add(ix);
-    }
+/**
+ * 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<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();
+    constructor(private provider: AnchorProvider) {
+        const svc = new SolanaProgramService(provider);
+        this.program = svc.getProgram('validatorLeaderboard');
     }
 
-    /**
-     * Traverse the on-chain linked list and return the sequence of PublicKeys
-     */
-    async getLeaderboard(): Promise<PublicKey[]> {
-        const [headPda] = deriveLeaderboardHeadPDA();
-        let headAccount;
+    async getState(): Promise<any | null> {
+        const pda = 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<any | null> {
+        const pda = 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 sort top validators by score.
+     * Assumes `validatorRecord` has a numeric `score` field in the IDL.
      */
-    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<any[]> {
+        const records = await (this.program.account as any).validatorRecord.all();
+        const sorted = (records as Array<{ publicKey: PublicKey; account: any }>).sort(
+            (a, b) => {
+                const sa = BigInt(a.account.score?.toString?.() ?? '0');
+                const sb = BigInt(b.account.score?.toString?.() ?? '0');
+                return sb > sa ? 1 : sb < sa ? -1 : 0;
+            },
+        );
+        return sorted.slice(0, limit);
     }
-}
+}

package/src/networks/solana/constants.ts

@@ -1,73 +1,242 @@
 // src/networks/solana/constants.ts
+import { PublicKey, StakeProgram } from '@solana/web3.js';
 
-import { PublicKey } from '@solana/web3.js';
-import { TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from '@solana/spl-token';
-
-// — IDLs — (must match your filesystem: src/assets/solana/idl/*.json)
-import DepositIDL from '../../assets/solana/idl/deposit.json';
-import DistributionIDL from '../../assets/solana/idl/distribution.json';
-import LiqSolTokenIDL from '../../assets/solana/idl/liq_sol_token.json';
-import StakeControllerIDL from '../../assets/solana/idl/stake_controller.json';
-import StakeRegistryIDL from '../../assets/solana/idl/stake_registry.json';
-import TreasuryIDL from '../../assets/solana/idl/treasury.json';
-import ValidatorLeaderboardIDL from '../../assets/solana/idl/validator_leaderboard.json';
-import ValidatorRegistryIDL from '../../assets/solana/idl/validator_registry.json';
-import YieldOracleIDL from '../../assets/solana/idl/yield_oracle.json';
-
-// — Types — for your clients
-import type { Deposit } from '../../assets/solana/types/deposit';
-import type { Distribution } from '../../assets/solana/types/distribution';
-import type { ValidatorLeaderboard } from '../../assets/solana/types/validator_leaderboard';
-import type { LiqSolToken } from '../../assets/solana/types/liq_sol_token';
-import type { StakeController } from '../../assets/solana/types/stake_controller';
-import type { StakeRegistry } from '../../assets/solana/types/stake_registry';
-import type { Treasury } from '../../assets/solana/types/treasury';
-import type { ValidatorRegistry } from '../../assets/solana/types/validator_registry';
-import type { YieldOracle } from '../../assets/solana/types/yield_oracle';
-
-// Re-export for easy import elsewhere:
-export {
-    Deposit,
-    DepositIDL,
-    Distribution,
-    DistributionIDL,
-    LiqSolToken,
-    LiqSolTokenIDL,
-    StakeController,
-    StakeControllerIDL,
-    StakeRegistry,
-    StakeRegistryIDL,
-    Treasury,
-    TreasuryIDL,
-    ValidatorLeaderboard,
-    ValidatorLeaderboardIDL,
-    ValidatorRegistry,
-    ValidatorRegistryIDL,
-    YieldOracle,
-    YieldOracleIDL,
+import liqsolCoreIDL from "../../assets/solana/idl/liqsol_core.json";
+import liqSolTokenIDL from "../../assets/solana/idl/liqsol_token.json";
+import validatorLeaderboardIDL from "../../assets/solana/idl/validator_leaderboard.json";
+
+/**
+ * ---------------------------------------------------------------------------
+ *  PROGRAM IDS
+ * ---------------------------------------------------------------------------
+ *
+ * These should match:
+ *  - `metadata.address` in your Anchor IDLs under src/assets/solana/idl/*.json
+ *  - The program IDs printed by your deploy scripts
+ */
+// Extract program IDs from IDL files
+export const PROGRAM_IDS = {
+    LIQSOL_CORE: new PublicKey(liqsolCoreIDL.address),
+    LIQSOL_TOKEN: new PublicKey(liqSolTokenIDL.address),
+    VALIDATOR_LEADERBOARD: new PublicKey(validatorLeaderboardIDL.address),
+} as const;
+
+// Export individual program IDs for convenience
+export const {
+    LIQSOL_CORE,
+    LIQSOL_TOKEN,
+    VALIDATOR_LEADERBOARD,
+} = PROGRAM_IDS;
+
+/**
+ * ---------------------------------------------------------------------------
+ *  PDA SEEDS (must match on-chain programs)
+ * ---------------------------------------------------------------------------
+ *
+ * These strings are baked into the on-chain programs and are already used in
+ * your test utils. We centralize them here so all clients share them.
+ */
+
+export const PDA_SEEDS = {
+    // liqsol_core: deposit / stake controller
+    DEPOSIT_AUTHORITY: 'deposit_authority',
+    VAULT: 'vault',
+    RESERVE_POOL: 'reserve_pool',
+    STAKE_CONTROLLER_STATE: 'stake_controller',
+    PAYOUT_STATE: 'payout-state',
+
+    // liqsol_token: mint + bucket
+    LIQSOL_MINT: 'liqsol_mint',
+    LIQSOL_MINT_AUTHORITY: 'mint_authority',
+    BUCKET_AUTHORITY: 'liqsol_bucket',
+
+    // distribution program (embedded in liqsol_core)
+    DISTRIBUTION_STATE: 'distribution_state',
+    USER_RECORD: 'user_record',
+
+    // pay-rate history
+    PAY_RATE_HISTORY: 'pay_rate_history',
+
+    // validator leaderboard (state + records)
+    LEADERBOARD_STATE: 'leaderboard_state',
+    VALIDATOR_RECORD: 'validator',
+    GLOBAL_STAKE_INFO: 'global_stake_info',
+} as const;
+
+/**
+ * Helpers for PDA derivation so clients don’t duplicate logic.
+ */
+
+export const deriveLiqsolMintPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.LIQSOL_MINT)],
+        PROGRAM_IDS.LIQSOL_TOKEN,
+    )[0];
+
+export const deriveLiqsolMintAuthorityPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.LIQSOL_MINT_AUTHORITY)],
+        PROGRAM_IDS.LIQSOL_TOKEN,
+    )[0];
+
+export const deriveDepositAuthorityPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.DEPOSIT_AUTHORITY)],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+export const deriveVaultPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.VAULT)],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+export const deriveReservePoolPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.RESERVE_POOL)],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+export const deriveStakeControllerStatePda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.STAKE_CONTROLLER_STATE)],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+export const derivePayoutStatePda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.PAYOUT_STATE)],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+export const deriveBucketAuthorityPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.BUCKET_AUTHORITY)],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+export const deriveDistributionStatePda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.DISTRIBUTION_STATE)],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+export const deriveUserRecordPda = (user: PublicKey) =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.USER_RECORD), user.toBuffer()],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+export const derivePayRateHistoryPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.PAY_RATE_HISTORY)],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+// export const deriveGlobalStakeInfoPda = () =>
+//     PublicKey.findProgramAddressSync(
+//         [Buffer.from(PDA_SEEDS.GLOBAL_STAKE_INFO)],
+//         PROGRAM_IDS.LIQSOL_CORE,
+//     )[0];
+
+export const deriveLeaderboardStatePda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.LEADERBOARD_STATE)],
+        PROGRAM_IDS.VALIDATOR_LEADERBOARD,
+    )[0];
+
+export const deriveValidatorRecordPda = (voteAccount: PublicKey) =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.VALIDATOR_RECORD), voteAccount.toBuffer()],
+        PROGRAM_IDS.VALIDATOR_LEADERBOARD,
+    )[0];
+
+/**
+* Stake controller vault PDA (reserve pool SOL vault).
+* This is the same as VAULT, but named more explicitly for SDK callers.
+*/
+export const deriveStakeControllerVaultPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.VAULT)],
+        PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+
+/**
+ * Ephemeral stake account address used per-deposit.
+ * On-chain convention: seed = `ephemeral_<u32>` under StakeProgram.programId.
+ */
+export const deriveEphemeralStakeAddress = async (
+    user: PublicKey,
+    seed: any,
+): Promise<PublicKey> => {
+    const seedStr = `ephemeral_${seed}`;
+    return await PublicKey.createWithSeed(user, seedStr, StakeProgram.programId);
 };
 
-// — Program IDs — anchor “address” fields inside each IDL must match these:
-export const DEPOSIT_PROGRAM_ID = new PublicKey(DepositIDL.address);
-export const DISTRIBUTION_PROGRAM_ID = new PublicKey(DistributionIDL.address);
-export const LIQSOL_TOKEN_PROGRAM_ID = new PublicKey(LiqSolTokenIDL.address);
-export const STAKE_CONTROLLER_PROGRAM_ID = new PublicKey(StakeControllerIDL.address);
-export const STAKE_REGISTRY_PROGRAM_ID = new PublicKey(StakeRegistryIDL.address);
-export const TREASURY_PROGRAM_ID = new PublicKey(TreasuryIDL.address);
-export const VALIDATOR_LEADERBOARD_PROGRAM_ID = new PublicKey(ValidatorLeaderboardIDL.address);
-export const VALIDATOR_REGISTRY_PROGRAM_ID = new PublicKey(ValidatorRegistryIDL.address);
-export const YIELD_ORACLE_PROGRAM_ID = new PublicKey(YieldOracleIDL.address);
-
-// — Protocol constants — tweak as needed:
-export const MIN_SOL_TO_PARTICIPATE = 1_000_000_000;  // 1 SOL in lamports
-export const MIN_FUNDS_THRESHOLD = 10_000_000_000; // 10 SOL in lamports
-export const RESERVE_FOR_FEES = 1_000_000_000;  // 1 SOL
-
-// — Pre-derived PDA seeds for your convenience —  
-// (you can still use your utils.ts helpers instead)
-export const TREASURY_WALLET_PDA = new PublicKey('9gLj1MRrm66GNYqnMLPGUzyYqYJpVLQgFSbtCQV9Ta4G');
-export const LIQSOL_MINT_ADDRESS = new PublicKey('B2XtJABkc6eUoYUNgSfZVb3kYckmbh2zxp4rp2hX2Xwa');
-export const STAKE_VAULT_PDA = new PublicKey('AY83EfU5LXJGDhbLeP45H3tLKisGZgSe2G4mGYfPimqN');
-
-// re-export SPL token constants:
-export { TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID };
+
+
+/**
+ * ---------------------------------------------------------------------------
+ *  ECONOMICS & MATH CONSTANTS
+ * ---------------------------------------------------------------------------
+ */
+
+// Same scale factor used on-chain for pay-rate math
+export const PAY_RATE_SCALE_FACTOR = BigInt(1_000_000_000_000); // 10^12
+
+// Default pay rate fallback used in tests & utils
+export const DEFAULT_AVERAGE_PAY_RATE = BigInt(191_780_821);
+
+// How many history entries to average when computing expected fee
+export const DEFAULT_PAY_RATE_LOOKBACK = 5;
+
+// Rent exemption for ephemeral stake account (lamports)
+// Mirrors EPHEMERAL_RENT_EXEMPTION = 2_282_880 used in tests
+export const EPHEMERAL_RENT_EXEMPTION = 2_282_880;
+
+// For convenience: lamports <-> SOL helpers (no RPC dependency)
+export const LAMPORTS_PER_SOL = 1_000_000_000;
+
+export const lamportsToSol = (lamports: number | bigint): number =>
+    Number(lamports) / LAMPORTS_PER_SOL;
+
+export const solToLamports = (sol: number): number =>
+    Math.round(sol * LAMPORTS_PER_SOL);
+
+/**
+ * ---------------------------------------------------------------------------
+ *  CLUSTER / ENVIRONMENT CONFIG (optional but handy)
+ * ---------------------------------------------------------------------------
+ */
+
+export type SolanaCluster = 'localnet' | 'devnet' | 'mainnet';
+
+// export interface SolanaStakeProgramAddresses {
+//     liqsolCore: PublicKey;
+//     liqsolToken: PublicKey;
+//     validatorLeaderboard: PublicKey;
+// }
+
+// export const PROGRAMS_BY_CLUSTER: Record<SolanaCluster, SolanaStakeProgramAddresses> = {
+//     localnet: {
+//         liqsolCore: PROGRAM_IDS.LIQSOL_CORE,
+//         liqsolToken: PROGRAM_IDS.LIQSOL_TOKEN,
+//         validatorLeaderboard: PROGRAM_IDS.VALIDATOR_LEADERBOARD,
+//     },
+//     devnet: {
+//         liqsolCore: PROGRAM_IDS.LIQSOL_CORE,
+//         liqsolToken: PROGRAM_IDS.LIQSOL_TOKEN,
+//         validatorLeaderboard: PROGRAM_IDS.VALIDATOR_LEADERBOARD,
+//     },
+//     mainnet: {
+//         liqsolCore: PROGRAM_IDS.LIQSOL_CORE,
+//         liqsolToken: PROGRAM_IDS.LIQSOL_TOKEN,
+//         validatorLeaderboard: PROGRAM_IDS.VALIDATOR_LEADERBOARD,
+//     },
+// };
+
+// export const DEFAULT_CLUSTER: SolanaCluster = 'localnet';
+
+// export function getProgramIds(cluster: SolanaCluster = DEFAULT_CLUSTER): SolanaStakeProgramAddresses {
+//     return PROGRAMS_BY_CLUSTER[cluster];
+// }