@wireio/stake 0.0.5 → 0.1.0

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

@@ -1,76 +1,66 @@
-// src/solana/clients/ValidatorLeaderboardClient.ts
 import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
-import { PublicKey, Transaction, TransactionInstruction, SystemProgram, VersionedTransaction } from '@solana/web3.js';
+import { PublicKey, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js';
+import { SolanaProgramService } from '../program';
+import type { ValidatorLeaderboard } from '../../../assets/solana/types/validator_leaderboard';
 import {
     deriveLeaderboardHeadPDA,
     deriveValidatorRecordPDA,
     deriveTop10CachePDA,
-} from '../utils';
-import { VALIDATOR_LEADERBOARD_PROGRAM_ID, ValidatorLeaderboard, ValidatorLeaderboardIDL } from '../constants';
+} from '../constants';
 
 export class ValidatorLeaderboardClient {
-    constructor(private provider: AnchorProvider) { }
+    private programs: SolanaProgramService;
 
-    /**
-     * 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>;
+    constructor(private provider: AnchorProvider) {
+        this.programs = new SolanaProgramService(provider);
     }
 
-    /** Derive the PDA for the leaderboard head */
-    deriveHeadPDA(): PublicKey {
-        return deriveLeaderboardHeadPDA()[0];
+    /** Anchor Program<ValidatorLeaderboard> via ProgramService */
+    private get program(): Program<ValidatorLeaderboard> {
+        return this.programs.getProgram('validatorLeaderboard') as Program<ValidatorLeaderboard>;
     }
 
-    /** Derive the PDA for a given validator record */
-    deriveRecordPDA(voteAccount: PublicKey): PublicKey {
-        return deriveValidatorRecordPDA(voteAccount)[0];
-    }
+    // ───────────────────────────────────────────────────────────────────────────────
+    // BUILDERS (return Ixs so you can batch)
+    // ───────────────────────────────────────────────────────────────────────────────
 
-    /**
-     * Build the initialize instruction as a Transaction
-     */
-    async buildInitializeTransaction(authority: PublicKey): Promise<Transaction> {
-        const [headPda] = deriveLeaderboardHeadPDA();
-        const ix = await this.program.methods
+    /** Initialize the leaderboard head account. */
+    async buildInitializeIx(authority: PublicKey): Promise<TransactionInstruction> {
+        const [leaderboardHead] = deriveLeaderboardHeadPDA();
+        return this.program.methods
             .initialize()
             .accounts({
                 authority,
-                leaderboardHead: headPda,
+                // @ts-ignore
+                leaderboardHead,
                 systemProgram: SystemProgram.programId,
-            } as any)
+            })
             .instruction();
-
-        return new Transaction().add(ix);
     }
 
     /**
-     * Build an updateValidator transaction
+     * Upsert/update a validator record and (optionally) reposition it in the linked list.
+     * Any of insertAfter/insertBefore/currentPrev/currentNext can be omitted.
      */
-    async buildUpdateValidatorTransaction(params: {
-        authority: PublicKey;
+    async buildUpdateValidatorIx(params: {
         registrant: PublicKey;
         voteAccount: PublicKey;
-        vpp: number;
+        vpp: number; // Validator Performance Points
         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);
+    }): Promise<TransactionInstruction> {
+        const { registrant, voteAccount, vpp, insertAfter, insertBefore, currentPrev, currentNext } = params;
+
+        const [leaderboardHead] = deriveLeaderboardHeadPDA();
+        const [validatorRecord] = deriveValidatorRecordPDA(voteAccount);
 
         const accounts: any = {
             registrant,
             voteAccount,
-            validatorRecord: recPda,
-            leaderboardHead: headPda,
+            validatorRecord,
+            leaderboardHead,
             systemProgram: SystemProgram.programId,
             ...(insertAfter && { insertAfter }),
             ...(insertBefore && { insertBefore }),
@@ -78,70 +68,82 @@ export class ValidatorLeaderboardClient {
             ...(currentNext && { currentNext }),
         };
 
-        const ix = await this.program.methods
+        return this.program.methods
             .updateValidator(new BN(vpp))
             .accounts(accounts)
             .instruction();
-
-        return new Transaction().add(ix);
     }
 
-    /**
-     * Build an updateTop10Cache transaction
-     */
-    async buildUpdateTop10CacheTransaction(params: {
+    /** Update the Top-10 cache. Requires exactly 10 validator vote accounts. */
+    async buildUpdateTop10CacheIx(params: {
         authority: PublicKey;
         top10Validators: PublicKey[];
-    }): Promise<Transaction> {
+    }): Promise<TransactionInstruction> {
         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
+        if (top10Validators.length !== 10) throw new Error('Must provide exactly 10 validators');
+
+        const [cache] = deriveTop10CachePDA();
+        return this.program.methods
             .updateTop10Cache(top10Validators)
-            .accounts({ authority, cache: cachePda, systemProgram: SystemProgram.programId } as any)
+            .accounts({
+                // @ts-ignore
+                authority,
+                cache,
+                systemProgram: SystemProgram.programId,
+            })
             .instruction();
+    }
+
+    // Convenience wrappers if you want a ready-to-send Transaction
 
-        return new Transaction().add(ix);
+    async buildInitializeTx(authority: PublicKey): Promise<Transaction> {
+        return new Transaction().add(await this.buildInitializeIx(authority));
     }
 
-    /**
-     * 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();
+    async buildUpdateValidatorTx(params: {
+        registrant: PublicKey;
+        voteAccount: PublicKey;
+        vpp: number;
+        insertAfter?: PublicKey;
+        insertBefore?: PublicKey;
+        currentPrev?: PublicKey;
+        currentNext?: PublicKey;
+    }): Promise<Transaction> {
+        return new Transaction().add(await this.buildUpdateValidatorIx(params));
     }
 
-    /**
-     * Traverse the on-chain linked list and return the sequence of PublicKeys
-     */
+    async buildUpdateTop10CacheTx(params: {
+        authority: PublicKey;
+        top10Validators: PublicKey[];
+    }): Promise<Transaction> {
+        return new Transaction().add(await this.buildUpdateTop10CacheIx(params));
+    }
+
+    // ───────────────────────────────────────────────────────────────────────────────
+    // READ HELPERS
+    // ───────────────────────────────────────────────────────────────────────────────
+
+    /** Traverse the linked-list leaderboard, returning vote accounts in order. */
     async getLeaderboard(): Promise<PublicKey[]> {
-        const [headPda] = deriveLeaderboardHeadPDA();
-        let headAccount;
+        const [head] = deriveLeaderboardHeadPDA();
+        let headAcc;
         try {
-            headAccount = await this.program.account.leaderboardHead.fetch(headPda);
+            headAcc = await this.program.account.leaderboardHead.fetch(head);
         } catch {
             return [];
         }
-        const result: PublicKey[] = [];
-        let cursor: PublicKey = headAccount.nextValidator;
+        const out: PublicKey[] = [];
+        let cursor: PublicKey = headAcc.nextValidator;
         while (cursor && !cursor.equals(PublicKey.default)) {
-            result.push(cursor);
+            out.push(cursor);
             const rec = await this.program.account.validatorRecord.fetch(cursor);
             cursor = rec.nextValidator;
         }
-        return result;
+        return out;
     }
 
-    /**
-     * Fetch a single validator record or null
-     */
-    async getRecord(voteAccount: PublicKey): Promise<any | null> {
+    /** Fetch a single validator record (or null if it doesn't exist). */
+    async getValidatorRecord(voteAccount: PublicKey): Promise<any | null> {
         const [recPda] = deriveValidatorRecordPDA(voteAccount);
         try {
             return await this.program.account.validatorRecord.fetch(recPda);
@@ -149,31 +151,4 @@ export class ValidatorLeaderboardClient {
             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
-     */
-    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! };
-    }
-}
+}

package/src/networks/solana/constants.ts

@@ -1,73 +1,158 @@
 // src/networks/solana/constants.ts
-
 import { PublicKey } from '@solana/web3.js';
-import { TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import {
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    TOKEN_2022_PROGRAM_ID,
+    getAssociatedTokenAddressSync,
+} from '@solana/spl-token';
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
 
-// — IDLs — (must match your filesystem: src/assets/solana/idl/*.json)
+// IDLs (as generated artifacts)
 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 LiqSolTokenIDL from '../../assets/solana/idl/liq_sol_token.json';
+import DistributionIDL from '../../assets/solana/idl/distribution.json';
 import YieldOracleIDL from '../../assets/solana/idl/yield_oracle.json';
 
-// — Types — for your clients
+// Types (optional; keep the ones you use)
 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,
-};
 
-// — Program IDs — anchor “address” fields inside each IDL must match these:
+// ---------- Program IDs (from IDL.address) ----------
 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 LIQSOL_TOKEN_PROGRAM_ID = new PublicKey(LiqSolTokenIDL.address);
+export const DISTRIBUTION_PROGRAM_ID = new PublicKey(DistributionIDL.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
+// ---------- Protocol constants ----------
+export const MIN_SOL_TO_PARTICIPATE = 1_000_000_000; // 1 SOL (lamports)
+
+// The liqSOL Mint is a PDA on the LiqSOL token program
+export const LIQSOL_MINT_ADDRESS: PublicKey = PublicKey.findProgramAddressSync(
+    [Buffer.from('liq_sol_mint')],
+    LIQSOL_TOKEN_PROGRAM_ID
+)[0];
+
+// Re-export SPL ids
+export { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID };
+
+// ---------- Program factories ----------
+/** Create Anchor Program client for the Deposit program (with correct address) */
+export const getDepositProgram = (provider: AnchorProvider): Program<Deposit> => {
+    const idlWithAddress = { ...JSON.parse(JSON.stringify(DepositIDL)), address: DEPOSIT_PROGRAM_ID.toString() };
+    return new Program(idlWithAddress as any, provider) as Program<Deposit>;
+};
+
+// You can add similar helpers for other programs if you want:
+// export const getDistributionProgram = <T>(provider: AnchorProvider) => { ... }
+
+// ---------- PDA helpers ----------
+
+// Deposit
+export const deriveDepositAuthorityPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('program_authority')], 
+        DEPOSIT_PROGRAM_ID
+    );
+
+// LiqSOL Token program
+export const deriveLiqsolMintPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('liq_sol_mint')], 
+        LIQSOL_TOKEN_PROGRAM_ID
+    );
+
+/** ✅ FIXED: this must be derived with the LiqSOL token **program id**, not the mint address */
+export const deriveLiqsolMintAuthorityPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('mint_authority')], 
+        LIQSOL_TOKEN_PROGRAM_ID
+    );
+
+// Stake Controller
+export const deriveStakeControllerVaultPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('vault')], 
+        STAKE_CONTROLLER_PROGRAM_ID
+    );
+
+export const deriveStakeControllerReservePoolPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('reserve_pool')], 
+        STAKE_CONTROLLER_PROGRAM_ID
+    );
+
+export const deriveStakeControllerStatePDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('stake_controller')], 
+        STAKE_CONTROLLER_PROGRAM_ID
+    );
+
+export const deriveGlobalStakeInfoPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('global_stake_info')], 
+        STAKE_CONTROLLER_PROGRAM_ID
+    );
+
+export const deriveBucketAuthorityPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('liqsol_bucket')], 
+        STAKE_CONTROLLER_PROGRAM_ID
+    );
+
+export const derivePayRateHistoryPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('pay_rate_history')], 
+        STAKE_CONTROLLER_PROGRAM_ID
+    );
+
+// Distribution
+export const deriveDistributionStatePDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('distribution_state')], 
+        DISTRIBUTION_PROGRAM_ID
+    );
+
+export const deriveUserRecordPDA = (user: PublicKey): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('user_record'), user.toBuffer()], 
+        DISTRIBUTION_PROGRAM_ID
+    );
+
+// Validator Leaderboard
+export const deriveLeaderboardHeadPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('leaderboard_head')], 
+        VALIDATOR_LEADERBOARD_PROGRAM_ID
+    );
+
+export const deriveValidatorRecordPDA = (voteAccount: PublicKey): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('validator_record'), voteAccount.toBuffer()], 
+        VALIDATOR_LEADERBOARD_PROGRAM_ID
+    );
+
+export const deriveTop10CachePDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('top_10_cache')], 
+        VALIDATOR_LEADERBOARD_PROGRAM_ID
+    );
 
-// — 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');
+export const deriveStakeControllerAuthorityPDA = (): [PublicKey, number] =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from('stake_authority')],
+        STAKE_CONTROLLER_PROGRAM_ID
+    );
 
-// re-export SPL token constants:
-export { TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID };
+// ---------- SPL helper ----------
+/** User’s liqSOL ATA (Token-2022) */
+export const getUserLiqsolATA = (user: PublicKey): PublicKey =>
+    getAssociatedTokenAddressSync(
+        LIQSOL_MINT_ADDRESS,
+        user,
+    /* owner is PDA? */ false,
+        TOKEN_2022_PROGRAM_ID,
+        ASSOCIATED_TOKEN_PROGRAM_ID
+    );

package/src/networks/solana/program.ts

@@ -1,113 +1,60 @@
-// src/solana/programService.ts
-
 import { AnchorProvider, Program } from '@coral-xyz/anchor';
-import { PublicKey } from '@solana/web3.js';
-
-// 1) pull in all your on-chain IDLs (must match lowercase `src/assets/solana/idl`)
 import depositJson from '../../assets/solana/idl/deposit.json';
-import distributionJson from '../../assets/solana/idl/distribution.json';
-import liqSolTokenJson from '../../assets/solana/idl/liq_sol_token.json';
 import stakeControllerJson from '../../assets/solana/idl/stake_controller.json';
-import stakeRegistryJson from '../../assets/solana/idl/stake_registry.json';
-import treasuryJson from '../../assets/solana/idl/treasury.json';
+import liqSolTokenJson from '../../assets/solana/idl/liq_sol_token.json';
+import distributionJson from '../../assets/solana/idl/distribution.json';
 import validatorLeaderboardJson from '../../assets/solana/idl/validator_leaderboard.json';
-import validatorRegistryJson from '../../assets/solana/idl/validator_registry.json';
-import yieldOracleJson from '../../assets/solana/idl/yield_oracle.json';
 
-// 2) import their companion TS types
 import type { Deposit } from '../../assets/solana/types/deposit';
-import type { Distribution } from '../../assets/solana/types/distribution';
-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 { LiqSolToken } from '../../assets/solana/types/liq_sol_token';
+import type { Distribution } from '../../assets/solana/types/distribution';
 import type { ValidatorLeaderboard } from '../../assets/solana/types/validator_leaderboard';
-import type { ValidatorRegistry } from '../../assets/solana/types/validator_registry';
-import type { YieldOracle } from '../../assets/solana/types/yield_oracle';
 
-type IdlEntry<IDL> = {
-    idl: IDL & { address: string };
-    address: PublicKey;
-};
+import {
+    DEPOSIT_PROGRAM_ID,
+    STAKE_CONTROLLER_PROGRAM_ID,
+    LIQSOL_TOKEN_PROGRAM_ID,
+    DISTRIBUTION_PROGRAM_ID,
+    VALIDATOR_LEADERBOARD_PROGRAM_ID
+} from '../solana/constants';
 
-export const PROGRAM_IDLS = {
+type Entry<IDL> = { idl: IDL & { address: string }, address: string };
+
+const PROGRAMS = {
     deposit: {
         idl: depositJson,
-        address: new PublicKey(depositJson.address),
-    } as IdlEntry<Deposit>,
-
-    distribution: {
-        idl: distributionJson,
-        address: new PublicKey(distributionJson.address),
-    } as IdlEntry<Distribution>,
-
-    liqSolToken: {
-        idl: liqSolTokenJson,
-        address: new PublicKey(liqSolTokenJson.address),
-    } as IdlEntry<LiqSolToken>,
-
+        address: DEPOSIT_PROGRAM_ID.toBase58()
+    } as Entry<Deposit>,
     stakeController: {
         idl: stakeControllerJson,
-        address: new PublicKey(stakeControllerJson.address),
-    } as IdlEntry<StakeController>,
-
-    stakeRegistry: {
-        idl: stakeRegistryJson,
-        address: new PublicKey(stakeRegistryJson.address),
-    } as IdlEntry<StakeRegistry>,
-
-    treasury: {
-        idl: treasuryJson,
-        address: new PublicKey(treasuryJson.address),
-    } as IdlEntry<Treasury>,
-
+        address: STAKE_CONTROLLER_PROGRAM_ID.toBase58()
+    } as Entry<StakeController>,
+    liqSolToken: {
+        idl: liqSolTokenJson,
+        address: LIQSOL_TOKEN_PROGRAM_ID.toBase58()
+    } as Entry<LiqSolToken>,
+    distribution: {
+        idl: distributionJson,
+        address: DISTRIBUTION_PROGRAM_ID.toBase58()
+    } as Entry<Distribution>,
     validatorLeaderboard: {
         idl: validatorLeaderboardJson,
-        address: new PublicKey(validatorLeaderboardJson.address),
-    } as IdlEntry<ValidatorLeaderboard>,
-
-    validatorRegistry: {
-        idl: validatorRegistryJson,
-        address: new PublicKey(validatorRegistryJson.address),
-    } as IdlEntry<ValidatorRegistry>,
+        address:VALIDATOR_LEADERBOARD_PROGRAM_ID.toBase58()
+    } as Entry<ValidatorLeaderboard>,
+} as const;
 
-    yieldOracle: {
-        idl: yieldOracleJson,
-        address: new PublicKey(yieldOracleJson.address),
-    } as IdlEntry<YieldOracle>,
-};
-
-/**
- * Factory for Anchor Program clients.
- *
- * Anchor v0.28+ reads the program ID from `idl.address`, so
- * we call the 2-arg constructor: `new Program(idl, provider)`.
- */
 export class SolanaProgramService {
     constructor(private provider: AnchorProvider) { }
 
-    /**
-     * Returns a typed Anchor Program instance for the given key.
-     */
-    getProgram<K extends keyof typeof PROGRAM_IDLS>(
-        name: K
-    ): Program<(typeof PROGRAM_IDLS)[K]['idl']> {
-        const entry = PROGRAM_IDLS[name];
-        // stamp the correct address into a fresh copy of the IDL
-        const idlWithAddr = { ...entry.idl, address: entry.address.toString() };
-        // use the two-arg signature: (idl, provider)
-        return new Program(idlWithAddr as any, this.provider) as Program<
-            (typeof PROGRAM_IDLS)[K]['idl']
-        >;
-    }
-
-    /** List all program keys */
-    listProgramNames(): Array<keyof typeof PROGRAM_IDLS> {
-        return Object.keys(PROGRAM_IDLS) as Array<keyof typeof PROGRAM_IDLS>;
+    getProgram<K extends keyof typeof PROGRAMS>(name: K): Program<(typeof PROGRAMS)[K]['idl']> {
+        const { idl, address } = PROGRAMS[name];
+        // Ensure the IDL has the right address (avoid drift)
+        const idlWithAddr = { ...idl, address };
+        return new Program(idlWithAddr as any, this.provider) as Program<(typeof PROGRAMS)[K]['idl']>;
     }
 
-    /** Raw PublicKey of a program */
-    getProgramId(name: keyof typeof PROGRAM_IDLS): PublicKey {
-        return PROGRAM_IDLS[name].address;
+    listProgramNames(): Array<keyof typeof PROGRAMS> {
+        return Object.keys(PROGRAMS) as Array<keyof typeof PROGRAMS>;
     }
 }