@wireio/stake 0.3.1 → 0.4.1

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

@@ -1,38 +1,33 @@
-import { AnchorProvider, Program } from '@coral-xyz/anchor';
-import {
-    ParsedAccountData,
-    PublicKey,
-    SYSVAR_INSTRUCTIONS_PUBKEY,
-    Transaction,
-    SystemProgram,
-} from '@solana/web3.js';
-import {
-    TOKEN_2022_PROGRAM_ID,
-    getAssociatedTokenAddress,
-} from '@solana/spl-token';
+import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
 
 import { SolanaProgramService } from '../program';
 import type { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
 import {
-    deriveBucketAuthorityPda,
     deriveDistributionStatePda,
     deriveLiqsolMintPda,
-    derivePayRateHistoryPda,
     deriveUserRecordPda,
 } from '../constants';
-import type { CorrectRegisterBuildResult, DistributionState, MismatchCandidate, ParsedAccountInfo, UserRecord } from '../types';
+import type { DistributionState, DistributionUserRecord } from '../types';
+import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
 
 /**
  * Distribution client – wraps the distribution portion of the liqsol_core
- * program. Responsible for:
- *  - Reading DistributionState + UserRecord
- *  - Computing mismatch candidates (tracked > actual)
- *  - Building a "correct then register" transaction for the caller
+ * program in the *new* shares-only model.
+ *
+ * Responsibilities:
+ *  - Read DistributionState (global index/share pool)
+ *  - Read per-user UserRecord (shares)
+ *  - Provide simple helpers for querying user share positions
  *
- * Aligned with the on-chain `update_user` script:
- *   - Single `updateUser()` entrypoint that:
- *       * Can create userRecord if missing
- *       * Reconciles tracked vs actual using user, userAta, bucket, pay-rate
+ * There is no longer any notion of:
+ *  - tracked vs actual balances
+ *  - mismatch candidates
+ *  - updateUser / correct-&-register flow
+ *
+ * On-chain truth:
+ *  - User balances live in their liqSOL ATA.
+ *  - DistributionState + UserRecord track *shares* for yield.
  */
 export class DistributionClient {
     private program: Program<LiqsolCore>;
@@ -42,15 +37,18 @@ export class DistributionClient {
         this.program = svc.getProgram('liqsolCore');
     }
 
-    get connection() { return this.provider.connection; }
+    get connection() {
+        return this.provider.connection;
+    }
 
     /**
      * Fetch the global distribution state account.
+     *
+     * IDL account name: "distributionState"
      */
     async getDistributionState(): Promise<DistributionState | null> {
         const pda = deriveDistributionStatePda();
         try {
-            // IDL account name: "distributionState"
             return await this.program.account.distributionState.fetch(pda);
         } catch {
             return null;
@@ -59,294 +57,77 @@ export class DistributionClient {
 
     /**
      * Fetch a user's distribution userRecord (or null if missing).
-     */
-    async getUserRecord(user: PublicKey): Promise<UserRecord | null> {
-        const pda = deriveUserRecordPda(user);
-        try {
-            return await this.program.account.userRecord.fetchNullable(pda);
-        } catch {
-            return null;
-        }
-    }
-
-    /**
-     * Helper: get actual liqSOL balances for all token holders.
      *
-     * Returns a map: owner (base58) -> actual balance (BigInt)
+     * IDL account name: "userRecord"
      */
-    private async getActualBalancesByOwner(): Promise<Map<string, bigint>> {
+    async getUserRecord(
+        ownerOrAta: PublicKey,
+    ): Promise<DistributionUserRecord | null> {
         const liqsolMint = deriveLiqsolMintPda();
-        const mintStr = liqsolMint.toBase58();
-
-        const accounts = await this.connection.getParsedProgramAccounts(
-            TOKEN_2022_PROGRAM_ID,
-            {
-                filters: [
-                    // SPL token layout: mint at offset 0
-                    { memcmp: { offset: 0, bytes: mintStr } },
-                ],
-                commitment: 'confirmed',
-            },
-        );
-
-        const byOwner = new Map<string, bigint>();
-
-        for (const acct of accounts) {
-            const data = acct.account.data as ParsedAccountData;
-            const parsed = data.parsed;
-            if (!parsed || parsed.type !== 'account') continue;
-
-            const info: ParsedAccountInfo = parsed.info;
-            const ownerStr = info.owner;
-            const amountStr = info.tokenAmount.amount;
-            const amount = BigInt(amountStr);
 
-            const prev = byOwner.get(ownerStr) ?? BigInt(0);
-            byOwner.set(ownerStr, prev + amount);
+        // 1) Try treating ownerOrAta as a WALLET: derive its liqSOL ATA, then userRecord.
+        try {
+            const ata = getAssociatedTokenAddressSync(
+                liqsolMint,
+                ownerOrAta,
+                false,
+                TOKEN_2022_PROGRAM_ID,
+            );
+            const pdaFromWallet = deriveUserRecordPda(ata);
+            const recFromWallet =
+                await this.program.account.userRecord.fetchNullable(pdaFromWallet);
+            if (recFromWallet) {
+                return recFromWallet;
+            }
+        } catch {
+            // fall through
         }
 
-        return byOwner;
-    }
-
-    /**
-     * Helper: get tracked balances from all userRecord accounts,
-     * keyed by *actual wallet owner*, not the userRecord PDA.
-     *
-     * userRecord struct:
-     *  - userAta: pubkey
-     *  - trackedBalance: u64
-     *  - claimBalance: u64
-     *  - lastClaimTimestamp: i64
-     *  - bump: u8
-     */
-    private async getTrackedBalances(): Promise<
-        Map<string, { owner: PublicKey; tracked: bigint }>
-    > {
-        const records = await this.program.account.userRecord.all();
-        const map = new Map<string, { owner: PublicKey; tracked: bigint }>();
-
-        for (const r of records) {
-            const ur = r.account as UserRecord;
-            const userAta = ur.userAta as PublicKey;
-
-            // Resolve the *wallet* that owns this ATA
-            const ataInfo = await this.connection.getParsedAccountInfo(userAta);
-            const parsedData = ataInfo.value?.data as ParsedAccountData | undefined;
-            if (!parsedData) continue;
-
-            const parsed = parsedData.parsed;
-            if (!parsed || (parsed as any).type !== 'account') continue;
-
-            const info: ParsedAccountInfo = parsed.info;
-            const ownerStr = info.owner;
-            const owner = new PublicKey(ownerStr);
-
-            const tracked = BigInt(ur.trackedBalance.toString());
-            map.set(ownerStr, { owner, tracked });
+        // 2) Fallback: treat ownerOrAta as already being the TOKEN ACCOUNT.
+        try {
+            const pdaFromAta = deriveUserRecordPda(ownerOrAta);
+            return await this.program.account.userRecord.fetchNullable(pdaFromAta);
+        } catch {
+            return null;
         }
-
-        return map;
     }
 
     /**
-     * Discover all mismatch candidates where tracked > actual.
+     * Convenience: get the user's current distribution shares.
      *
-     * - actual balances are derived from token accounts for the liqSOL mint
-     * - tracked balances come from Distribution.userRecord
+     * Returns BN(0) if the user has no userRecord yet.
      */
-    private async deriveMismatchCandidates(): Promise<MismatchCandidate[]> {
-        const [actualByOwner, trackedByOwner] = await Promise.all([
-            this.getActualBalancesByOwner(),
-            this.getTrackedBalances(),
-        ]);
-
-        const out: MismatchCandidate[] = [];
-
-        for (const [ownerStr, { owner, tracked }] of trackedByOwner.entries()) {
-            const actual = actualByOwner.get(ownerStr) ?? BigInt(0);
-            const delta = tracked - actual;
-            if (delta > BigInt(0)) {
-                out.push({ owner, actual, tracked, delta });
-            }
-        }
-
-        // Largest discrepancy first
-        out.sort((a, b) => (b.delta > a.delta ? 1 : b.delta < a.delta ? -1 : 0));
-        return out;
-    }
-
-    /**
-     * Canonical helper to build an `updateUser` instruction for a given user,
-     * matching the standalone update-user.ts script.
-     */
-    private async buildUpdateUserIx(targetUser: PublicKey) {
-        const walletPk = this.provider.wallet.publicKey;
-
-        const distributionStatePDA = deriveDistributionStatePda();
-        const userRecordPDA = deriveUserRecordPda(targetUser);
-        const liqsolMintPDA = deriveLiqsolMintPda();
-        const payRateHistoryPDA = derivePayRateHistoryPda();
-        const bucketAuthorityPDA = deriveBucketAuthorityPda();
-
-        const userAta = await getAssociatedTokenAddress(
-            liqsolMintPDA,
-            targetUser,
-            false,
-            TOKEN_2022_PROGRAM_ID,
-        );
-
-        const bucketTokenAccount = await getAssociatedTokenAddress(
-            liqsolMintPDA,
-            bucketAuthorityPDA,
-            true, // allowOwnerOffCurve
-            TOKEN_2022_PROGRAM_ID,
-        );
-
-        return (this.program.methods as any)
-            .updateUser()
-            .accounts({
-                user: targetUser,
-                userAta,
-                userRecord: userRecordPDA,
-                authority: walletPk,
-                payer: walletPk,
-                distributionState: distributionStatePDA,
-                liqsolMint: liqsolMintPDA,
-                instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
-                tokenProgram: TOKEN_2022_PROGRAM_ID,
-                bucketAuthority: bucketAuthorityPDA,
-                bucketTokenAccount,
-                payRateHistory: payRateHistoryPDA,
-                systemProgram: SystemProgram.programId,
-            })
-            .instruction();
+    async getUserShares(user: PublicKey): Promise<BN> {
+        const record = await this.getUserRecord(user);
+        return record ? record.shares : new BN(0);
     }
 
     /**
-     * Build the "correct & register" transaction.
-     *
-     * - Fetches DistributionState + all userRecords + token holders
-     * - Computes caller's untracked amount (actual - tracked)
-     * - If DistributionState.availableBalance already covers that, we only
-     *   send updateUser(caller).
-     * - Otherwise we select top mismatch candidates until their freed deltas
-     *   cover the shortfall, then build updateUser(target) for each,
-     *   followed by updateUser(caller).
+     * Convenience: get both the user's shares and totalShares, plus a
+     * floating-point ratio (userShares / totalShares).
      *
-     * NOTE:
-     *  - This no longer uses a separate updateSpecificUser; the single
-     *    updateUser entrypoint accepts any `user` as long as authority/payer
-     *    are valid, per your script.
+     * NOTE: ratio is a JS number and may lose precision for very large values,
+     * but is fine for display / percentage UIs.
      */
-    async buildCorrectRegisterTx(opts: {
-        amount?: bigint;
-        maxCandidates?: number;
-    } = {}): Promise<CorrectRegisterBuildResult> {
-        const walletPk = this.provider.wallet.publicKey;
-        const callerStr = walletPk.toBase58();
-
-        const [distState, actualByOwner, trackedByOwner] = await Promise.all([
+    async getUserSharePosition(user: PublicKey): Promise<{
+        shares: BN;
+        totalShares: BN;
+        ratio: number;
+    }> {
+        const [dist, userShares] = await Promise.all([
             this.getDistributionState(),
-            this.getActualBalancesByOwner(),
-            this.getTrackedBalances(),
+            this.getUserShares(user),
         ]);
 
-        if (!distState) {
-            return {
-                needToRegister: false,
-                canSucceed: false,
-                reason: 'DistributionState not initialized',
-                transaction: undefined,
-                plan: { deficit: BigInt(0), willFree: BigInt(0), selected: [] },
-            };
-        }
-
-        const availableBalance = BigInt(distState.availableBalance.toString());
-
-        const trackedEntry =
-            trackedByOwner.get(callerStr) ?? {
-                owner: walletPk,
-                tracked: BigInt(0),
-            };
-
-        const actual = actualByOwner.get(callerStr) ?? BigInt(0);
-        const tracked = trackedEntry.tracked;
-        const untracked = actual - tracked;
-
-        // Nothing to register
-        if (untracked <= BigInt(0)) {
-            return {
-                needToRegister: false,
-                canSucceed: true,
-                reason: 'No untracked liqSOL to register',
-                transaction: undefined,
-                plan: { deficit: BigInt(0), willFree: BigInt(0), selected: [] },
-            };
-        }
-
-        // Optional user-specified cap on how much to register.
-        const targetRegister =
-            opts.amount && opts.amount > BigInt(0) ? opts.amount : untracked;
-
-        // Simple case: availableBalance already covers what we want to register
-        if (availableBalance >= targetRegister) {
-            const tx = new Transaction();
-            const ix = await this.buildUpdateUserIx(walletPk); // caller only
-            tx.add(ix);
-
-            return {
-                needToRegister: true,
-                canSucceed: true,
-                transaction: tx,
-                plan: { deficit: BigInt(0), willFree: BigInt(0), selected: [] },
-            };
-        }
-
-        // Need to free up more availableBalance by correcting others.
-        const deficit = targetRegister - availableBalance;
-
-        const allCandidates = await this.deriveMismatchCandidates();
-        const maxCandidates = opts.maxCandidates ?? 10;
-
-        const selected: MismatchCandidate[] = [];
-        let willFree = BigInt(0);
-
-        for (const c of allCandidates) {
-            if (c.owner.equals(walletPk)) continue; // don't self-correct here
-            selected.push(c);
-            willFree += c.delta;
-            if (willFree >= deficit || selected.length >= maxCandidates) break;
-        }
-
-        if (willFree < deficit) {
-            return {
-                needToRegister: true,
-                canSucceed: false,
-                reason: 'Not enough mismatched candidates to cover deficit',
-                transaction: undefined,
-                plan: { deficit, willFree, selected },
-            };
-        }
-
-        const tx = new Transaction();
-
-        // 1) Correct selected mismatched users.
-        for (const c of selected) {
-            const ix = await this.buildUpdateUserIx(c.owner);
-            tx.add(ix);
-        }
+        const totalShares = dist ? dist.totalShares : new BN(0);
 
-        // 2) Register caller (updateUser(caller)).
-        {
-            const ix = await this.buildUpdateUserIx(walletPk);
-            tx.add(ix);
+        let ratio = 0;
+        if (!totalShares.isZero()) {
+            // use toNumber() for UI-friendly ratio; if you need exact math,
+            // do it with BN or bigint at the call site instead.
+            ratio = userShares.toNumber() / totalShares.toNumber();
         }
 
-        return {
-            needToRegister: true,
-            canSucceed: true,
-            transaction: tx,
-            plan: { deficit, willFree, selected },
-        };
+        return { shares: userShares, totalShares, ratio };
     }
 }

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

@@ -7,6 +7,7 @@ import {
     deriveLeaderboardStatePda,
     deriveValidatorRecordPda,
 } from '../constants';
+import { LeaderboardState, ValidatorRecord } from '../types';
 
 /**
  * Simple read client for the validator_leaderboard program.
@@ -21,7 +22,7 @@ export class LeaderboardClient {
         this.program = svc.getProgram('validatorLeaderboard');
     }
 
-    async getState(): Promise<any | null> {
+    async getState(): Promise<LeaderboardState | null> {
         const pda = deriveLeaderboardStatePda();
         try {
             // Assumes account name "leaderboardState"
@@ -31,7 +32,7 @@ export class LeaderboardClient {
         }
     }
 
-    async getValidatorRecord(voteAccount: PublicKey): Promise<any | null> {
+    async getValidatorRecord(voteAccount: PublicKey): Promise<ValidatorRecord | null> {
         const pda = deriveValidatorRecordPda(voteAccount);
         try {
             // Assumes account name "validatorRecord"
@@ -42,18 +43,62 @@ export class LeaderboardClient {
     }
 
     /**
-     * Convenience helper to fetch and sort top validators by score.
-     * Assumes `validatorRecord` has a numeric `score` field in the IDL.
+     * 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 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);
+    async getTopValidators(limit = 20): Promise<ValidatorRecord[]> {
+        // Try to use the leaderboard state first
+        try {
+            const leaderboardPda = 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);
+        }
     }
 }