@wireio/stake 0.0.1

package/src/networks/ethereum/types.ts

@@ -0,0 +1,6 @@
+export const CONTRACT_NAMES = [
+    'Stake',
+] as const;
+
+export type ContractName = typeof CONTRACT_NAMES[number];
+export type AddressBook  = Record<ContractName, string>;

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

@@ -0,0 +1,178 @@
+import { AnchorProvider } from '@coral-xyz/anchor';
+import { BN } from '@coral-xyz/anchor';
+import {
+    PublicKey,
+    Transaction,
+    SystemProgram,
+    SYSVAR_INSTRUCTIONS_PUBKEY,
+    SYSVAR_CLOCK_PUBKEY,
+    SYSVAR_RENT_PUBKEY,
+    SYSVAR_STAKE_HISTORY_PUBKEY,
+    StakeProgram,
+    ComputeBudgetProgram,
+    VersionedTransaction,
+    Signer,
+    TransactionSignature,
+} from '@solana/web3.js';
+import {
+    TOKEN_2022_PROGRAM_ID,
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+} from '@solana/spl-token';
+
+import {
+    deriveDepositAuthorityPDA,
+    deriveLiqsolMintAuthorityPDA,
+    deriveStakeControllerVaultPDA,
+    deriveStakeControllerReservePoolPDA,
+    deriveStakeControllerStatePDA,
+    deriveDistributionStatePDA,
+    deriveUserRecordPDA,
+    getUserLiqsolATA,
+} from '../utils';
+import {
+    LIQSOL_MINT_ADDRESS,
+    TREASURY_WALLET_PDA,
+    STAKE_CONTROLLER_PROGRAM_ID,
+    LIQSOL_TOKEN_PROGRAM_ID,
+    YIELD_ORACLE_PROGRAM_ID,
+    DISTRIBUTION_PROGRAM_ID,
+    MIN_SOL_TO_PARTICIPATE,
+} from '../constants';
+import { SolanaProgramService } from '../program';
+
+/**
+ * DepositClient provides methods for building, simulating, and sending deposit transactions
+ * to the Solana blockchain using the Anchor framework. It handles the creation of ephemeral
+ * stake accounts, derives necessary PDAs and ATAs, and manages transaction construction
+ * with compute budget adjustments. This client is designed to facilitate deposits into
+ * the Liqsol staking protocol, ensuring all required accounts and instructions are included.
+ *
+ * @remarks
+ * - Uses AnchorProvider for network interactions.
+ * - Enforces minimum deposit requirements.
+ * - Supports dry-run simulation for transaction debugging.
+ * - Provides high-level helper for building and sending deposit transactions.
+ */
+export class DepositClient {
+    private program = new SolanaProgramService(this.provider);
+
+    constructor(private provider: AnchorProvider) { }
+
+    /** Minimum lamports (1 SOL) */
+    static readonly MIN_DEPOSIT = MIN_SOL_TO_PARTICIPATE;
+
+    /**
+     * Build the deposit transaction (compute-budget bump + deposit Ix).
+     * Returns both the Transaction and the ephemeral stake account Pubkey.
+     */
+    async buildDepositTx(
+        user: PublicKey,
+        amount: number
+    ): Promise<{ transaction: Transaction; ephemeralStakePubkey: PublicKey }> {
+        if (amount < MIN_SOL_TO_PARTICIPATE) {
+            throw new Error(
+                `Minimum deposit is ${MIN_SOL_TO_PARTICIPATE / 1e9} SOL`
+            );
+        }
+
+        // 1) grab your typed Anchor program
+        const program = this.program.getProgram('deposit');
+
+        // 2) PDAs & ATAs
+        const userAta = getUserLiqsolATA(user);
+        const [depositAuthPDA] = deriveDepositAuthorityPDA();
+        const [mintAuthPDA] = deriveLiqsolMintAuthorityPDA();
+        const [vaultPDA] = deriveStakeControllerVaultPDA();
+        const [reservePoolPDA] = deriveStakeControllerReservePoolPDA();
+        const [controllerStatePDA] = deriveStakeControllerStatePDA();
+        const [distStatePDA] = deriveDistributionStatePDA();
+        const [userRecordPDA] = deriveUserRecordPDA(user);
+
+        // 3) ephemeral stake account
+        const seed = Math.floor(Math.random() * 0xffffffff);
+        const ephemeralSeed = `ephemeral_${seed}`;
+        const ephemeralStakePubkey = await PublicKey.createWithSeed(
+            user,
+            ephemeralSeed,
+            StakeProgram.programId
+        );
+
+        // 4) build deposit instruction
+        const depositIx = await program.methods
+            .deposit(new BN(amount), seed)
+            .accounts({
+                user,
+                programAuthority: depositAuthPDA,
+                treasuryWallet: TREASURY_WALLET_PDA,
+                systemProgram: SystemProgram.programId,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+                stakeControllerProgram: STAKE_CONTROLLER_PROGRAM_ID,
+                liqsolProgram: LIQSOL_TOKEN_PROGRAM_ID,
+                yieldOracleProgram: YIELD_ORACLE_PROGRAM_ID,
+                stakeProgram: StakeProgram.programId,
+                distributionProgram: DISTRIBUTION_PROGRAM_ID,
+                liqsolMint: LIQSOL_MINT_ADDRESS,
+                userAta,
+                liqsolMintAuthority: mintAuthPDA,
+                reservePool: reservePoolPDA,
+                vault: vaultPDA,
+                ephemeralStake: ephemeralStakePubkey,
+                controllerState: controllerStatePDA,
+                userRecord: userRecordPDA,
+                distributionState: distStatePDA,
+                instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+                clock: SYSVAR_CLOCK_PUBKEY,
+                stakeHistory: SYSVAR_STAKE_HISTORY_PUBKEY,
+                rent: SYSVAR_RENT_PUBKEY,
+            } as any)
+            .instruction();
+
+        // 5) prepend compute-budget bump
+        const computeIx = ComputeBudgetProgram.setComputeUnitLimit({
+            units: 400_000,
+        });
+
+        const tx = new Transaction().add(computeIx, depositIx);
+        return { transaction: tx, ephemeralStakePubkey };
+    }
+
+    /**
+     * Simulate (dry-run) a built transaction.
+     * Returns any error plus the total compute-units consumed.
+     */
+    async simulate(
+        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! };
+    }
+
+    /**
+     * High-level “build & send” helper.
+     * Returns the confirmed signature.
+     */
+    async deposit(
+        user: PublicKey,
+        amount: number,
+        signers: Signer[] = []
+    ): Promise<TransactionSignature> {
+        const { transaction } = await this.buildDepositTx(user, amount);
+
+        // set feePayer & recent blockhash
+        transaction.feePayer = this.provider.wallet.publicKey;
+        const { blockhash } = await this.provider.connection.getLatestBlockhash();
+        transaction.recentBlockhash = blockhash;
+
+        // send + confirm
+        return this.provider.sendAndConfirm(transaction, signers);
+    }
+}

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

@@ -0,0 +1,230 @@
+// 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';
+
+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>;
+    }
+
+    /** Derive the PDA for global distribution state */
+    deriveStatePDA(): PublicKey {
+        return deriveDistributionStatePDA()[0];
+    }
+
+    /** Derive the PDA for a user’s record */
+    deriveUserRecordPDA(user: PublicKey): PublicKey {
+        return deriveUserRecordPDA(user)[0];
+    }
+
+    /** Fetch on-chain distribution state */
+    async getState(): Promise<any> {
+        return this.program.account.distributionState.fetch(this.deriveStatePDA());
+    }
+
+    /** Fetch a user’s record or return null if it doesn’t exist */
+    async getUserRecord(user: PublicKey): Promise<any | null> {
+        try {
+            return await this.program.account.userRecord.fetch(
+                this.deriveUserRecordPDA(user)
+            );
+        } 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();
+
+        return new Transaction().add(ix);
+    }
+
+    /** 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);
+
+        // 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
+        );
+
+        const [stakeControllerStatePda] = PublicKey.findProgramAddressSync(
+            [Buffer.from('stake_controller')],
+            STAKE_CONTROLLER_PROGRAM_ID
+        );
+
+        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();
+
+        return new Transaction().add(ix);
+    }
+
+    /** Build a `withdraw` transaction */
+    async buildWithdrawTransaction(user: PublicKey, amount: number): Promise<Transaction> {
+        const statePda = this.deriveStatePDA();
+        const userPda = this.deriveUserRecordPDA(user);
+
+        // Fetch state for the mint
+        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
+        );
+
+        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 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();
+
+        return new Transaction().add(ix);
+    }
+
+    /** Build a `claimRewards` transaction */
+    async buildClaimRewardsTransaction(user: PublicKey): Promise<Transaction> {
+        const statePda = this.deriveStatePDA();
+        const userPda = this.deriveUserRecordPDA(user);
+
+        // Fetch state for the mint
+        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
+        );
+        const [mintAuthPda] = deriveLiqsolMintAuthorityPDA();
+
+        const ix = await this.program.methods
+            .claimRewards()
+            .accounts({
+                user,
+                userAta,
+                userRecord: userPda,
+                distributionState: statePda,
+                liqsolMint,
+                liqsolProgram: LIQSOL_TOKEN_PROGRAM_ID,
+                liqsolMintAuthority: mintAuthPda,
+                instructionsSysvar: web3.SYSVAR_INSTRUCTIONS_PUBKEY,
+                yieldOracleProgram: YIELD_ORACLE_PROGRAM_ID,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+                systemProgram: SystemProgram.programId,
+            } as any)
+            .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);
+    }
+
+    /** 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! };
+    }
+}

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

@@ -0,0 +1,179 @@
+// 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();
+
+        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();
+
+        return new Transaction().add(ix);
+    }
+
+    /**
+     * 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();
+    }
+
+    /**
+     * Traverse the on-chain linked list and return the sequence of PublicKeys
+     */
+    async getLeaderboard(): Promise<PublicKey[]> {
+        const [headPda] = deriveLeaderboardHeadPDA();
+        let headAccount;
+        try {
+            headAccount = await this.program.account.leaderboardHead.fetch(headPda);
+        } 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 result;
+    }
+
+    /**
+     * Fetch a single validator record or null
+     */
+    async getRecord(voteAccount: PublicKey): Promise<any | null> {
+        const [recPda] = deriveValidatorRecordPDA(voteAccount);
+        try {
+            return await this.program.account.validatorRecord.fetch(recPda);
+        } 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
+     */
+    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

@@ -0,0 +1,73 @@
+// src/networks/solana/constants.ts
+
+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,
+};
+
+// — 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 };