@wireio/stake 1.1.0 → 2.1.0

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

@@ -1,15 +1,8 @@
 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 {
-    deriveDistributionStatePda,
-    deriveGlobalConfigPda,
-    deriveLiqsolMintPda,
-    derivePayRateHistoryPda,
-    deriveUserRecordPda,
-} from '../constants';
+import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
+import type { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
 import type { DistributionState, DistributionUserRecord, GlobalConfig, PayRateEntry, PayRateHistory } from '../types';
 import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
 import { ceilDiv } from '../utils';
@@ -33,11 +26,13 @@ import { ceilDiv } from '../utils';
  *  - DistributionState + UserRecord track *shares* for yield.
  */
 export class DistributionClient {
-    private program: Program<LiqsolCore>;
+    private program: Program<LiqsolCoreClientIdl>;
 
-    constructor(private provider: AnchorProvider) {
-        const svc = new SolanaProgramService(provider);
-        this.program = svc.getProgram('liqsolCore');
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('liqsolCore');
     }
 
     get connection() {
@@ -50,7 +45,7 @@ export class DistributionClient {
      * IDL account name: "distributionState"
      */
     async getDistributionState(): Promise<DistributionState | null> {
-        const pda = deriveDistributionStatePda();
+        const pda = this.pgs.deriveDistributionStatePda();
         try {
             return await this.program.account.distributionState.fetch(pda);
         } catch {
@@ -65,7 +60,7 @@ export class DistributionClient {
      * IDL account name: "payRateHistory"
      */
     async getPayRateHistory(): Promise<PayRateHistory | null> {
-        const pda = derivePayRateHistoryPda();
+        const pda = this.pgs.derivePayRateHistoryPda();
         try {
             // Anchor types map directly onto our PayRateHistory TS type
             return (await this.program.account.payRateHistory.fetch(
@@ -82,7 +77,7 @@ export class DistributionClient {
      * IDL account name: "globalConfig"
      */
     async getGlobalConfig(): Promise<GlobalConfig | null> {
-        const pda = deriveGlobalConfigPda();
+        const pda = this.pgs.deriveGlobalConfigPda();
         try {
             return (await this.program.account.globalConfig.fetch(
                 pda,
@@ -99,17 +94,17 @@ export class DistributionClient {
     async getUserRecord(
         ownerOrAta: PublicKey,
     ): Promise<DistributionUserRecord | null> {
-        const liqsolMint = deriveLiqsolMintPda();
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
 
         // 1) Try treating ownerOrAta as a WALLET: derive its liqSOL ATA, then userRecord.
         try {
             const ata = getAssociatedTokenAddressSync(
                 liqsolMint,
                 ownerOrAta,
-                false,
+                true,
                 TOKEN_2022_PROGRAM_ID,
             );
-            const pdaFromWallet = deriveUserRecordPda(ata);
+            const pdaFromWallet = this.pgs.deriveUserRecordPda(ata);
             const recFromWallet =
                 await this.program.account.userRecord.fetchNullable(pdaFromWallet);
             if (recFromWallet) {
@@ -121,7 +116,7 @@ export class DistributionClient {
 
         // 2) Fallback: treat ownerOrAta as already being the TOKEN ACCOUNT.
         try {
-            const pdaFromAta = deriveUserRecordPda(ownerOrAta);
+            const pdaFromAta = this.pgs.deriveUserRecordPda(ownerOrAta);
             return await this.program.account.userRecord.fetchNullable(pdaFromAta);
         } catch {
             return null;

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

@@ -1,12 +1,8 @@
 import { AnchorProvider, Program } from '@coral-xyz/anchor';
 import { PublicKey } from '@solana/web3.js';
 
-import { SolanaProgramService } from '../program';
-import type { ValidatorLeaderboard } from '../../../assets/solana/types/validator_leaderboard';
-import {
-    deriveLeaderboardStatePda,
-    deriveValidatorRecordPda,
-} from '../constants';
+import { SolanaProgramService, ValidatorLeaderboardClientIdl } from '../program';
+import type { ValidatorLeaderboard } from '../../../assets/solana/devnet/types/validator_leaderboard';
 import { LeaderboardState, ValidatorRecord } from '../types';
 
 /**
@@ -15,15 +11,17 @@ import { LeaderboardState, ValidatorRecord } from '../types';
  * Adjust account names/fields to match your IDL (state, validatorRecord, etc).
  */
 export class LeaderboardClient {
-    private program: Program<ValidatorLeaderboard>;
+    private program: Program<ValidatorLeaderboardClientIdl>;
 
-    constructor(private provider: AnchorProvider) {
-        const svc = new SolanaProgramService(provider);
-        this.program = svc.getProgram('validatorLeaderboard');
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('validatorLeaderboard');
     }
 
     async getState(): Promise<LeaderboardState | null> {
-        const pda = deriveLeaderboardStatePda();
+        const pda = this.pgs.deriveLeaderboardStatePda();
         try {
             // Assumes account name "leaderboardState"
             return await this.program.account.leaderboardState.fetch(pda);
@@ -33,7 +31,7 @@ export class LeaderboardClient {
     }
 
     async getValidatorRecord(voteAccount: PublicKey): Promise<ValidatorRecord | null> {
-        const pda = deriveValidatorRecordPda(voteAccount);
+        const pda = this.pgs.deriveValidatorRecordPda(voteAccount);
         try {
             // Assumes account name "validatorRecord"
             return await this.program.account.validatorRecord.fetchNullable(pda);
@@ -57,7 +55,7 @@ export class LeaderboardClient {
     async getTopValidators(limit = 20): Promise<ValidatorRecord[]> {
         // Try to use the leaderboard state first
         try {
-            const leaderboardPda = deriveLeaderboardStatePda();
+            const leaderboardPda = this.pgs.deriveLeaderboardStatePda();
             const leaderboard: LeaderboardState 
                 = await this.program.account.leaderboardState.fetch(leaderboardPda);
 

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

@@ -9,8 +9,7 @@ import {
     TOKEN_2022_PROGRAM_ID,
 } from '@solana/spl-token';
 
-import liqsolCoreIDL from '../../../assets/solana/idl/liqsol_core.json';
-import { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
+import { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
 
 import {
     OutpostAccounts,
@@ -23,7 +22,8 @@ import {
     TrancheState,
     WalletLike,
 } from '../types';
-import { INDEX_SCALE, PROGRAM_IDS } from '../constants';
+import { INDEX_SCALE } from '../constants';
+import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
 
 /**
  * OutpostClient
@@ -41,12 +41,13 @@ import { INDEX_SCALE, PROGRAM_IDS } from '../constants';
  * in sync with the on-chain PDAs and capital-staking Wire utils.
  */
 export class OutpostClient {
-    private readonly program: Program<LiqsolCore>;
+    private readonly program: Program<LiqsolCoreClientIdl>;
 
     constructor(
         private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService,
     ) {
-        this.program = new Program(liqsolCoreIDL as any, provider);
+        this.program = pgs.getProgram('liqsolCore');
     }
 
     get connection() {
@@ -57,14 +58,6 @@ export class OutpostClient {
         return this.provider.wallet as unknown as WalletLike;
     }
 
-    /**
-     * Expose the raw Program in case callers need to build custom
-     * instructions outside this client.
-     */
-    get liqsolCoreProgram(): Program<LiqsolCore> {
-        return this.program;
-    }
-
     /**
      * Build all outpost-related PDAs / ATAs for a given user.
      * Defaults to the connected wallet.
@@ -74,7 +67,7 @@ export class OutpostClient {
         if (!userPk) {
             throw new Error('OutpostClient.buildAccounts: wallet not connected');
         }
-        return buildOutpostAccounts(this.connection, userPk);
+        return buildOutpostAccounts(this.connection, userPk, this.pgs);
     }
 
     /**
@@ -170,8 +163,8 @@ export class OutpostClient {
                 senderUserRecord: a.userUserRecord,
                 receiverUserRecord: a.liqsolPoolUserRecord,
                 extraAccountMetaList: a.extraAccountMetaList,
-                liqsolCoreProgram: PROGRAM_IDS.LIQSOL_CORE,
-                transferHookProgram: PROGRAM_IDS.TRANSFER_HOOK,
+                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,
@@ -211,12 +204,13 @@ export class OutpostClient {
                 senderUserRecord: a.liqsolPoolUserRecord,
                 receiverUserRecord: a.userUserRecord,
                 extraAccountMetaList: a.extraAccountMetaList,
-                liqsolCoreProgram: PROGRAM_IDS.LIQSOL_CORE,
-                transferHookProgram: PROGRAM_IDS.TRANSFER_HOOK,
+                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,
             })
             .instruction();
     }
@@ -277,7 +271,7 @@ export class OutpostClient {
      *   if remainder > 0 → shares + 1
      */
     static tokensToShares(amount: BN, currentIndex: BN): BN {
-        const numerator = amount.mul(INDEX_SCALE);
+        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);

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

@@ -11,8 +11,8 @@ import {
     type OutpostAccounts,
 } from '../utils';
 
-import { SolanaProgramService } from '../program';
-import type { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
+import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
+import type { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
 
 import {
     GlobalState,
@@ -24,16 +24,12 @@ import {
 } from '../types';
 
 import {
-    derivePriceHistoryPda,
     CHAINLINK_FEED,
     CHAINLINK_PROGRAM,
-    PROGRAM_IDS,
-    deriveExtraAccountMetaListPda,
 } from '../constants';
 
-
 export class TokenClient {
-    private readonly program: Program<LiqsolCore>;
+    private readonly program: Program<LiqsolCoreClientIdl>;
 
     get wallet(): WalletLike {
         return this.provider.wallet;
@@ -43,9 +39,11 @@ export class TokenClient {
         return this.provider.connection;
     }
 
-    constructor(private readonly provider: AnchorProvider) {
-        const svc = new SolanaProgramService(provider);
-        this.program = svc.getProgram('liqsolCore');
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('liqsolCore');
     }
 
     // ---------------------------------------------------------------------------
@@ -53,7 +51,7 @@ export class TokenClient {
     // ---------------------------------------------------------------------------
 
     async getAccounts(user: PublicKey): Promise<OutpostAccounts> {
-        return buildOutpostAccounts(this.provider.connection, user);
+        return buildOutpostAccounts(this.provider.connection, user, this.pgs);
     }
 
     async fetchGlobalState(): Promise<GlobalState> {
@@ -104,9 +102,9 @@ export class TokenClient {
     ): Promise<TransactionInstruction> {
         const a = await this.getAccounts(user);
 
-        const extraAccountMetaList = deriveExtraAccountMetaListPda(a.liqsolMint);
-        const liqsolCoreProgram = PROGRAM_IDS.LIQSOL_CORE;
-        const transferHookProgram = PROGRAM_IDS.TRANSFER_HOOK;
+        const extraAccountMetaList = this.pgs.deriveExtraAccountMetaListPda(a.liqsolMint);
+        const liqsolCoreProgram = this.pgs.PROGRAM_IDS.LIQSOL_CORE;
+        const transferHookProgram = this.pgs.PROGRAM_IDS.TRANSFER_HOOK;
 
         return this.program.methods
             .purchase(new BN(amountLamports.toString()))
@@ -177,7 +175,7 @@ export class TokenClient {
      * Uses the ring-buffer semantics from capital-staking.
      */
     async getSolPriceUsd(): Promise<bigint> {
-        const priceHistoryPda = derivePriceHistoryPda();
+        const priceHistoryPda = this.pgs.derivePriceHistoryPda();
         const history = (await this.program.account.priceHistory.fetch(
             priceHistoryPda,
         )) as PriceHistory;

package/src/networks/solana/constants.ts

@@ -1,40 +1,58 @@
 // src/networks/solana/constants.ts
 import { PublicKey, StakeProgram } from '@solana/web3.js';
+import { SolChainID } from '@wireio/core';
 
-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';
-import transferHookIDL from '../../assets/solana/idl/transfer_hook.json';
+import mainnetLiqsolCoreIDL from '../../assets/solana/mainnet/idl/liqsol_core.json';
+import mainnetLiqSolTokenIDL from '../../assets/solana/mainnet/idl/liqsol_token.json';
+import mainnetValidatorLeaderboardIDL from '../../assets/solana/mainnet/idl/validator_leaderboard.json';
+import mainnetTransferHookIDL from '../../assets/solana/mainnet/idl/transfer_hook.json';
+
+import devnetLiqsolCoreIDL from '../../assets/solana/devnet/idl/liqsol_core.json';
+import devnetLiqSolTokenIDL from '../../assets/solana/devnet/idl/liqsol_token.json';
+import devnetValidatorLeaderboardIDL from '../../assets/solana/devnet/idl/validator_leaderboard.json';
+import devnetTransferHookIDL from '../../assets/solana/devnet/idl/transfer_hook.json';
+import { SupportedSolChainID } from '../../types';
 
 /**
- * ---------------------------------------------------------------------------
- *  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
+ * Per-chain program IDs (NOT global anymore).
  */
-export const PROGRAM_IDS = {
-    LIQSOL_CORE: new PublicKey(liqsolCoreIDL.address),
-    LIQSOL_TOKEN: new PublicKey(liqSolTokenIDL.address),
-    VALIDATOR_LEADERBOARD: new PublicKey(validatorLeaderboardIDL.address),
-    TRANSFER_HOOK: new PublicKey(transferHookIDL.address),
-} as const;
+export type SolanaProgramIds = {
+    LIQSOL_CORE: PublicKey;
+    LIQSOL_TOKEN: PublicKey;
+    VALIDATOR_LEADERBOARD: PublicKey;
+    TRANSFER_HOOK: PublicKey;
+};
 
-export const {
-    LIQSOL_CORE,
-    LIQSOL_TOKEN,
-    VALIDATOR_LEADERBOARD,
-    TRANSFER_HOOK,
-} = PROGRAM_IDS;
+const MAINNET_PROGRAM_IDS: SolanaProgramIds = {
+    LIQSOL_CORE: new PublicKey(mainnetLiqsolCoreIDL.address),
+    LIQSOL_TOKEN: new PublicKey(mainnetLiqSolTokenIDL.address),
+    VALIDATOR_LEADERBOARD: new PublicKey(mainnetValidatorLeaderboardIDL.address),
+    TRANSFER_HOOK: new PublicKey(mainnetTransferHookIDL.address),
+};
+
+const DEVNET_PROGRAM_IDS: SolanaProgramIds = {
+    LIQSOL_CORE: new PublicKey(devnetLiqsolCoreIDL.address),
+    LIQSOL_TOKEN: new PublicKey(devnetLiqSolTokenIDL.address),
+    VALIDATOR_LEADERBOARD: new PublicKey(devnetValidatorLeaderboardIDL.address),
+    TRANSFER_HOOK: new PublicKey(devnetTransferHookIDL.address),
+};
+
+export const PROGRAM_IDS_BY_CHAIN: Record<SupportedSolChainID, SolanaProgramIds> = {
+    [SolChainID.Mainnet]: MAINNET_PROGRAM_IDS,
+    [SolChainID.Devnet]: DEVNET_PROGRAM_IDS,
+};
+
+export const getProgramIds = (chainId: SolChainID): SolanaProgramIds => {
+    const ids = PROGRAM_IDS_BY_CHAIN[chainId];
+    if (!ids) throw new Error(`Unsupported Solana chainId=${chainId}`);
+    return ids;
+};
 
 /**
  * ---------------------------------------------------------------------------
  *  PDA SEEDS (must match on-chain programs)
  * ---------------------------------------------------------------------------
  */
-
 export const PDA_SEEDS = {
     // GLOBAL CONFIG
     GLOBAL_CONFIG: 'global_config',
@@ -53,7 +71,6 @@ export const PDA_SEEDS = {
 
     // distribution program (embedded in liqsol_core)
     DISTRIBUTION_STATE: 'distribution_state',
-    // NOTE: in the current IDL, userRecord is keyed by the USER (wallet), not ATA
     USER_RECORD: 'user_record',
 
     // pay-rate / price history
@@ -91,257 +108,9 @@ export const PDA_SEEDS = {
     WITHDRAW_MINT: 'mint',
 } as const;
 
-// Global Config PDA
-export const deriveGlobalConfigPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.GLOBAL_CONFIG)],
-        LIQSOL_CORE,
-    )[0];
-
-
-/**
- * ---------------------------------------------------------------------------
- *  CORE / DISTRIBUTION / DEPOSIT PDAS
- * ---------------------------------------------------------------------------
- */
-
-export const deriveLiqsolMintPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.LIQSOL_MINT)],
-        LIQSOL_TOKEN,
-    )[0];
-
-export const deriveLiqsolMintAuthorityPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.LIQSOL_MINT_AUTHORITY)],
-        LIQSOL_TOKEN,
-    )[0];
-
-export const deriveDepositAuthorityPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.DEPOSIT_AUTHORITY)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveVaultPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.VAULT)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveReservePoolPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.RESERVE_POOL)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveStakeControllerStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.STAKE_CONTROLLER_STATE)],
-        LIQSOL_CORE,
-    )[0];
-
-export const derivePayoutStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.PAYOUT_STATE)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveBucketAuthorityPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.BUCKET_AUTHORITY)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveDistributionStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.DISTRIBUTION_STATE)],
-        LIQSOL_CORE,
-    )[0];
-
-/**
- * user_record PDA
- *
- * In the current liqsol_core IDL, this is keyed by USER (wallet),
- * not by token account.
- */
-export const deriveUserRecordPda = (user: PublicKey) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.USER_RECORD), user.toBuffer()],
-        LIQSOL_CORE,
-    )[0];
-
-export const derivePayRateHistoryPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.PAY_RATE_HISTORY)],
-        LIQSOL_CORE,
-    )[0];
-
-/**
- * ---------------------------------------------------------------------------
- *  WITHDRAW MODULE / RECEIPTS
- * ---------------------------------------------------------------------------
- */
-
-export const deriveWithdrawGlobalPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.WITHDRAW_GLOBAL)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveStakeAllocationStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.STAKE_ALLOCATION_STATE)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveStakeMetricsPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.STAKE_METRICS)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveMaintenanceLedgerPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.MAINTENANCE_LEDGER)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveWithdrawMintAuthorityPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.WITHDRAW_MINT_AUTHORITY)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveWithdrawMintMetadataPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.MINT_METADATA)],
-        LIQSOL_CORE,
-    )[0];
-
 /**
- * NFT mint for withdrawal receipt, derived from nextReceiptId.
- */
-export const deriveWithdrawNftMintPda = (receiptId: bigint | number) => {
-    const receiptIdBytes = Buffer.alloc(8);
-    // receiptId comes in as BN or bigint upstream → normalize
-    const asBigInt =
-        typeof receiptId === 'bigint'
-            ? receiptId
-            : BigInt(receiptId.toString());
-    receiptIdBytes.writeBigUInt64LE(asBigInt);
-    return PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.WITHDRAW_MINT), receiptIdBytes],
-        LIQSOL_CORE,
-    )[0];
-};
-
-export const deriveLiqReceiptDataPda = (nftMint: PublicKey) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.LIQ_RECEIPT_DATA), nftMint.toBuffer()],
-        LIQSOL_CORE,
-    )[0];
-
-/**
- * ---------------------------------------------------------------------------
- *  VALIDATOR LEADERBOARD
- * ---------------------------------------------------------------------------
- */
-
-export const deriveLeaderboardStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.LEADERBOARD_STATE)],
-        VALIDATOR_LEADERBOARD,
-    )[0];
-
-export const deriveValidatorRecordPda = (voteAccount: PublicKey) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.VALIDATOR_RECORD), voteAccount.toBuffer()],
-        VALIDATOR_LEADERBOARD,
-    )[0];
-
-export const deriveStakeControllerVaultPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.VAULT)],
-        LIQSOL_CORE,
-    )[0];
-
-/**
- * ---------------------------------------------------------------------------
- *  OUTPOST / PRETOKENS
- * ---------------------------------------------------------------------------
- */
-
-export const deriveOutpostGlobalStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.OUTPOST_GLOBAL_STATE)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveOutpostPoolAuthorityPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.LIQSOL_POOL)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveOutpostAccountPda = (user: PublicKey) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.OUTPOST_ACCOUNT), user.toBuffer()],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveUserPretokenRecordPda = (user: PublicKey) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.USER_PRETOKEN_RECORD), user.toBuffer()],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveTrancheStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.TRANCHE_STATE)],
-        LIQSOL_CORE,
-    )[0];
-
-export const derivePriceHistoryPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.PRICE_HISTORY)],
-        LIQSOL_CORE,
-    )[0];
-
-/**
- * BAR (bonded actor roles)
- */
-
-export const deriveBarConfigPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.BAR_STATE_SEED)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveBondLevelPda = (bondLevelId: number[]) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.BOND_LEVEL_SEED), Buffer.from(bondLevelId)],
-        LIQSOL_CORE,
-    )[0];
-
-export const deriveBondedActorPda = (actor: PublicKey) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.BONDED_ACTOR_SEED), actor.toBuffer()],
-        LIQSOL_CORE,
-    )[0];
-
-/**
- * SPL Transfer-hook: extra-account-metas PDA for the liqSOL mint.
- */
-export const deriveExtraAccountMetaListPda = (liqsolMint: PublicKey) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.EXTRA_ACCOUNT_METAS), liqsolMint.toBuffer()],
-        PROGRAM_IDS.TRANSFER_HOOK,
-    )[0];
-
-/**
- * Ephemeral stake account address used per-deposit.
- * On-chain convention: seed = `ephemeral_<u32>` under StakeProgram.programId.
+ * Ephemeral stake account address seed helper
+ * (this one really is global & chain-agnostic).
  */
 export const deriveEphemeralStakeAddress = async (
     user: PublicKey,
@@ -366,22 +135,12 @@ export const CHAINLINK_PROGRAM = new PublicKey(
  *  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)
 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 INDEX_SCALE = BigInt(1_000_000_000_000); // 1e12
 
 export const lamportsToSol = (lamports: number | bigint): number =>