@wireio/stake 0.0.5 → 0.0.69

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

@@ -1,230 +1,358 @@
-// src/solana/clients/DistributionClient.ts
-import { AnchorProvider, Program, BN, web3 } from '@coral-xyz/anchor';
-import {
-    PublicKey,
-    Transaction,
-    TransactionInstruction,
-    SystemProgram,
-    VersionedTransaction,
-} from '@solana/web3.js';
-import {
-    TOKEN_2022_PROGRAM_ID,
-    ASSOCIATED_TOKEN_PROGRAM_ID,
-    getAssociatedTokenAddressSync,
-} from '@solana/spl-token';
-import {
-    DISTRIBUTION_PROGRAM_ID,
-    STAKE_CONTROLLER_PROGRAM_ID,
-    DistributionIDL,
-    Distribution,
-    YIELD_ORACLE_PROGRAM_ID,
-    LIQSOL_TOKEN_PROGRAM_ID,
-} from '../constants';
-import {
-    deriveDistributionStatePDA,
-    deriveUserRecordPDA,
-    deriveLiqsolMintAuthorityPDA,
-} from '../utils';
+import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
+import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
 
+import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
+import type { DistributionState, DistributionUserRecord, GlobalConfig, PayRateEntry, PayRateHistory } from '../types';
+import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
+import { ceilDiv } from '../utils';
+
+const INDEX_SCALE_BN = new BN('1000000000000');
+
+/**
+ * Distribution client – wraps the distribution portion of the liqsol_core
+ * 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
+ *
+ * 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 {
-    constructor(private provider: AnchorProvider) { }
-
-    /** Wrapped Anchor Program for Distribution */
-    private get program(): Program<Distribution> {
-        const idlWithAddress = {
-            ...JSON.parse(JSON.stringify(DistributionIDL)),
-            address: DISTRIBUTION_PROGRAM_ID.toString(),
-        };
-        return new Program(idlWithAddress as any, this.provider) as Program<Distribution>;
+    private program: Program<LiqsolCoreClientIdl>;
+
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('liqsolCore');
     }
 
-    /** Derive the PDA for global distribution state */
-    deriveStatePDA(): PublicKey {
-        return deriveDistributionStatePDA()[0];
+    get connection() {
+        return this.provider.connection;
     }
 
-    /** Derive the PDA for a user’s record */
-    deriveUserRecordPDA(user: PublicKey): PublicKey {
-        return deriveUserRecordPDA(user)[0];
+    private async getTokenBalance(ata: PublicKey): Promise<BN> {
+        try {
+            const bal = await this.connection.getTokenAccountBalance(ata);
+            return new BN(bal.value.amount);
+        } catch {
+            return new BN(0);
+        }
     }
 
-    /** Fetch on-chain distribution state */
-    async getState(): Promise<any> {
-        return this.program.account.distributionState.fetch(this.deriveStatePDA());
+    /**
+     * Fetch the global distribution state account.
+     *
+     * IDL account name: "distributionState"
+     */
+    async getDistributionState(): Promise<DistributionState | null> {
+        const pda = this.pgs.deriveDistributionStatePda();
+        try {
+            return await this.program.account.distributionState.fetch(pda);
+        } catch {
+            return null;
+        }
     }
 
-    /** Fetch a user’s record or return null if it doesn’t exist */
-    async getUserRecord(user: PublicKey): Promise<any | null> {
+
+    /**
+     * Fetch the global payRateHistory account (circular buffer of scaled pay rates).
+     *
+     * IDL account name: "payRateHistory"
+     */
+    async getPayRateHistory(): Promise<PayRateHistory | null> {
+        const pda = this.pgs.derivePayRateHistoryPda();
         try {
-            return await this.program.account.userRecord.fetch(
-                this.deriveUserRecordPDA(user)
-            );
+            // Anchor types map directly onto our PayRateHistory TS type
+            return (await this.program.account.payRateHistory.fetch(
+                pda,
+            )) as PayRateHistory;
         } catch {
             return null;
         }
     }
 
-    /** Build an `initialize` transaction for the distribution program */
-    async buildInitializeTransaction(user: PublicKey): Promise<Transaction> {
-        const [statePda] = deriveDistributionStatePDA();
-        const ix = await this.program.methods
-            .initialize()
-            .accounts({
-                authority: user,
-                distributionState: statePda,
-                systemProgram: SystemProgram.programId,
-                rent: web3.SYSVAR_RENT_PUBKEY,
-            } as any)
-            .instruction();
+    /**
+     * Fetch the globalConfig account (contains depositFeeMultiplier, etc).
+     *
+     * IDL account name: "globalConfig"
+     */
+    async getGlobalConfig(): Promise<GlobalConfig | null> {
+        const pda = this.pgs.deriveGlobalConfigPda();
+        try {
+            return (await this.program.account.globalConfig.fetch(
+                pda,
+            )) as any;
+        } catch {
+            return null;
+        }
+    }
+    /**
+     * Fetch a user's distribution userRecord (or null if missing).
+     *
+     * IDL account name: "userRecord"
+     */
+    async getUserRecord(
+        ownerOrAta: PublicKey,
+    ): Promise<DistributionUserRecord | null> {
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
 
-        return new Transaction().add(ix);
+        // 1) Try treating ownerOrAta as a WALLET: derive its liqSOL ATA, then userRecord.
+        try {
+            const ata = getAssociatedTokenAddressSync(
+                liqsolMint,
+                ownerOrAta,
+                true,
+                TOKEN_2022_PROGRAM_ID,
+            );
+            const pdaFromWallet = this.pgs.deriveUserRecordPda(ata);
+            const recFromWallet =
+                await this.program.account.userRecord.fetchNullable(pdaFromWallet);
+            if (recFromWallet) {
+                return recFromWallet;
+            }
+        } catch {
+            // fall through
+        }
+
+        // 2) Fallback: treat ownerOrAta as already being the TOKEN ACCOUNT.
+        try {
+            const pdaFromAta = this.pgs.deriveUserRecordPda(ownerOrAta);
+            return await this.program.account.userRecord.fetchNullable(pdaFromAta);
+        } catch {
+            return null;
+        }
     }
 
-    /** Build an `updateUser` transaction (register or refresh a user record) */
-    async buildUpdateUserTransaction(user: PublicKey): Promise<Transaction> {
-        const statePda = this.deriveStatePDA();
-        const userPda = this.deriveUserRecordPDA(user);
+    /**
+     * Convenience: get the user's current distribution shares.
+     *
+     * Returns BN(0) if the user has no userRecord yet.
+     */
+    async getUserShares(user: PublicKey): Promise<BN> {
+        const record = await this.getUserRecord(user);
+        return record ? record.shares : new BN(0);
+    }
 
-        // Fetch state to get the liqSOL mint address
-        const state: any = await this.getState();
-        const liqsolMint: PublicKey = state.liqsolMint;
-        const userAta = getAssociatedTokenAddressSync(
-            liqsolMint,
-            user,
-            false,
-            TOKEN_2022_PROGRAM_ID,
-            ASSOCIATED_TOKEN_PROGRAM_ID
-        );
+    /**
+     * Convenience: get both the user's shares and totalShares, plus a
+     * floating-point ratio (userShares / totalShares).
+     *
+     * NOTE: ratio is a JS number and may lose precision for very large values,
+     * but is fine for display / percentage UIs.
+     */
+    async getUserSharePosition(user: PublicKey): Promise<{
+        shares: BN;
+        totalShares: BN;
+        ratio: number;
+    }> {
+        const [dist, userShares] = await Promise.all([
+            this.getDistributionState(),
+            this.getUserShares(user),
+        ]);
 
-        const [stakeControllerStatePda] = PublicKey.findProgramAddressSync(
-            [Buffer.from('stake_controller')],
-            STAKE_CONTROLLER_PROGRAM_ID
-        );
+        const totalShares = dist ? dist.totalShares : new BN(0);
 
-        const ix = await this.program.methods
-            .updateUser()
-            .accounts({
-                user,
-                userAta,
-                userRecord: userPda,
-                authority: user,
-                payer: user,
-                distributionState: statePda,
-                stakeControllerState: stakeControllerStatePda,
-                tokenProgram: TOKEN_2022_PROGRAM_ID,
-                yieldOracleProgram: YIELD_ORACLE_PROGRAM_ID,
-                systemProgram: SystemProgram.programId,
-            } as any)
-            .instruction();
+        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 new Transaction().add(ix);
+        return { shares: userShares, totalShares, ratio };
     }
 
-    /** Build a `withdraw` transaction */
-    async buildWithdrawTransaction(user: PublicKey, amount: number): Promise<Transaction> {
-        const statePda = this.deriveStatePDA();
-        const userPda = this.deriveUserRecordPDA(user);
+    /**
+     * Compute claimable liqSOL for a wallet:
+     * claimable = max(0, entitled - actual)
+     * entitled = floor(shares * syncedIndex / 1e12)
+     *
+     * `syncedIndex` mirrors on-chain `sync_index` behavior by incorporating any
+     * unsynced bucket delta (bucket_balance - last_bucket_balance).
+     */
+    async getClaimableLiqsol(user: PublicKey): Promise<BN> {
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
 
-        // Fetch state for the mint
-        const state: any = await this.getState();
-        const liqsolMint: PublicKey = state.liqsolMint;
         const userAta = getAssociatedTokenAddressSync(
             liqsolMint,
             user,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
-            ASSOCIATED_TOKEN_PROGRAM_ID
-        );
-
-        const [stakeControllerStatePda] = PublicKey.findProgramAddressSync(
-            [Buffer.from('stake_controller')],
-            STAKE_CONTROLLER_PROGRAM_ID
         );
-        const [controllerAuthPda] = PublicKey.findProgramAddressSync(
-            [Buffer.from('stake_authority')],
-            STAKE_CONTROLLER_PROGRAM_ID
+        const bucketTokenAccount = getAssociatedTokenAddressSync(
+            liqsolMint,
+            bucketAuthority,
+            true,
+            TOKEN_2022_PROGRAM_ID,
         );
 
-        const ix = await this.program.methods
-            .withdraw(new BN(amount))
-            .accounts({
-                user,
-                userAta,
-                userRecord: userPda,
-                distributionState: statePda,
-                liqsolMint,
-                tokenProgram: TOKEN_2022_PROGRAM_ID,
-                stakeControllerProgram: STAKE_CONTROLLER_PROGRAM_ID,
-                stakeControllerState: stakeControllerStatePda,
-                controllerAuthority: controllerAuthPda,
-                yieldOracleProgram: YIELD_ORACLE_PROGRAM_ID,
-                systemProgram: SystemProgram.programId,
-            } as any)
-            .instruction();
+        const [distributionState, userRecord, actualBalance, bucketBalance] = await Promise.all([
+            this.getDistributionState(),
+            this.getUserRecord(user),
+            this.getTokenBalance(userAta),
+            this.getTokenBalance(bucketTokenAccount),
+        ]);
+
+        if (!distributionState || !userRecord) {
+            return new BN(0);
+        }
 
-        return new Transaction().add(ix);
+        let syncedIndex = new BN(distributionState.currentIndex.toString());
+        const totalShares = new BN(distributionState.totalShares.toString());
+        const lastBucketBalance = new BN(distributionState.lastBucketBalance.toString());
+
+        if (totalShares.gt(new BN(0)) && bucketBalance.gt(lastBucketBalance)) {
+            const delta = bucketBalance.sub(lastBucketBalance);
+            const indexDelta = delta.mul(INDEX_SCALE_BN).div(totalShares);
+            if (indexDelta.gt(new BN(0))) {
+                syncedIndex = syncedIndex.add(indexDelta);
+            }
+        }
+
+        const shares = new BN(userRecord.shares.toString());
+        const entitled = shares.mul(syncedIndex).div(INDEX_SCALE_BN);
+
+        if (entitled.lte(actualBalance)) {
+            return new BN(0);
+        }
+        return entitled.sub(actualBalance);
     }
 
-    /** Build a `claimRewards` transaction */
-    async buildClaimRewardsTransaction(user: PublicKey): Promise<Transaction> {
-        const statePda = this.deriveStatePDA();
-        const userPda = this.deriveUserRecordPDA(user);
+    /**
+     * Build claim_rewards instruction for a wallet.
+     */
+    async buildClaimRewardsIx(user: PublicKey): Promise<TransactionInstruction> {
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
+        const distributionState = this.pgs.deriveDistributionStatePda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
 
-        // Fetch state for the mint
-        const state: any = await this.getState();
-        const liqsolMint: PublicKey = state.liqsolMint;
         const userAta = getAssociatedTokenAddressSync(
             liqsolMint,
             user,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
-            ASSOCIATED_TOKEN_PROGRAM_ID
         );
-        const [mintAuthPda] = deriveLiqsolMintAuthorityPDA();
+        const bucketTokenAccount = getAssociatedTokenAddressSync(
+            liqsolMint,
+            bucketAuthority,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+
+        const userRecord = this.pgs.deriveUserRecordPda(userAta);
+        const bucketUserRecord = this.pgs.deriveUserRecordPda(bucketTokenAccount);
+        const extraAccountMetaList = this.pgs.deriveExtraAccountMetaListPda(liqsolMint);
 
-        const ix = await this.program.methods
+        return this.program.methods
             .claimRewards()
             .accounts({
                 user,
                 userAta,
-                userRecord: userPda,
-                distributionState: statePda,
+                userRecord,
+                bucketUserRecord,
+                distributionState,
+                extraAccountMetaList,
+                liqsolCoreProgram: this.pgs.PROGRAM_IDS.LIQSOL_CORE,
+                transferHookProgram: this.pgs.PROGRAM_IDS.TRANSFER_HOOK,
                 liqsolMint,
-                liqsolProgram: LIQSOL_TOKEN_PROGRAM_ID,
-                liqsolMintAuthority: mintAuthPda,
-                instructionsSysvar: web3.SYSVAR_INSTRUCTIONS_PUBKEY,
-                yieldOracleProgram: YIELD_ORACLE_PROGRAM_ID,
+                bucketAuthority,
+                bucketTokenAccount,
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
-                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-                systemProgram: SystemProgram.programId,
-            } as any)
+                systemProgram: SystemProgram.programId
+            })
             .instruction();
-
-        return new Transaction().add(ix);
     }
 
-    /** Send & confirm a single-IX transaction; returns the tx 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);
-    }
+    /**
+     * Compute an average scaled pay rate over the most recent `windowSize`
+     * valid entries in the pay-rate history circular buffer.
+     *
+     * Returns a BN scaled by 1e12 (same as on-chain).
+     */
+    async getAverageScaledPayRate(windowSize = 5): Promise<BN> {
+        const history = await this.getPayRateHistory();
+        if (!history) {
+            return new BN(0);
+        }
+
+        const entries: PayRateEntry[] = history.entries ?? [];
+        if (!entries.length) {
+            return new BN(0);
+        }
+
+        const maxEntries: number =
+            typeof history.maxEntries === 'number'
+                ? history.maxEntries
+                : entries.length;
+
+        const rawTotalAdded: any = history.totalEntriesAdded ?? 0;
+        const totalAddedBn = new BN(rawTotalAdded.toString());
+
+        // No valid entries written yet
+        if (totalAddedBn.isZero()) {
+            return new BN(0);
+        }
+
+        const totalAdded = Math.min(
+            totalAddedBn.toNumber(),
+            maxEntries,
+            entries.length,
+        );
+
+        if (!totalAdded) {
+            return new BN(0);
+        }
+
+        const COUNT = Math.max(1, Math.min(windowSize, totalAdded));
+
+        const currentIndexNum = Number(history.currentIndex ?? 0);
+
+        // Most recently written entry is at currentIndex - 1 (mod maxEntries)
+        let idx =
+            currentIndexNum === 0
+                ? maxEntries - 1
+                : currentIndexNum - 1;
+
+        let sum = new BN(0);
+        let valid = 0;
+        const zero = new BN(0);
+
+        for (let i = 0; i < COUNT; i++) {
+            const entry: any = entries[idx];
+            if (entry) {
+                // Support both camelCase and snake_case (for safety)
+                const rawScaled =
+                    entry.scaledRate ??
+                    entry.scaled_rate ??
+                    0;
+
+                const rate = new BN(rawScaled.toString());
+                if (rate.gt(zero)) {
+                    sum = sum.add(rate);
+                    valid += 1;
+                }
+            }
+
+            // Walk backwards through the circular buffer
+            idx = idx === 0 ? maxEntries - 1 : idx - 1;
+        }
+
+        if (!valid) {
+            return new BN(0);
+        }
 
-    /** Simulate a single-IX transaction; returns error (if any) + compute units used */
-    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! };
+        // Same behavior as the dashboard: use a ceiling-like average
+        return ceilDiv(sum, new BN(valid));
     }
-}
+}