@wireio/stake 0.0.6 → 0.1.1

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

@@ -1,178 +1,131 @@
-import { AnchorProvider } from '@coral-xyz/anchor';
-import { BN } from '@coral-xyz/anchor';
+import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
 import {
     PublicKey,
-    Transaction,
     SystemProgram,
+    Transaction,
+    TransactionInstruction,
+    StakeProgram,
     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,
+    getAssociatedTokenAddressSync,
 } from '@solana/spl-token';
 
+import { SolanaProgramService } from '../program';
+import type { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
+
 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,
+    PROGRAM_IDS,
+    deriveDepositAuthorityPda,
+    deriveLiqsolMintPda,
+    deriveLiqsolMintAuthorityPda,
+    deriveReservePoolPda,
+    deriveVaultPda,
+    deriveStakeControllerStatePda,
+    deriveBucketAuthorityPda,
+    derivePayRateHistoryPda,
+    deriveDistributionStatePda,
+    deriveUserRecordPda,
+    derivePayoutStatePda,
+    deriveEphemeralStakeAddress,
 } 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) { }
+    private program: Program<LiqsolCore>;
 
-    /** Minimum lamports (1 SOL) */
-    static readonly MIN_DEPOSIT = MIN_SOL_TO_PARTICIPATE;
+    constructor(private provider: AnchorProvider) {
+        const svc = new SolanaProgramService(provider);
+        this.program = svc.getProgram('liqsolCore');
+    }
 
-    /**
-     * 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(
+        lamports: number
+    ): Promise<{ transaction: Transaction; ephemeralStake: PublicKey }> {
+
+        const program = this.program;
+
+        // -------------------------------------------------------------
+        // PDAs
+        // -------------------------------------------------------------
+        const depositAuthority = deriveDepositAuthorityPda();
+        const liqsolMint = deriveLiqsolMintPda();
+        const liqsolMintAuthority = deriveLiqsolMintAuthorityPda();
+        const reservePool = deriveReservePoolPda();
+        const vault = deriveVaultPda();
+        const controllerState = deriveStakeControllerStatePda();
+        const payoutState = derivePayoutStatePda();
+        const bucketAuthority = deriveBucketAuthorityPda();
+        const payRateHistory = derivePayRateHistoryPda();
+        const distributionState = deriveDistributionStatePda();
+        const userRecord = deriveUserRecordPda(user);
+
+        // -------------------------------------------------------------
+        // Token-2022 ATAs
+        // -------------------------------------------------------------
+        const userAta = getAssociatedTokenAddressSync(
+            liqsolMint,
             user,
-            ephemeralSeed,
-            StakeProgram.programId
+            false,
+            TOKEN_2022_PROGRAM_ID
+        );
+
+        const bucketTokenAccount = getAssociatedTokenAddressSync(
+            liqsolMint,
+            bucketAuthority,
+            true,
+            TOKEN_2022_PROGRAM_ID
         );
 
-        // 4) build deposit instruction
-        const depositIx = await program.methods
-            .deposit(new BN(amount), seed)
+        // -------------------------------------------------------------
+        // Ephemeral stake
+        // -------------------------------------------------------------
+        const seed = Math.floor(Math.random() * 2 ** 32);
+        const ephemeralStake = await deriveEphemeralStakeAddress(user, seed);
+
+        // -------------------------------------------------------------
+        // BUILD IX (MUST MATCH IDL)
+        // -------------------------------------------------------------
+        const ix: TransactionInstruction = await program.methods
+            .deposit(new BN(lamports), seed)
             .accounts({
                 user,
-                programAuthority: depositAuthPDA,
-                treasuryWallet: TREASURY_WALLET_PDA,
+                depositAuthority,
                 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,
+                liqsolProgram: PROGRAM_IDS.LIQSOL_TOKEN,
                 stakeProgram: StakeProgram.programId,
-                distributionProgram: DISTRIBUTION_PROGRAM_ID,
-                liqsolMint: LIQSOL_MINT_ADDRESS,
+
+                liqsolMint,
                 userAta,
-                liqsolMintAuthority: mintAuthPDA,
-                reservePool: reservePoolPDA,
-                vault: vaultPDA,
-                ephemeralStake: ephemeralStakePubkey,
-                controllerState: controllerStatePDA,
-                userRecord: userRecordPDA,
-                distributionState: distStatePDA,
+                liqsolMintAuthority,
+                reservePool,
+                vault,
+                ephemeralStake,
+
+                controllerState,
+                payoutState,
+                bucketAuthority,
+                bucketTokenAccount,
+
+                userRecord,
+                distributionState,
+                payRateHistory,
+
                 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);
+        const tx = new Transaction().add(ix);
+        return { transaction: tx, ephemeralStake };
     }
 }