@wireio/stake 2.1.1 → 2.2.2

package/lib/stake.browser.js

@@ -1,7 +1,7 @@
 import { SolChainID, PublicKey as PublicKey$1, KeyType, EvmChainID } from '@wireio/core';
-import { SystemProgram, StakeProgram, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_CLOCK_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, SYSVAR_RENT_PUBKEY, Transaction, PublicKey, Keypair, Connection, TransactionMessage, ComputeBudgetProgram, SendTransactionError } from '@solana/web3.js';
+import { SystemProgram, StakeProgram, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_CLOCK_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, SYSVAR_RENT_PUBKEY, PublicKey, Keypair, Connection, ComputeBudgetProgram, TransactionMessage, Transaction, SendTransactionError } from '@solana/web3.js';
 import { BN, Program, AnchorProvider } from '@coral-xyz/anchor';
-import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddress, createAssociatedTokenAccountInstruction } from '@solana/spl-token';
+import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddress } from '@solana/spl-token';
 import * as multisig from '@sqds/multisig';
 import bs58 from 'bs58';
 import { ethers, Contract, BigNumber } from 'ethers';
@@ -141,7 +141,7 @@ class DepositClient {
       true,
       TOKEN_2022_PROGRAM_ID
     );
-    const ix = await this.program.methods.requestWithdraw(new BN(amount.toString())).accounts({
+    return await this.program.methods.requestWithdraw(new BN(amount.toString())).accounts({
       user,
       owner,
       global,
@@ -167,69 +167,6 @@ class DepositClient {
       rent: SYSVAR_RENT_PUBKEY,
       globalConfig
     }).instruction();
-    return new Transaction().add(ix);
-  }
-  async buildDepositIxForUser(amount, user) {
-    if (!user) {
-      throw new Error("buildDepositIxForUser: user is required");
-    }
-    if (!amount || amount <= BigInt(0)) {
-      throw new Error("buildDepositIxForUser: amount must be > 0");
-    }
-    const depositAuthority = this.pgs.deriveDepositAuthorityPda();
-    const liqsolMint = this.pgs.deriveLiqsolMintPda();
-    const liqsolMintAuthority = this.pgs.deriveLiqsolMintAuthorityPda();
-    const reservePool = this.pgs.deriveReservePoolPda();
-    const vault = this.pgs.deriveVaultPda();
-    const controllerState = this.pgs.deriveStakeControllerStatePda();
-    const payoutState = this.pgs.derivePayoutStatePda();
-    const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
-    const payRateHistory = this.pgs.derivePayRateHistoryPda();
-    const globalConfig = this.pgs.deriveGlobalConfigPda();
-    const userAta = getAssociatedTokenAddressSync(
-      liqsolMint,
-      user,
-      true,
-      TOKEN_2022_PROGRAM_ID
-    );
-    const distributionState = this.pgs.deriveDistributionStatePda();
-    const userRecord = this.pgs.deriveUserRecordPda(userAta);
-    const bucketTokenAccount = getAssociatedTokenAddressSync(
-      liqsolMint,
-      bucketAuthority,
-      true,
-      TOKEN_2022_PROGRAM_ID
-    );
-    const seed = Math.floor(Math.random() * 2 ** 32);
-    const ephemeralStake = await this.pgs.deriveEphemeralStakeAddress(user, seed);
-    const ix = await this.program.methods.deposit(new BN(amount.toString()), seed).accounts({
-      user,
-      depositAuthority,
-      systemProgram: SystemProgram.programId,
-      tokenProgram: TOKEN_2022_PROGRAM_ID,
-      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-      liqsolProgram: this.pgs.PROGRAM_IDS.LIQSOL_TOKEN,
-      stakeProgram: StakeProgram.programId,
-      liqsolMint,
-      userAta,
-      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,
-      globalConfig
-    }).instruction();
-    return { ix, seed, userAta, ephemeralStake };
   }
 }
 
@@ -14659,13 +14596,15 @@ const MAINNET_PROGRAM_IDS = {
   LIQSOL_CORE: new PublicKey(liqsolCoreMainnetJson.address),
   LIQSOL_TOKEN: new PublicKey(liqsolTokenMainnetJson.address),
   VALIDATOR_LEADERBOARD: new PublicKey(validatorLeaderboardMainnetJson.address),
-  TRANSFER_HOOK: new PublicKey(mainnetTransferHookIDL.address)
+  TRANSFER_HOOK: new PublicKey(mainnetTransferHookIDL.address),
+  ALT_LOOKUP_TABLE: new PublicKey("AQXTHwkdNBEiXeQuVA5uCoxvzgYUmudRxthQY4vWKCPS")
 };
 const DEVNET_PROGRAM_IDS = {
   LIQSOL_CORE: new PublicKey(liqsolCoreDevnetJson.address),
   LIQSOL_TOKEN: new PublicKey(liqsolTokenDevnetJson.address),
   VALIDATOR_LEADERBOARD: new PublicKey(validatorLeaderboardDevnetJson.address),
-  TRANSFER_HOOK: new PublicKey(devnetTransferHookIDL.address)
+  TRANSFER_HOOK: new PublicKey(devnetTransferHookIDL.address),
+  ALT_LOOKUP_TABLE: new PublicKey("3MbupRDxUqPtJzoLLmjEYV3dXJdh1jojQrpDEQUqv7xb")
 };
 const PROGRAM_IDS_BY_CHAIN = {
   [SolChainID.Mainnet]: MAINNET_PROGRAM_IDS,
@@ -14887,7 +14826,7 @@ async function buildOutpostAccounts(connection, user, pgs) {
   const userAta = await getAssociatedTokenAddress(
     liqsolMint,
     user,
-    false,
+    true,
     TOKEN_2022_PROGRAM_ID
   );
   const bucketUserRecord = pgs.deriveUserRecordPda(bucketTokenAccount);
@@ -15269,14 +15208,13 @@ class OutpostClient {
       throw err;
     }
   }
-  async buildStakeIx(amountLamports, user) {
-    const userPk = user ?? this.wallet.publicKey;
-    if (!userPk) {
+  async buildStakeIx(amountLamports, user = this.wallet.publicKey) {
+    if (!user) {
       throw new Error("OutpostClient.buildStakeIx: wallet not connected");
     }
-    const a = await this.buildAccounts(userPk);
+    const a = await this.buildAccounts(user);
     return this.program.methods.synd(new BN(amountLamports.toString())).accounts({
-      user: userPk,
+      user,
       liqsolMint: a.liqsolMint,
       globalState: a.globalState,
       distributionState: a.distributionState,
@@ -15393,6 +15331,7 @@ class TokenClient {
     );
   }
   async buildPurchaseIx(amountLamports, user = this.wallet.publicKey) {
+    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;
@@ -15812,71 +15751,13 @@ const _SolanaStakingClient = class _SolanaStakingClient {
     const config = this.config.extras?.squadsX;
     return config ?? null;
   }
-  async createVaultLiqsolAtaOneShot(params) {
-    const { connection, payer, vaultPda } = params;
-    const liqsolMint = this.program.deriveLiqsolMintPda();
-    const vaultAta = getAssociatedTokenAddressSync(
-      liqsolMint,
-      vaultPda,
-      true,
-      TOKEN_2022_PROGRAM_ID,
-      ASSOCIATED_TOKEN_PROGRAM_ID
-    );
-    const info = await connection.getAccountInfo(vaultAta, "confirmed");
-    if (info) return null;
-    const ix = createAssociatedTokenAccountInstruction(
-      payer,
-      vaultAta,
-      vaultPda,
-      liqsolMint,
-      TOKEN_2022_PROGRAM_ID,
-      ASSOCIATED_TOKEN_PROGRAM_ID
-    );
-    const tx = new Transaction().add(ix);
-    return { tx, vaultAta };
-  }
-  async prepSquadsIxs(ix) {
-    if (!this.squadsX) throw new Error("Attempting to wrap Squads instruction without SquadsX config");
-    const multisigPda = this.squadsMultisigPDA;
-    const vaultPda = this.squadsVaultPDA;
-    const vaultIndex = this.squadsX?.vaultIndex ?? 0;
-    const creator = this.solPubKey;
-    const ms = await multisig.accounts.Multisig.fromAccountAddress(this.connection, multisigPda);
-    const current = BigInt(ms.transactionIndex?.toString() ?? 0);
-    const transactionIndex = current + BigInt(1);
-    const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
-    const transactionMessage = new TransactionMessage({
-      payerKey: vaultPda,
-      recentBlockhash: blockhash,
-      instructions: [ix]
-    });
-    const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
-      multisigPda,
-      transactionIndex,
-      creator,
-      vaultIndex,
-      transactionMessage,
-      ephemeralSigners: 0
-    });
-    const createProposalIx = await multisig.instructions.proposalCreate({
-      multisigPda,
-      transactionIndex,
-      creator
-    });
-    return [createVaultTxIx, createProposalIx];
-  }
   async deposit(amountLamports) {
     this.ensureUser();
-    if (amountLamports <= BigInt(0)) {
+    if (amountLamports <= BigInt(0))
       throw new Error("Deposit amount must be greater than zero.");
-    }
     try {
-      const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
-      const ix = await this.depositClient.buildDepositTx(amountLamports);
-      const tx = new Transaction().add(ix);
-      const prepared = await this.prepareTx(tx);
-      const signed = await this.signTransaction(prepared.tx);
-      return this.sendAndConfirmHttp(signed, prepared);
+      const ix = await this.depositClient.buildDepositTx(amountLamports, this.squadsVaultPDA);
+      return !!this.squadsX ? await this.sendSquadsIxs(ix) : await this.buildAndSendIx(ix);
     } catch (err) {
       console.log(`Failed to deposit Solana: ${err}`);
       throw err;
@@ -15884,16 +15765,11 @@ const _SolanaStakingClient = class _SolanaStakingClient {
   }
   async withdraw(amountLamports) {
     this.ensureUser();
-    if (amountLamports <= BigInt(0)) {
+    if (amountLamports <= BigInt(0))
       throw new Error("Withdraw amount must be greater than zero.");
-    }
     try {
-      const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
-      const ix = await this.depositClient.buildWithdrawTx(amountLamports);
-      const tx = new Transaction().add(cuIx, ix);
-      const prepared = await this.prepareTx(tx);
-      const signed = await this.signTransaction(prepared.tx);
-      return this.sendAndConfirmHttp(signed, prepared);
+      const ix = await this.depositClient.buildWithdrawTx(amountLamports, this.squadsVaultPDA);
+      return !!this.squadsX ? await this.sendSquadsIxs(ix) : await this.buildAndSendIx(ix);
     } catch (err) {
       console.log(`Failed to withdraw Solana: ${err}`);
       throw err;
@@ -15901,17 +15777,11 @@ const _SolanaStakingClient = class _SolanaStakingClient {
   }
   async stake(amountLamports) {
     this.ensureUser();
-    if (!amountLamports || amountLamports <= BigInt(0)) {
+    if (!amountLamports || amountLamports <= BigInt(0))
       throw new Error("Stake amount must be greater than zero.");
-    }
     try {
-      const user = this.solPubKey;
-      const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
-      const ix = await this.outpostClient.buildStakeIx(amountLamports, user);
-      const tx = new Transaction().add(cuIx, ix);
-      const prepared = await this.prepareTx(tx);
-      const signed = await this.signTransaction(prepared.tx);
-      return this.sendAndConfirmHttp(signed, prepared);
+      const ix = await this.outpostClient.buildStakeIx(amountLamports, this.squadsVaultPDA);
+      return !!this.squadsX ? await this.sendSquadsIxs(ix) : await this.buildAndSendIx(ix);
     } catch (err) {
       console.log(`Failed to stake Solana: ${err}`);
       throw err;
@@ -15919,17 +15789,11 @@ const _SolanaStakingClient = class _SolanaStakingClient {
   }
   async unstake(amountLamports) {
     this.ensureUser();
-    if (!amountLamports || amountLamports <= BigInt(0)) {
+    if (!amountLamports || amountLamports <= BigInt(0))
       throw new Error("Unstake amount must be greater than zero.");
-    }
     try {
-      const user = this.solPubKey;
-      const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
-      const ix = await this.outpostClient.buildUnstakeIx(amountLamports, user);
-      const tx = new Transaction().add(cuIx, ix);
-      const prepared = await this.prepareTx(tx);
-      const signed = await this.signTransaction(prepared.tx);
-      return this.sendAndConfirmHttp(signed, prepared);
+      const ix = await this.outpostClient.buildUnstakeIx(amountLamports, this.squadsVaultPDA);
+      return !!this.squadsX ? await this.sendSquadsIxs(ix) : await this.buildAndSendIx(ix);
     } catch (err) {
       console.log(`Failed to unstake Solana: ${err}`);
       throw err;
@@ -15937,24 +15801,17 @@ const _SolanaStakingClient = class _SolanaStakingClient {
   }
   async buy(amountLamports) {
     this.ensureUser();
-    if (!amountLamports || amountLamports <= BigInt(0)) {
+    if (!amountLamports || amountLamports <= BigInt(0))
       throw new Error("liqSOL pretoken purchase requires a positive amount.");
-    }
     try {
-      const user = this.solPubKey;
-      const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
-      const ix = await this.tokenClient.buildPurchaseIx(amountLamports, user);
-      const tx = new Transaction().add(cuIx, ix);
-      const prepared = await this.prepareTx(tx);
-      const signed = await this.signTransaction(prepared.tx);
-      return this.sendAndConfirmHttp(signed, prepared);
+      const ix = await this.tokenClient.buildPurchaseIx(amountLamports, this.squadsVaultPDA);
+      return !!this.squadsX ? await this.sendSquadsIxs(ix) : await this.buildAndSendIx(ix);
     } catch (err) {
       console.log(`Failed to buy liqSOL pretokens: ${err}`);
       throw err;
     }
   }
   async getPortfolio() {
-    if (!this.pubKey) throw new Error("User pubKey is undefined");
     try {
       const user = !!this.squadsX ? this.squadsVaultPDA : this.solPubKey;
       const reservePoolPDA = this.program.deriveReservePoolPda();
@@ -16046,16 +15903,115 @@ const _SolanaStakingClient = class _SolanaStakingClient {
     return this.distributionClient.getUserRecord(this.solPubKey);
   }
   get squadsMultisigPDA() {
-    if (!this.squadsX) return null;
+    if (!this.squadsX) return void 0;
     return new PublicKey(this.squadsX.multisigPDA);
   }
   get squadsVaultPDA() {
-    if (!this.squadsX || !this.squadsMultisigPDA) return null;
+    if (!this.squadsX || !this.squadsMultisigPDA) return void 0;
     const multisigPda = this.squadsMultisigPDA;
     const index = this.squadsX.vaultIndex ?? 0;
     const pda = multisig.getVaultPda({ multisigPda, index });
     return pda[0];
   }
+  async sendSquadsIxs(ix) {
+    if (!this.squadsX) throw new Error("Attempting to wrap Squads instruction without SquadsX config");
+    const multisigPda = this.squadsMultisigPDA;
+    const vaultPda = this.squadsVaultPDA;
+    const vaultIndex = this.squadsX?.vaultIndex ?? 0;
+    const creator = this.solPubKey;
+    const ms = await multisig.accounts.Multisig.fromAccountAddress(this.connection, multisigPda);
+    const current = BigInt(ms.transactionIndex?.toString() ?? 0);
+    const transactionIndex = current + BigInt(1);
+    const altAddress = this.program.PROGRAM_IDS.ALT_LOOKUP_TABLE;
+    const altAccount = await this.connection.getAddressLookupTable(altAddress);
+    if (!altAccount.value) throw new Error("ALT not found on-chain or not yet active.");
+    const lookupTable = altAccount.value;
+    const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
+    const computePriceIx = ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 2e3 });
+    const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+    const transactionMessage = new TransactionMessage({
+      payerKey: vaultPda,
+      recentBlockhash: blockhash,
+      instructions: [computeLimitIx, computePriceIx, ix]
+    });
+    const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
+      multisigPda,
+      transactionIndex,
+      creator,
+      vaultIndex,
+      transactionMessage,
+      ephemeralSigners: 0,
+      addressLookupTableAccounts: [lookupTable]
+    });
+    const vaultTransactionCreate = await this.buildAndSendIx(createVaultTxIx);
+    console.log("SQUADSX: vaultTransactionCreate", vaultTransactionCreate);
+    const createProposalIx = await multisig.instructions.proposalCreate({
+      multisigPda,
+      transactionIndex,
+      creator
+    });
+    const proposalCreate = await this.buildAndSendIx(createProposalIx);
+    console.log("SQUADSX: proposalCreate", proposalCreate);
+    return proposalCreate;
+  }
+  async buildAndSendIx(ix) {
+    const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
+    const ixs = Array.isArray(ix) ? ix : [ix];
+    const tx = new Transaction().add(cuIx, ...ixs);
+    const prepared = await this.prepareTx(tx);
+    const signed = await this.signTransaction(prepared.tx);
+    return this.sendAndConfirmHttp(signed, prepared);
+  }
+  async sendAndConfirmHttp(signed, _ctx) {
+    this.ensureUser();
+    const rawTx = signed.serialize();
+    try {
+      const signature = await this.connection.sendRawTransaction(rawTx, {
+        skipPreflight: false,
+        preflightCommitment: commitment,
+        maxRetries: 3
+      });
+      return signature;
+    } catch (e) {
+      const msg = e?.message ?? "";
+      const isSendTxError = e instanceof SendTransactionError || e?.name === "SendTransactionError";
+      if (isSendTxError && msg.includes("already been processed")) {
+        console.warn(
+          'sendRawTransaction reports "already been processed"; treating as success without further confirmation.'
+        );
+        const legacy = signed;
+        const first = legacy.signatures?.[0]?.signature;
+        if (first) {
+          return bs58.encode(first);
+        }
+        return "already-processed";
+      }
+      throw e;
+    }
+  }
+  async signTransaction(tx) {
+    this.ensureUser();
+    return this.anchor.wallet.signTransaction(tx);
+  }
+  async sendTransaction(signed) {
+    this.ensureUser();
+    return this.anchor.sendAndConfirm(signed);
+  }
+  async prepareTx(tx) {
+    const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash("confirmed");
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = this.feePayer;
+    return { tx, blockhash, lastValidBlockHeight };
+  }
+  ensureUser() {
+    if (!this.pubKey) throw new Error("User pubKey is undefined");
+    const wallet = this.anchor?.wallet;
+    const pk = wallet?.publicKey;
+    if (!pk) throw new Error("Wallet not connected");
+    if (typeof wallet.signTransaction !== "function") {
+      throw new Error("Wallet does not support signTransaction");
+    }
+  }
   async getTrancheSnapshot(chainID) {
     try {
       const [globalState, trancheState] = await Promise.all([
@@ -16097,10 +16053,24 @@ const _SolanaStakingClient = class _SolanaStakingClient {
       return Number(DEFAULT_AVERAGE_PAY_RATE) / Number(PAY_RATE_SCALE_FACTOR);
     }
     const currentIndex = Number(payRateHistory.currentIndex);
-    const latestIdx = (currentIndex - 1 + maxEntries) % maxEntries;
-    const latestEntry = payRateHistory.entries[latestIdx];
-    const raw = BigInt(latestEntry.scaledRate.toString());
-    return Number(raw) / Number(PAY_RATE_SCALE_FACTOR);
+    const processedCount = Math.min(totalEntriesAdded, maxEntries);
+    let sum = BigInt(0);
+    let validCount = 0;
+    let idx = (currentIndex - 1 + maxEntries) % maxEntries;
+    for (let i = 0; i < processedCount; i++) {
+      const entry = payRateHistory.entries[idx];
+      const scaledRate = BigInt(entry.scaledRate.toString());
+      if (scaledRate > BigInt(0)) {
+        sum += scaledRate;
+        validCount++;
+      }
+      idx = (idx - 1 + maxEntries) % maxEntries;
+    }
+    if (validCount === 0) {
+      return Number(DEFAULT_AVERAGE_PAY_RATE) / Number(PAY_RATE_SCALE_FACTOR);
+    }
+    const average = Number(sum / BigInt(validCount));
+    return average / Number(PAY_RATE_SCALE_FACTOR);
   }
   async getEpochsPerYearFromCluster() {
     const now = Date.now();
@@ -16235,56 +16205,6 @@ const _SolanaStakingClient = class _SolanaStakingClient {
     };
     return singleTxFeeLamports;
   }
-  async sendAndConfirmHttp(signed, _ctx) {
-    this.ensureUser();
-    const rawTx = signed.serialize();
-    try {
-      const signature = await this.connection.sendRawTransaction(rawTx, {
-        skipPreflight: false,
-        preflightCommitment: commitment,
-        maxRetries: 3
-      });
-      return signature;
-    } catch (e) {
-      const msg = e?.message ?? "";
-      const isSendTxError = e instanceof SendTransactionError || e?.name === "SendTransactionError";
-      if (isSendTxError && msg.includes("already been processed")) {
-        console.warn(
-          'sendRawTransaction reports "already been processed"; treating as success without further confirmation.'
-        );
-        const legacy = signed;
-        const first = legacy.signatures?.[0]?.signature;
-        if (first) {
-          return bs58.encode(first);
-        }
-        return "already-processed";
-      }
-      throw e;
-    }
-  }
-  async signTransaction(tx) {
-    this.ensureUser();
-    return this.anchor.wallet.signTransaction(tx);
-  }
-  async sendTransaction(signed) {
-    this.ensureUser();
-    return this.anchor.sendAndConfirm(signed);
-  }
-  async prepareTx(tx) {
-    const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash("confirmed");
-    tx.recentBlockhash = blockhash;
-    tx.feePayer = this.feePayer;
-    return { tx, blockhash, lastValidBlockHeight };
-  }
-  ensureUser() {
-    if (!this.pubKey) throw new Error("User pubKey is undefined");
-    const wallet = this.anchor?.wallet;
-    const pk = wallet?.publicKey;
-    if (!pk) throw new Error("Wallet not connected");
-    if (typeof wallet.signTransaction !== "function") {
-      throw new Error("Wallet does not support signTransaction");
-    }
-  }
 };
 _SolanaStakingClient.EPOCHS_PER_YEAR_TTL_MS = 10 * 60 * 1e3;
 _SolanaStakingClient.FEE_CACHE_TTL_MS = 6e4;
@@ -41446,6 +41366,41 @@ class ReceiptClient {
   }
 }
 
+class ValidatorClient {
+  get contract() {
+    return this.contractService.contract;
+  }
+  constructor(contract) {
+    this.contractService = contract;
+  }
+  async validatorDepositAndLockBond() {
+    const amountWei = ethers.utils.parseEther("32");
+    try {
+      await this.contract.DepositManager.callStatic.validatorDepositAndLockBond({ value: amountWei });
+    } catch (err) {
+      let errorObj = formatContractErrors(err);
+      throw new Error(errorObj.name ?? errorObj.raw);
+    }
+    const tx = await this.contract.DepositManager.validatorDepositAndLockBond({ value: amountWei });
+    const receipt = await tx.wait(1);
+    let staked;
+    const ev = receipt.events?.find((e) => e.event === "Staked");
+    if (ev && ev.args) {
+      const { sender, amount, shares } = ev.args;
+      staked = {
+        sender,
+        amount: BigNumber.from(amount),
+        shares: BigNumber.from(shares)
+      };
+    }
+    return {
+      txHash: tx.hash,
+      receipt,
+      staked
+    };
+  }
+}
+
 const INITIAL_TRANCHE_SUPPLY = 35e3;
 class EthereumStakingClient {
   constructor(config) {
@@ -41468,6 +41423,7 @@ class EthereumStakingClient {
       this.stakeClient = new StakeClient(this.contractService);
       this.oppClient = new OPPClient(this.contractService);
       this.receiptClient = new ReceiptClient(this.contractService);
+      this.validatorClient = new ValidatorClient(this.contractService);
     } catch (error) {
       throw error;
     }
@@ -41524,6 +41480,11 @@ class EthereumStakingClient {
     let result = await this.pretokenClient.purchasePretokensWithLiqETH(amount, buyer);
     return result && result.txHash ? result.txHash : "Error - no resulting txHash";
   }
+  async validatorDeposit() {
+    this.ensureUser();
+    let result = await this.validatorClient.validatorDepositAndLockBond();
+    return result && result.txHash ? result.txHash : "Error - no resulting txHash";
+  }
   async getPortfolio() {
     try {
       if (!this.signer) return Promise.resolve(null);