@wireio/stake 0.3.1 → 0.4.1

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

@@ -1,237 +1,173 @@
 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 liqsolCoreIDL from '../../../assets/solana/idl/liqsol_core.json';
+import { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
+
 import {
+    OutpostAccounts,
     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';
+
+import {
+    OutpostWireStateSnapshot,
+    SharesPreview,
+    TrancheState,
+    WalletLike,
+} from '../types';
+import { INDEX_SCALE, PROGRAM_IDS } from '../constants';
 
 /**
- * Minimal, user-flow focused OutpostClient.
- * - Read state
- * - Build + (optionally) send user instructions
+ * OutpostClient
  *
- * No admin/bootstrap/reset helpers by design.
+ * Read-only + preview helper for:
+ *  - Outpost config + per-user pretokens
+ *  - Tranche ladder snapshot
+ *  - Pretoken preview math
+ *
+ * Write helpers:
+ *  - buildStakeIx   → liqsol_core::synd
+ *  - buildUnstakeIx → liqsol_core::desynd
+ *
+ * All PDAs / ATAs are sourced via buildOutpostAccounts, which is kept
+ * in sync with the on-chain PDAs and capital-staking Wire utils.
  */
 export class OutpostClient {
-    private readonly program: Program<LiqsolCore>;  
-
-    // keep consistent with your tests
-    static readonly INDEX_SCALE = new BN('1000000000000');
+    private readonly program: Program<LiqsolCore>;
 
-    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');
+    constructor(
+        private readonly provider: AnchorProvider,
+    ) {
+        this.program = new Program(liqsolCoreIDL as any, provider);
     }
 
-    /**
-     * 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);
+    get connection() {
+        return this.provider.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);
+    get wallet(): WalletLike {
+        return this.provider.wallet as unknown as WalletLike;
     }
 
     /**
-     * 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.)
+     * Expose the raw Program in case callers need to build custom
+     * instructions outside this client.
      */
-    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,
-        };
+    get liqsolCoreProgram(): Program<LiqsolCore> {
+        return this.program;
     }
 
-    // ---------------------------------------------------------------------------
-    // Account helpers (user-facing, not admin bootstrap)
-    // ---------------------------------------------------------------------------
-
     /**
-     * Returns whether the user's liqSOL ATA exists.
-     * Useful for UX (show "Create token account" prompt).
+     * Build all outpost-related PDAs / ATAs for a given user.
+     * Defaults to the connected wallet.
      */
-    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;
+    async buildAccounts(user?: PublicKey): Promise<OutpostAccounts> {
+        const userPk = user ?? this.wallet.publicKey;
+        if (!userPk) {
+            throw new Error('OutpostClient.buildAccounts: wallet not connected');
+        }
+        return buildOutpostAccounts(this.connection, userPk);
     }
 
     /**
-     * Builds an instruction to create the user's liqSOL ATA (Token-2022).
-     * This is general-purpose sugar for any flow that needs the ATA.
+     * Internal helper: get raw token balance (BN) for a given 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,
-        );
+    private async getTokenBalance(ata: PublicKey): Promise<BN> {
+        try {
+            const bal = await this.connection.getTokenAccountBalance(ata);
+            return new BN(bal.value.amount);
+        } catch {
+            return new BN(0);
+        }
     }
 
     /**
-     * Convenience: ensures ATA exists by returning either [] or [createATAIx].
-     * (Does NOT send; caller composes tx)
+     * Fetch the core "Wire state" for Outpost / pretokens for a given user.
      */
-    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 fetchWireState(user?: PublicKey): Promise<OutpostWireStateSnapshot> {
+        const userPk = user ?? this.wallet.publicKey;
+        if (!userPk) {
+            throw new Error('OutpostClient.fetchWireState: wallet not connected');
+        }
 
-    async getWireStateSnapshot(user: PublicKey = this.wallet.publicKey): Promise<OutpostWireStateSnapshot> {
-        const accounts = await buildOutpostAccounts(this.connection, user);
+        const pdas = await this.buildAccounts(userPk);
 
         const [
             globalState,
-            wireReceipt,
+            outpostAccount,
             distributionState,
-            userWarrantRecord,
+            userPretokenRecord,
             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),
+            this.program.account.globalState.fetch(pdas.globalState),
+            this.program.account.outpostAccount.fetchNullable(pdas.outpostAccount),
+            this.program.account.distributionState.fetchNullable(pdas.distributionState),
+            this.program.account.userPretokenRecord.fetchNullable(pdas.userPretokenRecord),
+            this.program.account.trancheState.fetchNullable(pdas.trancheState),
         ]);
 
-        const [
-            liqsolPoolBalance,
-            solBucketLamports,
-            userLiqsolBalance,
-        ] = await Promise.all([
-            this.getTokenBalanceSafe(accounts.liqsolPoolAta),
-            this.connection.getBalance(accounts.solBucket),
-            this.getTokenBalanceSafe(accounts.userAta),
+        const [liqsolPoolBalance, userLiqsolBalance] = await Promise.all([
+            this.getTokenBalance(pdas.liqsolPoolAta),
+            this.getTokenBalance(pdas.userAta),
         ]);
 
         return {
             globalState,
+            outpostAccount,
             distributionState,
-            wireReceipt,
             trancheState,
-            userWarrantRecord,
+            userPretokenRecord,
             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)
-    // ---------------------------------------------------------------------------
+    // -------------------------------------------------------------------------
+    // Outpost stake / unstake builders (synd / desynd)
+    // -------------------------------------------------------------------------
 
     /**
-     * stakeLiqsol(amount)
-     * (Outpost staking: liqSOL -> warrant pool)
+     * Build the `synd` (stake) instruction:
+     *   user liqSOL ATA → liqSOL pool ATA
      */
-    async buildStakeLiqsolIx(amountLamports: bigint, userPubKey = this.wallet.publicKey): Promise<TransactionInstruction> {
-        const a = await buildOutpostAccounts(this.connection, userPubKey);
-        const amount = new BN(amountLamports.toString());
+    async buildStakeIx(
+        amountLamports: bigint,
+        user?: PublicKey,
+    ): Promise<TransactionInstruction> {
+        const userPk = user ?? this.wallet.publicKey;
+        if (!userPk) {
+            throw new Error('OutpostClient.buildStakeIx: wallet not connected');
+        }
+
+        const a = await this.buildAccounts(userPk);
 
         return this.program.methods
-            .stakeLiqsol(amount)
+            .synd(new BN(amountLamports.toString()))
             .accounts({
-                user: a.user,
+                user: userPk,
                 liqsolMint: a.liqsolMint,
                 globalState: a.globalState,
+                distributionState: a.distributionState,
                 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,
+                bucketUserRecord: a.bucketUserRecord,
+                senderUserRecord: a.userUserRecord,
+                receiverUserRecord: a.liqsolPoolUserRecord,
+                extraAccountMetaList: a.extraAccountMetaList,
+                liqsolCoreProgram: PROGRAM_IDS.LIQSOL_CORE,
+                transferHookProgram: PROGRAM_IDS.TRANSFER_HOOK,
+                liqsolPoolAta: a.liqsolPoolAta,
+                outpostAccount: a.outpostAccount,
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
                 systemProgram: SystemProgram.programId,
@@ -240,235 +176,128 @@ export class OutpostClient {
     }
 
     /**
-     * withdrawStake(amount)
-     * (Outpost unstake: warrant pool -> user liqSOL)
+     * Build the `desynd` (unstake) instruction:
+     *   liqSOL pool ATA → user liqSOL ATA
      */
-    async buildWithdrawStakeIx(amountLamports: bigint, userPubKey = this.wallet.publicKey): Promise<TransactionInstruction> {
-        const a = await buildOutpostAccounts(this.connection, userPubKey);
-        const amount = new BN(amountLamports.toString());
+    async buildUnstakeIx(
+        amountLamports: bigint,
+        user?: PublicKey,
+    ): Promise<TransactionInstruction> {
+        const userPk = user ?? this.wallet.publicKey;
+        if (!userPk) {
+            throw new Error('OutpostClient.buildUnstakeIx: wallet not connected');
+        }
+
+        const a = await this.buildAccounts(userPk);
 
         return this.program.methods
-            .withdrawStake(amount)
+            .desynd(new BN(amountLamports.toString()))
             .accounts({
-                user: a.user,
+                user: userPk,
                 liqsolMint: a.liqsolMint,
                 globalState: a.globalState,
+                distributionState: a.distributionState,
                 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,
+                bucketUserRecord: a.bucketUserRecord,
+                senderUserRecord: a.liqsolPoolUserRecord,
+                receiverUserRecord: a.userUserRecord,
+                extraAccountMetaList: a.extraAccountMetaList,
+                liqsolCoreProgram: PROGRAM_IDS.LIQSOL_CORE,
+                transferHookProgram: PROGRAM_IDS.TRANSFER_HOOK,
                 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,
+                outpostAccount: a.outpostAccount,
                 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();
-    }
+    // -------------------------------------------------------------------------
+    // Pretoken preview helper (unchanged)
+    // -------------------------------------------------------------------------
 
     /**
-     * purchaseWarrantsFromYield()
+     * Local preview for "how many pretokens would I get for this liqSOL
+     * amount at the current tranche price and SOL/USD price?"
+     *
+     *   SCALE = 1e8
+     *   usdValue = solAmountLamports * solPriceUsd / 1e9
+     *   pretokens = usdValue * SCALE / pretokenPriceUsd
      *
-     * Source of truth: your test util executePurchaseFromYield (note: it passed
-     * liqsolPoolUserRecord: pdas.userUserRecord, not poolUserRecord).
+     * All values are BN integers; solPriceUsd and pretokenPriceUsd are 1e8 scaled.
      */
-    async buildPurchaseFromYieldIx(userPubKey = this.wallet.publicKey): Promise<TransactionInstruction> {
-        const a = await buildOutpostAccounts(this.connection, userPubKey);
+    previewPretokens(params: {
+        liqsolAmountLamports: BN;
+        solPriceUsd: BN; // 1e8 scale
+        trancheState: TrancheState;
+    }): SharesPreview {
+        const { liqsolAmountLamports, solPriceUsd, trancheState } = params;
+
+        // Current tranche price in USD (1e8 scale)
+        const pretokenPriceUsd = new BN(
+            trancheState.currentTranchePriceUsd.toString(),
+        );
 
-        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();
-    }
+        const SCALE = new BN('100000000'); // 1e8
 
-    // ---------------------------------------------------------------------------
-    // Optional send helpers (wallet-facing sugar)
-    // ---------------------------------------------------------------------------
+        // usdValue = (lamports * solPriceUsd) / 1e9
+        const usdValue = liqsolAmountLamports
+            .mul(solPriceUsd)
+            .div(new BN(1_000_000_000));
 
-    /**
-     * 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);
+        const estimatedPretokens = usdValue.mul(SCALE).div(pretokenPriceUsd);
 
-        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}`);
-        }
+        return {
+            liqsolAmountLamports,
+            solPriceUsd,
+            pretokenPriceUsd,
+            estimatedPretokens,
+        };
     }
 
     /**
-     * Convenience: stake liqSOL and (optionally) create ATA first.
+     * Convert liqSOL tokens (lamports) → Outpost “shares”, rounding UP
+     * when there is any remainder.
+     *
+     * This matches the on-chain logic and the capital-staking helper:
+     *
+     *   INDEX_SCALE = 1e12
+     *   numerator   = amount * INDEX_SCALE
+     *   shares      = numerator / currentIndex
+     *   remainder   = numerator % currentIndex
+     *   if remainder > 0 → shares + 1
      */
-    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);
+    static tokensToShares(amount: BN, currentIndex: BN): BN {
+        const numerator = amount.mul(INDEX_SCALE);
+        const shares = numerator.div(currentIndex);
+        const remainder = numerator.mod(currentIndex);
+        return remainder.eqn(0) ? shares : shares.addn(1);
     }
 
-    // ---------------------------------------------------------------------------
-    // Internals
-    // ---------------------------------------------------------------------------
-
     /**
-     * Token balance helper returning BN(0) if ATA missing.
+     * Format a 1e8-scaled integer (e.g. USD price, pretokens, etc.)
+     * into a fixed 8-decimal string.
+     *
+     * Examples:
+     *   0          -> "0.00000000"
+     *   1          -> "0.00000001"
+     *   100000000  -> "1.00000000"
+     *   123456789  -> "1.23456789"
      */
-    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);
+    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}`;
     }
 }