@wireio/stake 0.1.2 → 0.2.0

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

@@ -0,0 +1,474 @@
+import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import {
+    Connection,
+    PublicKey,
+    SystemProgram,
+    Transaction,
+    TransactionInstruction,
+} from '@solana/web3.js';
+import {
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    TOKEN_2022_PROGRAM_ID,
+    createAssociatedTokenAccountInstruction,
+} from '@solana/spl-token';
+import {
+    buildOutpostAccounts,
+    getLiqsolCoreProgram,
+    getErrorMessage,
+} from '../utils';
+import { SolanaProgramService } from '../program';
+import { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
+import { WalletLike, OutpostWireStateSnapshot, SharesPreview, UserWarrantRecord, TrancheState, WireReceipt } from '../types';
+
+/**
+ * Minimal, user-flow focused OutpostClient.
+ * - Read state
+ * - Build + (optionally) send user instructions
+ *
+ * No admin/bootstrap/reset helpers by design.
+ */
+export class OutpostClient {
+    private readonly program: Program<LiqsolCore>;  
+
+    // keep consistent with your tests
+    static readonly INDEX_SCALE = new BN('1000000000000');
+
+    get connection(): Connection { return this.provider.connection; }
+    get wallet(): WalletLike { return this.provider.wallet; }
+
+    constructor(private provider: AnchorProvider) {
+        const svc = new SolanaProgramService(provider);
+        this.program = svc.getProgram('liqsolCore');
+    }
+
+    /**
+     * Read-only Program helper (dummy wallet), useful if you want to do pure reads
+     * without requiring a wallet. Kept here as sugar for callers.
+     */
+    getReadOnlyProgram(): Program<LiqsolCore> {
+        return getLiqsolCoreProgram(this.connection);
+    }
+
+    // ---------------------------------------------------------------------------
+    // General-purpose formatting + math (SDK sugar)
+    // ---------------------------------------------------------------------------
+
+    /**
+     * Same rounding logic from your tests: ceil(amount * INDEX_SCALE / currentIndex)
+     */
+    static tokensToShares(amount: BN, currentIndex: BN): BN {
+        const numerator = amount.mul(OutpostClient.INDEX_SCALE);
+        const shares = numerator.div(currentIndex);
+        const remainder = numerator.mod(currentIndex);
+        return remainder.eqn(0) ? shares : shares.addn(1);
+    }
+
+    /**
+     * UI helper: formats a BN assumed to be scale=1e8 into a decimal string.
+     * (Matches your test helper; useful for tranche price, USD price, etc.)
+     */
+    static formatScale8(value: BN): string {
+        const decimals = 8;
+        const valueStr = value.toString();
+        if (valueStr.length <= decimals) {
+            const padding = '0'.repeat(decimals - valueStr.length);
+            return `0.${padding}${valueStr}`;
+        }
+        const intPart = valueStr.slice(0, valueStr.length - decimals);
+        const decPart = valueStr.slice(valueStr.length - decimals);
+        return `${intPart}.${decPart}`;
+    }
+
+    /**
+     * Previews expected shares for a purchase/stake flow that mints shares
+     * relative to globalState.currentIndex.
+     */
+    async previewExpectedShares(params: {
+        amountLamports: BN;
+        user?: PublicKey; // optional; defaults to wallet.publicKey
+    }): Promise<SharesPreview> {
+        const user = params.user ?? this.wallet.publicKey;
+        const accounts = await buildOutpostAccounts(this.connection, user);
+        const globalState = await this.program.account.globalState.fetch(accounts.globalState);
+        const currentIndex = new BN(globalState.currentIndex.toString());
+        const expectedShares = OutpostClient.tokensToShares(
+            params.amountLamports,
+            currentIndex,
+        );
+
+        return {
+            amountLamports: params.amountLamports,
+            currentIndex,
+            indexScale: OutpostClient.INDEX_SCALE,
+            expectedShares,
+        };
+    }
+
+    // ---------------------------------------------------------------------------
+    // Account helpers (user-facing, not admin bootstrap)
+    // ---------------------------------------------------------------------------
+
+    /**
+     * Returns whether the user's liqSOL ATA exists.
+     * Useful for UX (show "Create token account" prompt).
+     */
+    async doesUserAtaExist(user: PublicKey = this.wallet.publicKey): Promise<boolean> {
+        const accounts = await buildOutpostAccounts(this.connection, user);
+        const info = await this.connection.getAccountInfo(accounts.userAta);
+        return !!info;
+    }
+
+    /**
+     * Builds an instruction to create the user's liqSOL ATA (Token-2022).
+     * This is general-purpose sugar for any flow that needs the ATA.
+     */
+    async buildCreateUserAtaIx(user: PublicKey = this.wallet.publicKey): Promise<TransactionInstruction> {
+        const accounts = await buildOutpostAccounts(this.connection, user);
+
+        return createAssociatedTokenAccountInstruction(
+            this.wallet.publicKey,          // payer
+            accounts.userAta,               // ata
+            user,                           // owner
+            accounts.liqsolMint,            // mint
+            TOKEN_2022_PROGRAM_ID,
+            ASSOCIATED_TOKEN_PROGRAM_ID,
+        );
+    }
+
+    /**
+     * Convenience: ensures ATA exists by returning either [] or [createATAIx].
+     * (Does NOT send; caller composes tx)
+     */
+    async maybeBuildCreateUserAtaIx(user: PublicKey = this.wallet.publicKey): Promise<TransactionInstruction[]> {
+        const accounts = await buildOutpostAccounts(this.connection, user);
+        const info = await this.connection.getAccountInfo(accounts.userAta);
+        if (info) return [];
+        return [await this.buildCreateUserAtaIx(user)];
+    }
+
+    // ---------------------------------------------------------------------------
+    // Reads (UI-first)
+    // ---------------------------------------------------------------------------
+
+    async getWireStateSnapshot(user: PublicKey = this.wallet.publicKey): Promise<OutpostWireStateSnapshot> {
+        const accounts = await buildOutpostAccounts(this.connection, user);
+
+        const [
+            globalState,
+            wireReceipt,
+            distributionState,
+            userWarrantRecord,
+            trancheState,
+        ] = await Promise.all([
+            this.program.account.globalState.fetch(accounts.globalState),
+            this.program.account.wireReceipt.fetchNullable(accounts.wireReceipt),
+            this.program.account.distributionState.fetch(accounts.distributionState),
+            this.program.account.userWarrantRecord.fetchNullable(accounts.userWarrantRecord),
+            this.program.account.trancheState.fetchNullable(accounts.trancheState),
+        ]);
+
+        const [
+            liqsolPoolBalance,
+            solBucketLamports,
+            userLiqsolBalance,
+        ] = await Promise.all([
+            this.getTokenBalanceSafe(accounts.liqsolPoolAta),
+            this.connection.getBalance(accounts.solBucket),
+            this.getTokenBalanceSafe(accounts.userAta),
+        ]);
+
+        return {
+            globalState,
+            distributionState,
+            wireReceipt,
+            trancheState,
+            userWarrantRecord,
+            liqsolPoolBalance,
+            solBucketLamports,
+            userLiqsolBalance,
+        };
+    }
+
+    async getWireReceipt(user: PublicKey = this.wallet.publicKey): Promise<WireReceipt | null> {
+        const accounts = await buildOutpostAccounts(this.connection, user);
+        return this.program.account.wireReceipt.fetchNullable(accounts.wireReceipt);
+    }
+
+    async getTrancheState(): Promise<TrancheState | null> {
+        const accounts = await buildOutpostAccounts(this.connection, this.wallet.publicKey);
+        return this.program.account.trancheState.fetchNullable(accounts.trancheState);
+    }
+
+    async getUserWarrantRecord(user: PublicKey = this.wallet.publicKey): Promise<UserWarrantRecord | null> {
+        const accounts = await buildOutpostAccounts(this.connection, user);
+        return this.program.account.userWarrantRecord.fetchNullable(accounts.userWarrantRecord);
+    }
+
+    // ---------------------------------------------------------------------------
+    // Instruction builders (source of truth: your test utils)
+    // ---------------------------------------------------------------------------
+
+    /**
+     * stakeLiqsol(amount)
+     * (Outpost staking: liqSOL -> warrant pool)
+     */
+    async buildStakeLiqsolIx(amountLamports: bigint, userPubKey = this.wallet.publicKey): Promise<TransactionInstruction> {
+        const a = await buildOutpostAccounts(this.connection, userPubKey);
+        const amount = new BN(amountLamports.toString());
+
+        return this.program.methods
+            .stakeLiqsol(amount)
+            .accounts({
+                user: a.user,
+                liqsolMint: a.liqsolMint,
+                globalState: a.globalState,
+                userAta: a.userAta,
+                poolAuthority: a.poolAuthority,
+                liqsolPoolAta: a.liqsolPoolAta,
+                warrantDepositRecord: a.wireReceipt,
+                liqsolPoolUserRecord: a.poolUserRecord,
+                distributionState: a.distributionState,
+                payRateHistory: a.payRateHistory,
+                bucketAuthority: a.bucketAuthority,
+                bucketTokenAccount: a.bucketTokenAccount,
+                solBucket: a.solBucket,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+                systemProgram: SystemProgram.programId,
+            })
+            .instruction();
+    }
+
+    /**
+     * withdrawStake(amount)
+     * (Outpost unstake: warrant pool -> user liqSOL)
+     */
+    async buildWithdrawStakeIx(amountLamports: bigint, userPubKey = this.wallet.publicKey): Promise<TransactionInstruction> {
+        const a = await buildOutpostAccounts(this.connection, userPubKey);
+        const amount = new BN(amountLamports.toString());
+
+        return this.program.methods
+            .withdrawStake(amount)
+            .accounts({
+                user: a.user,
+                liqsolMint: a.liqsolMint,
+                globalState: a.globalState,
+                userAta: a.userAta,
+                poolAuthority: a.poolAuthority,
+                liqsolPoolAta: a.liqsolPoolAta,
+                warrantDepositRecord: a.wireReceipt,
+                liqsolPoolUserRecord: a.poolUserRecord,
+                distributionState: a.distributionState,
+                payRateHistory: a.payRateHistory,
+                bucketAuthority: a.bucketAuthority,
+                bucketTokenAccount: a.bucketTokenAccount,
+                solBucket: a.solBucket,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                systemProgram: SystemProgram.programId,
+            })
+            .instruction();
+    }
+
+    /**
+     * purchaseWithLiqsol(amount)
+     */
+    async buildPurchaseWithLiqsolIx(amountLamports: bigint, userPubKey = this.wallet.publicKey): Promise<TransactionInstruction> {
+        const a = await buildOutpostAccounts(this.connection, userPubKey);
+        const amount = new BN(amountLamports.toString());
+
+        return this.program.methods
+            .purchaseWithLiqsol(amount)
+            .accounts({
+                user: a.user,
+                liqsolMint: a.liqsolMint,
+                globalState: a.globalState,
+                buyerAta: a.userAta,
+                poolAuthority: a.poolAuthority,
+                liqsolPoolAta: a.liqsolPoolAta,
+                warrantDepositRecord: a.wireReceipt,
+                liqsolPoolUserRecord: a.poolUserRecord,
+                distributionState: a.distributionState,
+                payRateHistory: a.payRateHistory,
+                bucketAuthority: a.bucketAuthority,
+                bucketTokenAccount: a.bucketTokenAccount,
+                solBucket: a.solBucket,
+                trancheState: a.trancheState,
+                userWarrantRecord: a.userWarrantRecord,
+                chainlinkFeed: a.chainLinkFeed,
+                chainlinkProgram: a.chainLinkProgram,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+                systemProgram: SystemProgram.programId,
+            })
+            .instruction();
+    }
+
+    /**
+     * purchaseWithSol(amount)
+     */
+    async buildPurchaseWithSolIx(amountLamports: bigint, userPubKey = this.wallet.publicKey): Promise<TransactionInstruction> {
+        const a = await buildOutpostAccounts(this.connection, userPubKey);
+        const amount = new BN(amountLamports.toString());
+
+        return this.program.methods
+            .purchaseWithSol(amount)
+            .accounts({
+                user: a.user,
+                liqsolMint: a.liqsolMint,
+                globalState: a.globalState,
+                poolAuthority: a.poolAuthority,
+                liqsolPoolAta: a.liqsolPoolAta,
+                liqsolPoolUserRecord: a.poolUserRecord,
+                distributionState: a.distributionState,
+                payRateHistory: a.payRateHistory,
+                bucketAuthority: a.bucketAuthority,
+                bucketTokenAccount: a.bucketTokenAccount,
+                solBucket: a.solBucket,
+                warrantDepositRecord: a.wireReceipt,
+                trancheState: a.trancheState,
+                userWarrantRecord: a.userWarrantRecord,
+                chainlinkFeed: a.chainLinkFeed,
+                chainlinkProgram: a.chainLinkProgram,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                systemProgram: SystemProgram.programId,
+            })
+            .instruction();
+    }
+
+    /**
+     * purchaseWarrantsFromYield()
+     *
+     * Source of truth: your test util executePurchaseFromYield (note: it passed
+     * liqsolPoolUserRecord: pdas.userUserRecord, not poolUserRecord).
+     */
+    async buildPurchaseFromYieldIx(userPubKey = this.wallet.publicKey): Promise<TransactionInstruction> {
+        const a = await buildOutpostAccounts(this.connection, userPubKey);
+
+        return this.program.methods
+            .purchaseWarrantsFromYield()
+            .accounts({
+                user: a.user,
+                globalState: a.globalState,
+                liqsolMint: a.liqsolMint,
+                poolAuthority: a.poolAuthority,
+                liqsolPoolAta: a.liqsolPoolAta,
+                solBucket: a.solBucket,
+                liqsolPoolUserRecord: a.userUserRecord,
+                distributionState: a.distributionState,
+                payRateHistory: a.payRateHistory,
+                bucketAuthority: a.bucketAuthority,
+                bucketTokenAccount: a.bucketTokenAccount,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                systemProgram: SystemProgram.programId,
+                trancheState: a.trancheState,
+                userWarrantRecord: a.userWarrantRecord,
+                chainlinkFeed: a.chainLinkFeed,
+                chainlinkProgram: a.chainLinkProgram,
+            })
+            .instruction();
+    }
+
+    // ---------------------------------------------------------------------------
+    // Optional send helpers (wallet-facing sugar)
+    // ---------------------------------------------------------------------------
+
+    /**
+     * Builds and sends a single-instruction transaction.
+     * (Hub can ignore this and use builder methods only.)
+     */
+    async sendIx(ix: TransactionInstruction, opts?: {
+        additionalIxs?: TransactionInstruction[];
+    }): Promise<string> {
+        const tx = new Transaction();
+        if (opts?.additionalIxs?.length) {
+            tx.add(...opts.additionalIxs);
+        }
+        tx.add(ix);
+
+        try {
+            const sig = await this.provider.sendAndConfirm(tx, [], { commitment: 'confirmed' });
+            return sig;
+        } catch (e: any) {
+            const msg = getErrorMessage(e);
+            throw new Error(`OutpostClient sendIx failed: ${msg}`);
+        }
+    }
+
+    /**
+     * Convenience: stake liqSOL and (optionally) create ATA first.
+     */
+    async stakeLiqsol(params: {
+        amount: BN;
+        user?: PublicKey;
+        ensureAta?: boolean; // default true
+    }): Promise<string> {
+        const user = params.user ?? this.wallet.publicKey;
+        const pre: TransactionInstruction[] = [];
+        if (params.ensureAta ?? true) {
+            pre.push(...(await this.maybeBuildCreateUserAtaIx(user)));
+        }
+        const ix = await this.buildStakeLiqsolIx(params.amount, user);
+        return this.sendIx(ix, { additionalIxs: pre });
+    }
+
+    async withdrawStake(params: {
+        amount: BN;
+        user?: PublicKey;
+        ensureAta?: boolean; // default true (usually exists, but harmless)
+    }): Promise<string> {
+        const user = params.user ?? this.wallet.publicKey;
+        const pre: TransactionInstruction[] = [];
+        if (params.ensureAta ?? true) {
+            pre.push(...(await this.maybeBuildCreateUserAtaIx(user)));
+        }
+        const ix = await this.buildWithdrawStakeIx(params.amount, user);
+        return this.sendIx(ix, { additionalIxs: pre });
+    }
+
+    async purchaseWithLiqsol(params: {
+        amount: BN;
+        user?: PublicKey;
+        ensureAta?: boolean; // default true
+    }): Promise<string> {
+        const user = params.user ?? this.wallet.publicKey;
+        const pre: TransactionInstruction[] = [];
+        if (params.ensureAta ?? true) {
+            pre.push(...(await this.maybeBuildCreateUserAtaIx(user)));
+        }
+        const ix = await this.buildPurchaseWithLiqsolIx(params.amount, user);
+        return this.sendIx(ix, { additionalIxs: pre });
+    }
+
+    async purchaseWithSol(params: {
+        amount: BN;
+        user?: PublicKey;
+    }): Promise<string> {
+        const user = params.user ?? this.wallet.publicKey;
+        const ix = await this.buildPurchaseWithSolIx(params.amount, user);
+        return this.sendIx(ix);
+    }
+
+    async purchaseFromYield(params?: {
+        user?: PublicKey;
+    }): Promise<string> {
+        const user = params?.user ?? this.wallet.publicKey;
+        const ix = await this.buildPurchaseFromYieldIx(user);
+        return this.sendIx(ix);
+    }
+
+    // ---------------------------------------------------------------------------
+    // Internals
+    // ---------------------------------------------------------------------------
+
+    /**
+     * Token balance helper returning BN(0) if ATA missing.
+     */
+    private async getTokenBalanceSafe(ata: PublicKey): Promise<BN> {
+        try {
+            const bal = await this.connection.getTokenAccountBalance(ata);
+            return new BN(bal.value.amount);
+        } catch {
+            return new BN(0);
+        }
+    }
+}

package/src/networks/solana/constants.ts

@@ -43,7 +43,7 @@ export const PDA_SEEDS = {
     VAULT: 'vault',
     RESERVE_POOL: 'reserve_pool',
     STAKE_CONTROLLER_STATE: 'stake_controller',
-    PAYOUT_STATE: 'payout-state',
+    PAYOUT_STATE: 'payout_state',
 
     // liqsol_token: mint + bucket
     LIQSOL_MINT: 'liqsol_mint',
@@ -61,12 +61,24 @@ export const PDA_SEEDS = {
     LEADERBOARD_STATE: 'leaderboard_state',
     VALIDATOR_RECORD: 'validator',
     GLOBAL_STAKE_INFO: 'global_stake_info',
+
+    // Outpost
+    WARRANT_DEPOSIT_GLOBAL: 'warrant_deposit_global',
+    LIQSOL_POOL: 'liqsol_pool',
+    WARRANT_DEPOSIT_RECORD: 'warrant_deposit_record',
+    WIRE_SOL_BUCKET: 'wire_sol_bucket',
+    TRANCHE_STATE: 'tranche_state',
+    USER_WARRANT_RECORD: 'user_warrant_record',
+
+    // BAR
+    BAR_STATE_SEED: 'bar_state',
+    BONDED_ACTOR_SEED: 'bonded_actor',
+    BOND_LEVEL_SEED: 'bond_level',
 } as const;
 
 /**
  * Helpers for PDA derivation so clients don’t duplicate logic.
  */
-
 export const deriveLiqsolMintPda = () =>
     PublicKey.findProgramAddressSync(
         [Buffer.from(PDA_SEEDS.LIQSOL_MINT)],
@@ -133,12 +145,6 @@ export const derivePayRateHistoryPda = () =>
         PROGRAM_IDS.LIQSOL_CORE,
     )[0];
 
-// export const deriveGlobalStakeInfoPda = () =>
-//     PublicKey.findProgramAddressSync(
-//         [Buffer.from(PDA_SEEDS.GLOBAL_STAKE_INFO)],
-//         PROGRAM_IDS.LIQSOL_CORE,
-//     )[0];
-
 export const deriveLeaderboardStatePda = () =>
     PublicKey.findProgramAddressSync(
         [Buffer.from(PDA_SEEDS.LEADERBOARD_STATE)],
@@ -151,16 +157,81 @@ export const deriveValidatorRecordPda = (voteAccount: PublicKey) =>
         PROGRAM_IDS.VALIDATOR_LEADERBOARD,
     )[0];
 
-/**
-* Stake controller vault PDA (reserve pool SOL vault).
-* This is the same as VAULT, but named more explicitly for SDK callers.
-*/
 export const deriveStakeControllerVaultPda = () =>
     PublicKey.findProgramAddressSync(
         [Buffer.from(PDA_SEEDS.VAULT)],
         PROGRAM_IDS.LIQSOL_CORE,
     )[0];
 
+/**
+ * OUTPOST 
+ */
+export const deriveOutpostGlobalStatePda = () => 
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.WARRANT_DEPOSIT_GLOBAL)],
+        LIQSOL_CORE,
+    )[0];
+
+export const deriveOutpostPoolAuthorityPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.LIQSOL_POOL)],
+        LIQSOL_CORE,
+    )[0];
+
+export const deriveWireReceiptPda = (user: PublicKey) =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.WARRANT_DEPOSIT_RECORD), user.toBuffer()],
+        LIQSOL_CORE,
+    )[0];
+
+export const derivePoolUserRecordPda = (poolAuthority: PublicKey) =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.USER_RECORD), poolAuthority.toBuffer()],
+        LIQSOL_CORE,
+    )[0];
+
+export const deriveUserUserRecordPda = (user: PublicKey) =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.USER_RECORD), user.toBuffer()],
+        LIQSOL_CORE,
+    )[0];
+
+export const deriveSolBucketPda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.WIRE_SOL_BUCKET)],
+        LIQSOL_CORE,
+    )[0];
+
+export const deriveTrancheStatePda = () =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.TRANCHE_STATE)],
+        LIQSOL_CORE,
+    )[0];
+
+export const deriveUserWarrantRecordPda = (user: PublicKey) =>
+    PublicKey.findProgramAddressSync(
+        [Buffer.from(PDA_SEEDS.USER_WARRANT_RECORD), user.toBuffer()],
+        LIQSOL_CORE,
+    )[0];
+
+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];
+
 /**
  * Ephemeral stake account address used per-deposit.
  * On-chain convention: seed = `ephemeral_<u32>` under StakeProgram.programId.
@@ -173,7 +244,12 @@ export const deriveEphemeralStakeAddress = async (
     return await PublicKey.createWithSeed(user, seedStr, StakeProgram.programId);
 };
 
+/**
+ * Constant keys
+ */
 
+export const CHAINLINK_FEED = new PublicKey("99B2bTijsU6f1GCT73HmdR7HCFFjGMBcPZY6jZ96ynrR");
+export const CHAINLINK_PROGRAM = new PublicKey("HEvSKofvBgfaexv23kMabbYqxasxU3mQ4ibBMEmJWHny");
 
 /**
  * ---------------------------------------------------------------------------
@@ -200,43 +276,5 @@ export const LAMPORTS_PER_SOL = 1_000_000_000;
 export const lamportsToSol = (lamports: number | bigint): number =>
     Number(lamports) / LAMPORTS_PER_SOL;
 
-export const solToLamports = (sol: number): number =>
-    Math.round(sol * LAMPORTS_PER_SOL);
-
-/**
- * ---------------------------------------------------------------------------
- *  CLUSTER / ENVIRONMENT CONFIG (optional but handy)
- * ---------------------------------------------------------------------------
- */
-
-export type SolanaCluster = 'localnet' | 'devnet' | 'mainnet';
-
-// export interface SolanaStakeProgramAddresses {
-//     liqsolCore: PublicKey;
-//     liqsolToken: PublicKey;
-//     validatorLeaderboard: PublicKey;
-// }
-
-// export const PROGRAMS_BY_CLUSTER: Record<SolanaCluster, SolanaStakeProgramAddresses> = {
-//     localnet: {
-//         liqsolCore: PROGRAM_IDS.LIQSOL_CORE,
-//         liqsolToken: PROGRAM_IDS.LIQSOL_TOKEN,
-//         validatorLeaderboard: PROGRAM_IDS.VALIDATOR_LEADERBOARD,
-//     },
-//     devnet: {
-//         liqsolCore: PROGRAM_IDS.LIQSOL_CORE,
-//         liqsolToken: PROGRAM_IDS.LIQSOL_TOKEN,
-//         validatorLeaderboard: PROGRAM_IDS.VALIDATOR_LEADERBOARD,
-//     },
-//     mainnet: {
-//         liqsolCore: PROGRAM_IDS.LIQSOL_CORE,
-//         liqsolToken: PROGRAM_IDS.LIQSOL_TOKEN,
-//         validatorLeaderboard: PROGRAM_IDS.VALIDATOR_LEADERBOARD,
-//     },
-// };
-
-// export const DEFAULT_CLUSTER: SolanaCluster = 'localnet';
-
-// export function getProgramIds(cluster: SolanaCluster = DEFAULT_CLUSTER): SolanaStakeProgramAddresses {
-//     return PROGRAMS_BY_CLUSTER[cluster];
-// }
+export const solToLamports = (sol: number): bigint =>
+    BigInt(Math.round(sol * LAMPORTS_PER_SOL));