@wireio/stake 0.1.0 → 0.1.1

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

@@ -1,169 +1,131 @@
-import { AnchorProvider, 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 {
-    getAssociatedTokenAddress,
+    TOKEN_2022_PROGRAM_ID,
     ASSOCIATED_TOKEN_PROGRAM_ID,
-    TOKEN_2022_PROGRAM_ID
+    getAssociatedTokenAddressSync,
 } from '@solana/spl-token';
 
+import { SolanaProgramService } from '../program';
+import type { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
+
 import {
-    STAKE_CONTROLLER_PROGRAM_ID,
-    LIQSOL_TOKEN_PROGRAM_ID,
-    DISTRIBUTION_PROGRAM_ID,
-    MIN_SOL_TO_PARTICIPATE,
-    deriveDepositAuthorityPDA,
-    deriveLiqsolMintPDA,
-    deriveLiqsolMintAuthorityPDA,
-    deriveStakeControllerReservePoolPDA,
-    deriveStakeControllerVaultPDA,
-    deriveStakeControllerStatePDA,
-    deriveGlobalStakeInfoPDA,
-    deriveBucketAuthorityPDA,
-    deriveDistributionStatePDA,
-    deriveUserRecordPDA,
-    derivePayRateHistoryPDA,
+    PROGRAM_IDS,
+    deriveDepositAuthorityPda,
+    deriveLiqsolMintPda,
+    deriveLiqsolMintAuthorityPda,
+    deriveReservePoolPda,
+    deriveVaultPda,
+    deriveStakeControllerStatePda,
+    deriveBucketAuthorityPda,
+    derivePayRateHistoryPda,
+    deriveDistributionStatePda,
+    deriveUserRecordPda,
+    derivePayoutStatePda,
+    deriveEphemeralStakeAddress,
 } from '../constants';
-import { SolanaProgramService } from '../program';
 
-/**
- * DepositClient: builds, simulates, and sends deposit txns matching the latest IDL.
- *
- */
 export class DepositClient {
-    private programs = new SolanaProgramService(this.provider);
+    private program: Program<LiqsolCore>;
 
-    constructor(private provider: AnchorProvider) { }
+    constructor(private provider: AnchorProvider) {
+        const svc = new SolanaProgramService(provider);
+        this.program = svc.getProgram('liqsolCore');
+    }
 
-    /**
-     * Build the deposit transaction (compute-budget bump + deposit Ix).
-     * 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`);
-        }
+        lamports: number
+    ): Promise<{ transaction: Transaction; ephemeralStake: PublicKey }> {
 
-        const program = this.programs.getProgram('deposit');
+        const program = this.program;
 
+        // -------------------------------------------------------------
         // 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();
-
+        // -------------------------------------------------------------
+        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 = await getAssociatedTokenAddress(
+        // -------------------------------------------------------------
+        const userAta = getAssociatedTokenAddressSync(
             liqsolMint,
             user,
             false,
             TOKEN_2022_PROGRAM_ID
         );
-        const bucketTokenAccount = await getAssociatedTokenAddress(
+
+        const bucketTokenAccount = getAssociatedTokenAddressSync(
             liqsolMint,
             bucketAuthority,
-            /* allowOwnerOffCurve */ true,
+            true,
             TOKEN_2022_PROGRAM_ID
         );
 
-        // Ephemeral stake account
-        const seed = Math.floor(Math.random() * 0xffffffff);
-        const ephemeralSeed = `ephemeral_${seed}`;
-        const ephemeralStakePubkey = await PublicKey.createWithSeed(
-            user,
-            ephemeralSeed,
-            StakeProgram.programId
-        );
-
-        // Build the 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,
+                depositAuthority,
                 systemProgram: SystemProgram.programId,
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-                stakeControllerProgram: STAKE_CONTROLLER_PROGRAM_ID,
-                liqsolProgram: LIQSOL_TOKEN_PROGRAM_ID,
-                payRateHistory,
+                liqsolProgram: PROGRAM_IDS.LIQSOL_TOKEN,
                 stakeProgram: StakeProgram.programId,
-                distributionProgram: DISTRIBUTION_PROGRAM_ID,
 
-                // mints / ATAs / PDAs
                 liqsolMint,
                 userAta,
                 liqsolMintAuthority,
                 reservePool,
                 vault,
-                ephemeralStake: ephemeralStakePubkey,
+                ephemeralStake,
+
                 controllerState,
-                globalStakeInfo,
+                payoutState,
                 bucketAuthority,
                 bucketTokenAccount,
+
                 userRecord,
                 distributionState,
+                payRateHistory,
 
-                // sysvars
                 instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
                 clock: SYSVAR_CLOCK_PUBKEY,
                 stakeHistory: SYSVAR_STAKE_HISTORY_PUBKEY,
                 rent: SYSVAR_RENT_PUBKEY,
-            } as any)
+            })
             .instruction();
 
-        // Prepend compute-budget bump
-        const computeIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
-        const tx = new Transaction().add(computeIx, depositIx);
-        return { transaction: tx, ephemeralStakePubkey };
-    }
-
-    /** 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,
-        });
-        return { err: sim.value.err, unitsConsumed: sim.value.unitsConsumed! };
-    }
-
-    /** Build + send. Returns confirmed signature. */
-    async deposit(
-        user: PublicKey,
-        amount: number,
-        signers: Signer[] = []
-    ): Promise<TransactionSignature> {
-        const { transaction } = await this.buildDepositTx(user, amount);
-        transaction.feePayer = this.provider.wallet.publicKey;
-        const { blockhash } = await this.provider.connection.getLatestBlockhash();
-        transaction.recentBlockhash = blockhash;
-        return this.provider.sendAndConfirm(transaction, signers);
+        const tx = new Transaction().add(ix);
+        return { transaction: tx, ephemeralStake };
     }
 }