@wireio/stake 0.2.4 → 0.2.69

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

@@ -6,32 +6,43 @@ import {
     ASSOCIATED_TOKEN_PROGRAM_ID,
 } from '@solana/spl-token';
 
-import { buildOutpostAccounts, type OutpostAccounts, buildSolanaTrancheSnapshot } from '../utils';
-import { SolanaProgramService } from '../program';
-import { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
+import {
+    buildOutpostAccounts,
+    type OutpostAccounts,
+} from '../utils';
+
+import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
+
 import {
     GlobalState,
     PriceHistory,
     TrancheState,
-    UserWarrantRecord,
     WalletLike,
-    WireReceipt,
+    OutpostAccount,
+    UserPretokenRecord,
 } from '../types';
-import { derivePriceHistoryPda } from '../constants';
-import type { } from '../types';
-import { ChainID, SolChainID } from '@wireio/core';
-import { PurchaseAsset, PurchaseQuote, TrancheSnapshot } from '../../../types';
+
+import {
+    CHAINLINK_FEED,
+    CHAINLINK_PROGRAM,
+} from '../constants';
 
 export class TokenClient {
-    private readonly program: Program<LiqsolCore>;
+    private readonly program: Program<LiqsolCoreClientIdl>;
 
     get wallet(): WalletLike {
         return this.provider.wallet;
     }
 
-    constructor(private readonly provider: AnchorProvider) {
-        const svc = new SolanaProgramService(provider);
-        this.program = svc.getProgram('liqsolCore');
+    get connection(): Connection {
+        return this.provider.connection;
+    }
+
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('liqsolCore');
     }
 
     // ---------------------------------------------------------------------------
@@ -39,7 +50,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> {
@@ -52,132 +63,106 @@ export class TokenClient {
         return this.program.account.trancheState.fetch(trancheState);
     }
 
-    async fetchWireReceipt(user: PublicKey): Promise<WireReceipt> {
-        const { wireReceipt } = await this.getAccounts(user);
-        return this.program.account.wireReceipt.fetch(wireReceipt);
+    /**
+     * Fetch the per-user Outpost account (old "wire receipt").
+     * Returns null if the user has never interacted with Outpost.
+     */
+    async fetchOutpostAccount(user: PublicKey): Promise<OutpostAccount | null> {
+        const { outpostAccount } = await this.getAccounts(user);
+        return this.program.account.outpostAccount.fetchNullable(outpostAccount);
     }
 
-    async fetchUserWarrantRecord(user: PublicKey): Promise<UserWarrantRecord> {
-        const { userWarrantRecord } = await this.getAccounts(user);
-        return this.program.account.userWarrantRecord.fetch(userWarrantRecord);
+    /**
+     * Fetch the per-user pretoken purchase record.
+     * Returns null if the user has never purchased pretokens.
+     */
+    async fetchUserPretokenRecord(
+        user: PublicKey,
+    ): Promise<UserPretokenRecord | null> {
+        const { userPretokenRecord } = await this.getAccounts(user);
+        return this.program.account.userPretokenRecord.fetchNullable(
+            userPretokenRecord,
+        );
     }
 
-    // ---------------------------------------------------------------------------
-    // Tranche snapshot / quoting
-    // ---------------------------------------------------------------------------
-
     // ---------------------------------------------------------------------------
     // Instruction builders (no send / confirm)
     // ---------------------------------------------------------------------------
 
-    async buildPurchaseWithSolIx(
+    /**
+     * Build a pretoken `purchase` instruction using liqSOL from the user’s ATA.
+     *
+     * This mirrors capital-staking `executePurchase` wiring:
+     * - amountLamports: liqSOL amount (raw token-2022 units, not SOL)
+     */
+    async buildPurchaseIx(
         amountLamports: bigint,
         user = this.wallet.publicKey,
     ): Promise<TransactionInstruction> {
+        console.log('build purchase for', user.toBase58());
+        
         const a = await this.getAccounts(user);
 
+        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
-            .purchaseWithSol(new BN(amountLamports.toString()))
+            .purchase(new BN(amountLamports.toString()))
             .accounts({
                 user: a.user,
                 liqsolMint: a.liqsolMint,
                 globalState: a.globalState,
+                distributionState: a.distributionState,
 
+                // buyer’s liqSOL
+                buyerAta: a.userAta,
+
+                // pool / bucket context
                 poolAuthority: a.poolAuthority,
-                liqsolPoolAta: a.liqsolPoolAta,
-                liqsolPoolUserRecord: a.poolUserRecord,
-                distributionState: a.distributionState,
-                payRateHistory: a.payRateHistory,
                 bucketAuthority: a.bucketAuthority,
                 bucketTokenAccount: a.bucketTokenAccount,
-                solBucket: a.solBucket,
-
-                // IDL name is warrantDepositRecord (wireReceipt PDA)
-                warrantDepositRecord: a.wireReceipt,
-
-                trancheState: a.trancheState,
-                userWarrantRecord: a.userWarrantRecord,
-
-                chainlinkFeed: a.chainLinkFeed,
-                chainlinkProgram: a.chainLinkProgram,
-
-                tokenProgram: TOKEN_2022_PROGRAM_ID,
-                systemProgram: SystemProgram.programId,
-            })
-            .instruction();
-    }
+                bucketUserRecord: a.bucketUserRecord,
 
-    async buildPurchaseWithLiqsolIx(
-        amountLamports: bigint,
-        user = this.wallet.publicKey,
-    ): Promise<TransactionInstruction> {
-        const a = await this.getAccounts(user);
+                // distribution userRecords (token-account keyed)
+                senderUserRecord: a.userUserRecord,
+                receiverUserRecord: a.liqsolPoolUserRecord,
 
-        return this.program.methods
-            .purchaseWithLiqsol(new BN(amountLamports.toString()))
-            .accounts({
-                user: a.user,
-                liqsolMint: a.liqsolMint,
-                globalState: a.globalState,
+                // transfer-hook wiring
+                extraAccountMetaList,
+                liqsolCoreProgram,
+                transferHookProgram,
 
-                buyerAta: a.userAta,
-                poolAuthority: a.poolAuthority,
+                // pool + outpost + tranche
                 liqsolPoolAta: a.liqsolPoolAta,
-
-                warrantDepositRecord: a.wireReceipt,
-
-                liqsolPoolUserRecord: a.poolUserRecord,
-                distributionState: a.distributionState,
-                payRateHistory: a.payRateHistory,
-                bucketAuthority: a.bucketAuthority,
-                bucketTokenAccount: a.bucketTokenAccount,
-                solBucket: a.solBucket,
-
+                outpostAccount: a.outpostAccount,
                 trancheState: a.trancheState,
-                userWarrantRecord: a.userWarrantRecord,
+                userPretokenRecord: a.userPretokenRecord,
 
-                chainlinkFeed: a.chainLinkFeed,
-                chainlinkProgram: a.chainLinkProgram,
+                // Chainlink pricing
+                chainlinkFeed: a.chainLinkFeed ?? CHAINLINK_FEED,
+                chainlinkProgram: a.chainLinkProgram ?? CHAINLINK_PROGRAM,
 
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
                 systemProgram: SystemProgram.programId,
-            })
-            .instruction();
-    }
-
-    async buildPurchaseFromYieldIx(
-        user = this.wallet.publicKey,
-    ): Promise<TransactionInstruction> {
-        const a = await this.getAccounts(user);
-
-        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.poolUserRecord,
-                distributionState: a.distributionState,
-                payRateHistory: a.payRateHistory,
-                bucketAuthority: a.bucketAuthority,
-                bucketTokenAccount: a.bucketTokenAccount,
+                pretokenPurchaseHistory: a.pretokenPurchaseHistory,
 
-                trancheState: a.trancheState,
-                userWarrantRecord: a.userWarrantRecord,
-                chainlinkFeed: a.chainLinkFeed,
-                chainlinkProgram: a.chainLinkProgram,
-
-                tokenProgram: TOKEN_2022_PROGRAM_ID,
-                systemProgram: SystemProgram.programId,
+                globalConfig: a.globalConfig,
+                oppEpochState: a.oppEpochState, 
+                pendingAttestations: a.pendingAttestations
             })
             .instruction();
     }
 
+    // NOTE:
+    // - There is no longer `purchaseWithSol` in the IDL - SOL → liqSOL happens
+    //   through the deposit / liqSOL minting path, not directly in pretokens.
+    // - `purchaseFromYield` is an operator-facing / protocol flow and you
+    //   indicated you’ll trigger it from Wire infra, so we don’t expose a
+    //   client helper here for now.
+
     // ---------------------------------------------------------------------------
     // Price helpers (SOL/USD via priceHistory account)
     // ---------------------------------------------------------------------------
@@ -194,10 +179,10 @@ export class TokenClient {
 
     /**
      * Fetch latest SOL/USD price (1e8 scale) from liqsol_core.priceHistory.
-     * Uses the ring-buffer semantics from earlier SDK code.
+     * 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;
@@ -205,19 +190,23 @@ export class TokenClient {
         const { prices, nextIndex, count, windowSize } = history;
 
         if (!prices || prices.length === 0 || !count) {
-            throw new Error('Price history is empty – no SOL price available');
+            throw new Error('Price history is empty - no SOL price available');
         }
 
         const capacity = prices.length || windowSize;
         if (!capacity) {
-            throw new Error('Price history capacity is zero – check account layout');
+            throw new Error(
+                'Price history capacity is zero - check account layout',
+            );
         }
 
         const lastIndex = nextIndex === 0 ? capacity - 1 : nextIndex - 1;
         const latest = prices[lastIndex];
 
         if (!BN.isBN(latest)) {
-            throw new Error('Latest price entry is not a BN – check IDL/decoder');
+            throw new Error(
+                'Latest price entry is not a BN - check IDL/decoder',
+            );
         }
 
         return BigInt(latest.toString());

package/src/networks/solana/constants.ts

@@ -1,43 +1,65 @@
 // 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 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).
  */
-// Extract program IDs from IDL files
-export const PROGRAM_IDS = {
-    LIQSOL_CORE: new PublicKey(liqsolCoreIDL.address),
-    LIQSOL_TOKEN: new PublicKey(liqSolTokenIDL.address),
-    VALIDATOR_LEADERBOARD: new PublicKey(validatorLeaderboardIDL.address),
-} as const;
+export type SolanaProgramIds = {
+    LIQSOL_CORE: PublicKey;
+    LIQSOL_TOKEN: PublicKey;
+    VALIDATOR_LEADERBOARD: PublicKey;
+    TRANSFER_HOOK: PublicKey;
+    ALT: PublicKey;
+};
 
-// Export individual program IDs for convenience
-export const {
-    LIQSOL_CORE,
-    LIQSOL_TOKEN,
-    VALIDATOR_LEADERBOARD,
-} = 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),
+    ALT: new PublicKey("AQXTHwkdNBEiXeQuVA5uCoxvzgYUmudRxthQY4vWKCPS")
+};
+
+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),
+    ALT: new PublicKey("AZQmTbacBuAsJpncg2N2AwcZsLG1Sxeohbau9vjezmTz")
+};
+
+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)
  * ---------------------------------------------------------------------------
- *
- * These strings are baked into the on-chain programs and are already used in
- * your test utils. We centralize them here so all clients share them.
  */
-
 export const PDA_SEEDS = {
+    // GLOBAL CONFIG
+    GLOBAL_CONFIG: 'global_config',
+
     // liqsol_core: deposit / stake controller
     DEPOSIT_AUTHORITY: 'deposit_authority',
     VAULT: 'vault',
@@ -54,236 +76,86 @@ export const PDA_SEEDS = {
     DISTRIBUTION_STATE: 'distribution_state',
     USER_RECORD: 'user_record',
 
-    // pay-rate history
+    // pay-rate / price history
     PAY_RATE_HISTORY: 'pay_rate_history',
+    PRICE_HISTORY: 'price_history',
 
     // validator leaderboard (state + records)
     LEADERBOARD_STATE: 'leaderboard_state',
     VALIDATOR_RECORD: 'validator',
     GLOBAL_STAKE_INFO: 'global_stake_info',
 
-    // Outpost
-    WARRANT_DEPOSIT_GLOBAL: 'warrant_deposit_global',
+    // Outpost / Wire pretokens
+    OUTPOST_GLOBAL_STATE: 'outpost_global_state',
     LIQSOL_POOL: 'liqsol_pool',
-    WARRANT_DEPOSIT_RECORD: 'warrant_deposit_record',
-    WIRE_SOL_BUCKET: 'wire_sol_bucket',
+    OUTPOST_ACCOUNT: 'outpost_account',
+    USER_PRETOKEN_RECORD: 'user_pretoken_record',
     TRANCHE_STATE: 'tranche_state',
-    USER_WARRANT_RECORD: 'user_warrant_record',
 
-    // BAR
+    // BAR module (bonded actor roles)
     BAR_STATE_SEED: 'bar_state',
     BONDED_ACTOR_SEED: 'bonded_actor',
     BOND_LEVEL_SEED: 'bond_level',
 
-    // Other?
-    PRICE_HISTORY: 'price_history',
+    // SPL transfer-hook extra account metas
+    EXTRA_ACCOUNT_METAS: 'extra-account-metas',
+
+    // Withdraw module / receipts
+    WITHDRAW_GLOBAL: 'global',
+    STAKE_ALLOCATION_STATE: 'stake_allocation_state',
+    STAKE_METRICS: 'stake_metrics',
+    MAINTENANCE_LEDGER: 'maintenance_ledger',
+    WITHDRAW_MINT_AUTHORITY: 'mint_authority',
+    MINT_METADATA: 'mint_metadata',
+    LIQ_RECEIPT_DATA: 'liq_receipt_data',
+    WITHDRAW_MINT: 'mint',
+
+    // New
+    PRETOKEN_PURCHASE_HISTORY: 'pretoken_purchase_history',
+
+    // OPP (outpost protocol pipeline)
+    OPP_EPOCH_STATE: 'opp_epoch_state',
+    PENDING_ATTESTATIONS: 'pending_attestations',
+    OPP_BRIDGE_STATE: 'opp_bridge_state',
 } as const;
 
 /**
- * Helpers for PDA derivation so clients don’t duplicate logic.
- */
-export const deriveLiqsolMintPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.LIQSOL_MINT)],
-        PROGRAM_IDS.LIQSOL_TOKEN,
-    )[0];
-
-export const deriveLiqsolMintAuthorityPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.LIQSOL_MINT_AUTHORITY)],
-        PROGRAM_IDS.LIQSOL_TOKEN,
-    )[0];
-
-export const deriveDepositAuthorityPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.DEPOSIT_AUTHORITY)],
-        PROGRAM_IDS.LIQSOL_CORE,
-    )[0];
-
-export const deriveVaultPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.VAULT)],
-        PROGRAM_IDS.LIQSOL_CORE,
-    )[0];
-
-export const deriveReservePoolPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.RESERVE_POOL)],
-        PROGRAM_IDS.LIQSOL_CORE,
-    )[0];
-
-export const deriveStakeControllerStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.STAKE_CONTROLLER_STATE)],
-        PROGRAM_IDS.LIQSOL_CORE,
-    )[0];
-
-export const derivePayoutStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.PAYOUT_STATE)],
-        PROGRAM_IDS.LIQSOL_CORE,
-    )[0];
-
-export const deriveBucketAuthorityPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.BUCKET_AUTHORITY)],
-        PROGRAM_IDS.LIQSOL_CORE,
-    )[0];
-
-export const deriveDistributionStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.DISTRIBUTION_STATE)],
-        PROGRAM_IDS.LIQSOL_CORE,
-    )[0];
-
-export const deriveUserRecordPda = (user: PublicKey) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.USER_RECORD), user.toBuffer()],
-        PROGRAM_IDS.LIQSOL_CORE,
-    )[0];
-
-export const derivePayRateHistoryPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.PAY_RATE_HISTORY)],
-        PROGRAM_IDS.LIQSOL_CORE,
-    )[0];
-
-export const deriveLeaderboardStatePda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.LEADERBOARD_STATE)],
-        PROGRAM_IDS.VALIDATOR_LEADERBOARD,
-    )[0];
-
-export const deriveValidatorRecordPda = (voteAccount: PublicKey) =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.VALIDATOR_RECORD), voteAccount.toBuffer()],
-        PROGRAM_IDS.VALIDATOR_LEADERBOARD,
-    )[0];
-
-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];
-
-export const derivePriceHistoryPda = () =>
-    PublicKey.findProgramAddressSync(
-        [Buffer.from(PDA_SEEDS.PRICE_HISTORY)],
-        LIQSOL_CORE,
-    )[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,
-    seed: any,
+    seed: number,
 ): Promise<PublicKey> => {
     const seedStr = `ephemeral_${seed}`;
-    return await PublicKey.createWithSeed(user, seedStr, StakeProgram.programId);
+    return PublicKey.createWithSeed(user, seedStr, StakeProgram.programId);
 };
 
 /**
- * Constant keys
+ * Constant keys (Chainlink)
  */
-
-export const CHAINLINK_FEED = new PublicKey("99B2bTijsU6f1GCT73HmdR7HCFFjGMBcPZY6jZ96ynrR");
-export const CHAINLINK_PROGRAM = new PublicKey("HEvSKofvBgfaexv23kMabbYqxasxU3mQ4ibBMEmJWHny");
+export const CHAINLINK_FEED = new PublicKey(
+    'CH31Xns5z3M1cTAbKW34jcxPPciazARpijcHj9rxtemt',
+);
+export const CHAINLINK_PROGRAM = new PublicKey(
+    'HEvSKofvBgfaexv23kMabbYqxasxU3mQ4ibBMEmJWHny',
+);
 
 /**
  * ---------------------------------------------------------------------------
  *  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)
-// Mirrors EPHEMERAL_RENT_EXEMPTION = 2_282_880 used in tests
 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 =>
     Number(lamports) / LAMPORTS_PER_SOL;
 
 export const solToLamports = (sol: number): bigint =>
-    BigInt(Math.round(sol * LAMPORTS_PER_SOL));
+    BigInt(Math.round(sol * LAMPORTS_PER_SOL));