@wireio/stake 0.0.6 → 0.1.0

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

@@ -1,5 +1,4 @@
-import { AnchorProvider } from '@coral-xyz/anchor';
-import { BN } from '@coral-xyz/anchor';
+import { AnchorProvider, BN } from '@coral-xyz/anchor';
 import {
     PublicKey,
     Transaction,
@@ -14,81 +13,83 @@ import {
     Signer,
     TransactionSignature,
 } from '@solana/web3.js';
+
 import {
-    TOKEN_2022_PROGRAM_ID,
+    getAssociatedTokenAddress,
     ASSOCIATED_TOKEN_PROGRAM_ID,
+    TOKEN_2022_PROGRAM_ID
 } from '@solana/spl-token';
 
 import {
+    STAKE_CONTROLLER_PROGRAM_ID,
+    LIQSOL_TOKEN_PROGRAM_ID,
+    DISTRIBUTION_PROGRAM_ID,
+    MIN_SOL_TO_PARTICIPATE,
     deriveDepositAuthorityPDA,
+    deriveLiqsolMintPDA,
     deriveLiqsolMintAuthorityPDA,
-    deriveStakeControllerVaultPDA,
     deriveStakeControllerReservePoolPDA,
+    deriveStakeControllerVaultPDA,
     deriveStakeControllerStatePDA,
+    deriveGlobalStakeInfoPDA,
+    deriveBucketAuthorityPDA,
     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,
+    derivePayRateHistoryPDA,
 } 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.
+ * DepositClient: builds, simulates, and sends deposit txns matching the latest IDL.
  *
- * @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);
+    private programs = 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.
+     * Returns the Transaction and the derived ephemeral stake 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`
-            );
+            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);
+        const program = this.programs.getProgram('deposit');
+
+        // PDAs
+        const [programAuthority] = deriveDepositAuthorityPDA();
+        const [liqsolMint] = deriveLiqsolMintPDA();
+        const [liqsolMintAuthority] = deriveLiqsolMintAuthorityPDA();
+        const [reservePool] = deriveStakeControllerReservePoolPDA();
+        const [vault] = deriveStakeControllerVaultPDA();
+        const [controllerState] = deriveStakeControllerStatePDA();
+        const [globalStakeInfo] = deriveGlobalStakeInfoPDA();
+        const [bucketAuthority] = deriveBucketAuthorityPDA();
+        const [distributionState] = deriveDistributionStatePDA();
+        const [userRecord] = deriveUserRecordPDA(user);
+        const [payRateHistory] = derivePayRateHistoryPDA();
+
+        // Token-2022 ATAs
+        const userAta = await getAssociatedTokenAddress(
+            liqsolMint,
+            user,
+            false,
+            TOKEN_2022_PROGRAM_ID
+        );
+        const bucketTokenAccount = await getAssociatedTokenAddress(
+            liqsolMint,
+            bucketAuthority,
+            /* allowOwnerOffCurve */ true,
+            TOKEN_2022_PROGRAM_ID
+        );
 
-        // 3) ephemeral stake account
+        // Ephemeral stake account
         const seed = Math.floor(Math.random() * 0xffffffff);
         const ephemeralSeed = `ephemeral_${seed}`;
         const ephemeralStakePubkey = await PublicKey.createWithSeed(
@@ -97,30 +98,36 @@ export class DepositClient {
             StakeProgram.programId
         );
 
-        // 4) build deposit instruction
+        // Build the deposit instruction
         const depositIx = await program.methods
             .deposit(new BN(amount), seed)
             .accounts({
                 user,
-                programAuthority: depositAuthPDA,
-                treasuryWallet: TREASURY_WALLET_PDA,
+                programAuthority,
                 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,
+                payRateHistory,
                 stakeProgram: StakeProgram.programId,
                 distributionProgram: DISTRIBUTION_PROGRAM_ID,
-                liqsolMint: LIQSOL_MINT_ADDRESS,
+
+                // mints / ATAs / PDAs
+                liqsolMint,
                 userAta,
-                liqsolMintAuthority: mintAuthPDA,
-                reservePool: reservePoolPDA,
-                vault: vaultPDA,
+                liqsolMintAuthority,
+                reservePool,
+                vault,
                 ephemeralStake: ephemeralStakePubkey,
-                controllerState: controllerStatePDA,
-                userRecord: userRecordPDA,
-                distributionState: distStatePDA,
+                controllerState,
+                globalStakeInfo,
+                bucketAuthority,
+                bucketTokenAccount,
+                userRecord,
+                distributionState,
+
+                // sysvars
                 instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
                 clock: SYSVAR_CLOCK_PUBKEY,
                 stakeHistory: SYSVAR_STAKE_HISTORY_PUBKEY,
@@ -128,51 +135,35 @@ export class DepositClient {
             } as any)
             .instruction();
 
-        // 5) prepend compute-budget bump
-        const computeIx = ComputeBudgetProgram.setComputeUnitLimit({
-            units: 400_000,
-        });
-
+        // 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 }> {
+    /** Simulate a transaction (dry-run). */
+    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 }
-        );
+        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.
-     */
+    /** Build + send. Returns 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);
     }
 }