@wireio/stake 0.9.0 → 0.9.2

package/lib/stake.browser.js

@@ -1,7 +1,8 @@
 import { PublicKey as PublicKey$1, KeyType, SolChainID, EvmChainID } from '@wireio/core';
-import { PublicKey, StakeProgram, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_CLOCK_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, SYSVAR_RENT_PUBKEY, Transaction, Keypair, Connection, ComputeBudgetProgram } from '@solana/web3.js';
+import { PublicKey, StakeProgram, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_CLOCK_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, SYSVAR_RENT_PUBKEY, TransactionMessage, Transaction, Keypair, Connection, ComputeBudgetProgram } from '@solana/web3.js';
 import { Program, BN, AnchorProvider } from '@coral-xyz/anchor';
-import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddress } from '@solana/spl-token';
+import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddress, createAssociatedTokenAccountInstruction } from '@solana/spl-token';
+import * as multisig from '@sqds/multisig';
 import { ethers, Contract, BigNumber } from 'ethers';
 
 var address$3 = "5nBtmutQLrRKBUxNfHJPDjiW5u8id6QM9Hhjg1D1g1XH";
@@ -7440,6 +7441,9 @@ class DepositClient {
     const svc = new SolanaProgramService(provider);
     this.program = svc.getProgram("liqsolCore");
   }
+  get connection() {
+    return this.provider.connection;
+  }
   get wallet() {
     return this.provider.wallet;
   }
@@ -7467,7 +7471,7 @@ class DepositClient {
     const userAta = getAssociatedTokenAddressSync(
       liqsolMint,
       user,
-      false,
+      true,
       TOKEN_2022_PROGRAM_ID
     );
     const distributionState = deriveDistributionStatePda();
@@ -7480,7 +7484,7 @@ class DepositClient {
     );
     const seed = Math.floor(Math.random() * 2 ** 32);
     const ephemeralStake = await deriveEphemeralStakeAddress(user, seed);
-    const ix = await this.program.methods.deposit(new BN(amount.toString()), seed).accounts({
+    return await this.program.methods.deposit(new BN(amount.toString()), seed).accounts({
       user,
       depositAuthority,
       systemProgram: SystemProgram.programId,
@@ -7507,7 +7511,58 @@ class DepositClient {
       rent: SYSVAR_RENT_PUBKEY,
       globalConfig
     }).instruction();
-    return new Transaction().add(ix);
+  }
+  async buildSquadsDepositProposalTx(params) {
+    const { connection, multisigPda, amountLamports, wallet } = params;
+    const vaultIndex = params.vaultIndex ?? 0;
+    if (!wallet?.publicKey) throw new Error("wallet.publicKey missing");
+    if (!amountLamports || amountLamports <= BigInt(0)) throw new Error("amountLamports must be > 0");
+    const [vaultPda] = multisig.getVaultPda({ multisigPda, index: vaultIndex });
+    const depositBuilt = await this.buildDepositIxForUser(amountLamports, vaultPda);
+    const ms = await multisig.accounts.Multisig.fromAccountAddress(connection, multisigPda);
+    const current = BigInt(ms.transactionIndex?.toString?.() ?? 0);
+    const transactionIndex = current + BigInt(1);
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    const message = new TransactionMessage({
+      payerKey: vaultPda,
+      recentBlockhash: blockhash,
+      instructions: [depositBuilt.ix]
+    });
+    const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
+      multisigPda,
+      transactionIndex,
+      creator: wallet.publicKey,
+      vaultIndex,
+      ephemeralSigners: 0,
+      transactionMessage: message
+    });
+    console.log("createVaultTxIx", createVaultTxIx);
+    const tx = new Transaction().add(createVaultTxIx);
+    return { tx, transactionIndex, vaultPda };
+  }
+  async buildSquadsDepositProposalTx2(params) {
+    const { connection, multisigPda, amountLamports, wallet } = params;
+    const vaultIndex = params.vaultIndex ?? 0;
+    if (!wallet?.publicKey) throw new Error("wallet.publicKey missing");
+    if (!amountLamports || amountLamports <= BigInt(0)) throw new Error("amountLamports must be > 0");
+    const [vaultPda] = multisig.getVaultPda({ multisigPda, index: vaultIndex });
+    const depositBuilt = await this.buildDepositIxForUser(amountLamports, vaultPda);
+    const ms = await multisig.accounts.Multisig.fromAccountAddress(connection, multisigPda);
+    const current = BigInt(ms.transactionIndex?.toString?.() ?? 0);
+    const transactionIndex = current + BigInt(1);
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    new TransactionMessage({
+      payerKey: vaultPda,
+      recentBlockhash: blockhash,
+      instructions: [depositBuilt.ix]
+    });
+    const createProposalIx = await multisig.instructions.proposalCreate({
+      multisigPda,
+      transactionIndex,
+      creator: wallet.publicKey
+    });
+    const tx = new Transaction().add(createProposalIx);
+    return { tx, transactionIndex, vaultPda };
   }
   async buildWithdrawTx(amount, user = this.wallet.publicKey) {
     if (!user) {
@@ -7524,7 +7579,7 @@ class DepositClient {
     const userAta = getAssociatedTokenAddressSync(
       liqsolMint,
       user,
-      false,
+      true,
       TOKEN_2022_PROGRAM_ID
     );
     const userRecord = deriveUserRecordPda(userAta);
@@ -7557,7 +7612,7 @@ class DepositClient {
     const nftAta = getAssociatedTokenAddressSync(
       nftMint,
       owner,
-      false,
+      true,
       TOKEN_2022_PROGRAM_ID
     );
     const bucketAuthority = deriveBucketAuthorityPda();
@@ -7595,6 +7650,68 @@ class DepositClient {
     }).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 = 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 globalConfig = deriveGlobalConfigPda();
+    const userAta = getAssociatedTokenAddressSync(
+      liqsolMint,
+      user,
+      true,
+      TOKEN_2022_PROGRAM_ID
+    );
+    const distributionState = deriveDistributionStatePda();
+    const userRecord = deriveUserRecordPda(userAta);
+    const bucketTokenAccount = getAssociatedTokenAddressSync(
+      liqsolMint,
+      bucketAuthority,
+      true,
+      TOKEN_2022_PROGRAM_ID
+    );
+    const seed = Math.floor(Math.random() * 2 ** 32);
+    const ephemeralStake = await 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: 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 };
+  }
 }
 
 const INDEX_SCALE = BigInt(1e12);
@@ -8083,7 +8200,7 @@ class DistributionClient {
       const ata = getAssociatedTokenAddressSync(
         liqsolMint,
         ownerOrAta,
-        false,
+        true,
         TOKEN_2022_PROGRAM_ID
       );
       const pdaFromWallet = deriveUserRecordPda(ata);
@@ -8362,7 +8479,7 @@ class OutpostClient {
     };
   }
   static tokensToShares(amount, currentIndex) {
-    const numerator = amount.mul(INDEX_SCALE$1);
+    const numerator = amount.mul(new BN(INDEX_SCALE$1));
     const shares = numerator.div(currentIndex);
     const remainder = numerator.mod(currentIndex);
     return remainder.eqn(0) ? shares : shares.addn(1);
@@ -8561,6 +8678,69 @@ const _SolanaStakingClient = class _SolanaStakingClient {
   get network() {
     return this.config.network;
   }
+  get feePayer() {
+    if (this.signer) return this.signer;
+    if (this.anchor.wallet.publicKey) return this.anchor.wallet.publicKey;
+    throw new Error("No signing authority available");
+  }
+  get squadsX() {
+    const config = this.config.extras?.squadsX;
+    return config ?? null;
+  }
+  async createVaultLiqsolAtaOneShot(params) {
+    const { connection, payer, vaultPda } = params;
+    const liqsolMint = deriveLiqsolMintPda();
+    const vaultAta = getAssociatedTokenAddressSync(
+      liqsolMint,
+      vaultPda,
+      true,
+      TOKEN_2022_PROGRAM_ID,
+      ASSOCIATED_TOKEN_PROGRAM_ID
+    );
+    const info = await connection.getAccountInfo(vaultAta, "confirmed");
+    console.log("info?", info);
+    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)) {
@@ -8568,11 +8748,40 @@ const _SolanaStakingClient = class _SolanaStakingClient {
     }
     try {
       const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
-      const ix = await this.depositClient.buildDepositTx(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);
+      if (!!this.squadsX) {
+        const createVaultTx = await this.createVaultLiqsolAtaOneShot({
+          connection: this.connection,
+          payer: this.solPubKey,
+          vaultPda: this.squadsVaultPDA
+        });
+        if (createVaultTx !== null) {
+          console.log("need to create vault ata first...");
+          const tx0 = new Transaction().add(createVaultTx.tx);
+          const prepared0 = await this.prepareTx(tx0);
+          const signed0 = await this.signTransaction(prepared0.tx);
+          const sent0 = await this.sendAndConfirmHttp(signed0, prepared0);
+          console.log("create Vault ATA", sent0);
+        }
+        const ix = await this.depositClient.buildDepositTx(amountLamports, this.squadsVaultPDA);
+        const squadIxs = await this.prepSquadsIxs(ix);
+        const tx1 = new Transaction().add(cuIx, squadIxs[0]);
+        const prepared1 = await this.prepareTx(tx1);
+        const signed1 = await this.signTransaction(prepared1.tx);
+        const sent1 = await this.sendAndConfirmHttp(signed1, prepared1);
+        console.log("SENT 1", sent1);
+        const tx2 = new Transaction().add(cuIx, squadIxs[1]);
+        const prepared2 = await this.prepareTx(tx2);
+        const signed2 = await this.signTransaction(prepared2.tx);
+        const sent2 = await this.sendAndConfirmHttp(signed2, prepared2);
+        console.log("SENT 2", sent2);
+        return sent2;
+      } else {
+        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);
+      }
     } catch (err) {
       throw new Error(`Failed to deposit Solana: ${err}`);
     }
@@ -8647,14 +8856,15 @@ const _SolanaStakingClient = class _SolanaStakingClient {
   async getPortfolio() {
     if (!this.pubKey) throw new Error("User pubKey is undefined");
     try {
-      const user = this.solPubKey;
+      const user = !!this.squadsX ? this.squadsVaultPDA : this.solPubKey;
+      console.log("get portfolio for user", user.toBase58());
       const reservePoolPDA = deriveReservePoolPda();
       const vaultPDA = deriveVaultPda();
       const liqsolMint = deriveLiqsolMintPda();
       const userLiqsolAta = getAssociatedTokenAddressSync(
         liqsolMint,
         user,
-        false,
+        true,
         TOKEN_2022_PROGRAM_ID,
         ASSOCIATED_TOKEN_PROGRAM_ID
       );
@@ -8735,6 +8945,17 @@ const _SolanaStakingClient = class _SolanaStakingClient {
     if (!this.pubKey) throw new Error("User pubKey is undefined");
     return this.distributionClient.getUserRecord(this.solPubKey);
   }
+  get squadsMultisigPDA() {
+    if (!this.squadsX) return null;
+    return new PublicKey(this.squadsX.multisigPDA);
+  }
+  get squadsVaultPDA() {
+    if (!this.squadsX || !this.squadsMultisigPDA) return null;
+    const multisigPda = this.squadsMultisigPDA;
+    const index = this.squadsX.vaultIndex ?? 0;
+    const pda = multisig.getVaultPda({ multisigPda, index });
+    return pda[0];
+  }
   async getTrancheSnapshot(options) {
     try {
       const {
@@ -8841,8 +9062,7 @@ const _SolanaStakingClient = class _SolanaStakingClient {
   }
   async getDepositBuffer(options) {
     this.ensureUser();
-    const payer = this.solPubKey;
-    const balanceLamports = options?.balanceOverrideLamports ?? BigInt(await this.connection.getBalance(payer, commitment));
+    const balanceLamports = options?.balanceOverrideLamports ?? BigInt(await this.connection.getBalance(this.feePayer, commitment));
     if (balanceLamports <= BigInt(0)) {
       return BigInt(0);
     }
@@ -8898,7 +9118,7 @@ const _SolanaStakingClient = class _SolanaStakingClient {
     if (this.cachedTxFee && now - this.cachedTxFee.fetchedAt < _SolanaStakingClient.FEE_CACHE_TTL_MS) {
       return this.cachedTxFee.value;
     }
-    const payer = this.solPubKey;
+    const payer = this.feePayer;
     const dummyIx = SystemProgram.transfer({
       fromPubkey: payer,
       toPubkey: payer,
@@ -8953,17 +9173,16 @@ const _SolanaStakingClient = class _SolanaStakingClient {
   async prepareTx(tx) {
     const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash("confirmed");
     tx.recentBlockhash = blockhash;
-    tx.feePayer = this.solPubKey;
+    tx.feePayer = this.feePayer;
     return { tx, blockhash, lastValidBlockHeight };
   }
   ensureUser() {
-    if (!this.pubKey || !this.anchor.wallet.publicKey) {
-      throw new Error("User Authorization required: pubKey is undefined");
-    }
-    if (this.solPubKey.toBase58() !== this.anchor.wallet.publicKey.toBase58()) {
-      throw new Error(
-        "Write access requires connected wallet to match pubKey"
-      );
+    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");
     }
   }
 };
@@ -34902,6 +35121,30 @@ class ConvertClient {
       event
     };
   }
+  async claimWithdraw(tokenId) {
+    let tx, receipt;
+    try {
+      tx = await this.contract.DepositManager.claim(tokenId);
+      receipt = await tx.wait(1);
+    } catch (err) {
+      let errorObj = formatContractErrors(err);
+      throw new Error(errorObj.name ?? errorObj.raw);
+    }
+    let event;
+    const ev = receipt.events?.find((e) => e.event === "Claimed");
+    if (ev && ev.args) {
+      const { sender, ethAmount } = ev.args;
+      event = {
+        sender,
+        ethAmount: BigNumber.from(ethAmount)
+      };
+    }
+    return {
+      txHash: tx.hash,
+      receipt,
+      event
+    };
+  }
 }
 
 class StakeClient {
@@ -34922,12 +35165,13 @@ class StakeClient {
   async performStake(amountWei, signerAddress) {
     const depositor = this.contract.Depositor.address;
     const liqRead = this.contract.LiqEthToken;
-    await liqRead.balanceOf(signerAddress);
+    const bal = await liqRead.balanceOf(signerAddress);
     const allowance = await liqRead.allowance(signerAddress, depositor);
     const paused = await this.contract.Depositor.paused();
     if (paused) {
       throw new Error("Error - Depositor is in a paused state");
     }
+    if (bal.lt(amountWei)) throw new Error("Insufficient LiqETH balance");
     if (allowance.lt(amountWei)) {
       const liqWrite = this.contractService.getWrite("LiqEthToken");
       console.warn(`allowance insufficient (${allowance.toString()} < ${amountWei.toString()}); sending approve(${depositor}, ${amountWei.toString()})`);
@@ -35372,7 +35616,7 @@ class ReceiptClient {
   }
   async fetchPreLaunchReceipts(address, type) {
     const receiptContract = this.contract.ReceiptNFT;
-    const tokenIds = await this.getOwnedTokenIdsFor(address);
+    const tokenIds = await this.getOwnedReceiptNFTsFor(address);
     const results = [];
     for (const idBN of tokenIds) {
       try {
@@ -35405,7 +35649,7 @@ class ReceiptClient {
     }
     return results;
   }
-  async getOwnedTokenIdsFor(owner, fromBlock = 0, toBlock = "latest") {
+  async getOwnedReceiptNFTsFor(owner, fromBlock = 0, toBlock = "latest") {
     const receiptContract = this.contract.ReceiptNFT;
     const toLogs = await receiptContract.queryFilter(
       receiptContract.filters.Transfer(null, owner),
@@ -35430,6 +35674,56 @@ class ReceiptClient {
     }
     return Array.from(owned).map((id) => BigNumber.from(id));
   }
+  async fetchWithdrawReceipts(address) {
+    const tokenIds = await this.getOwnedWithdrawReceiptsFor(address);
+    const results = [];
+    for (const idBN of tokenIds) {
+      try {
+        const receiptData = await this.contract.WithdrawalQueue.info(idBN);
+        results.push({
+          tokenId: idBN.toBigInt(),
+          receipt: {
+            ethAmount: receiptData.ethAmount,
+            ethBalance: {
+              amount: receiptData.ethAmount.toBigInt(),
+              decimals: 18,
+              symbol: "ETH"
+            },
+            readyAt: new Date(Number(receiptData.readyAt.toString()) * 1e3).valueOf()
+          }
+        });
+      } catch (err) {
+        console.warn(`Failed to load receipt for tokenId=${idBN.toString()}`, err);
+        continue;
+      }
+    }
+    return results;
+  }
+  async getOwnedWithdrawReceiptsFor(owner, fromBlock = 0, toBlock = "latest") {
+    const contract = this.contract.WithdrawalQueue;
+    const toLogs = await contract.queryFilter(
+      contract.filters.Transfer(null, owner),
+      fromBlock,
+      toBlock
+    );
+    const fromLogs = await contract.queryFilter(
+      contract.filters.Transfer(owner, null),
+      fromBlock,
+      toBlock
+    );
+    const owned =  new Set();
+    for (const e of toLogs) {
+      const tokenId = e.args?.tokenId;
+      if (!tokenId) continue;
+      owned.add(tokenId.toString());
+    }
+    for (const e of fromLogs) {
+      const tokenId = e.args?.tokenId;
+      if (!tokenId) continue;
+      owned.delete(tokenId.toString());
+    }
+    return Array.from(owned).map((id) => BigNumber.from(id));
+  }
 }
 
 const INITIAL_TRANCHE_SUPPLY = 35e3;
@@ -35476,6 +35770,17 @@ class EthereumStakingClient {
     const result = await this.convertClient.performWithdraw(address, amountWei);
     return result.txHash;
   }
+  async loadPendingWithdraws() {
+    this.ensureUser();
+    const address = await this.signer.getAddress();
+    return await this.receiptClient.fetchWithdrawReceipts(address);
+  }
+  async claimWithdraw(tokenId) {
+    this.ensureUser();
+    const tokenIdBigNum = BigNumber.from(tokenId);
+    const result = await this.convertClient.claimWithdraw(tokenIdBigNum);
+    return result.txHash;
+  }
   async stake(amount) {
     this.ensureUser();
     const walletAddress = await this.signer.getAddress();
@@ -35535,6 +35840,12 @@ class EthereumStakingClient {
       }
       let estimatedClaim = BigInt(0);
       let estimatedYield = BigInt(0);
+      if (userShares > BigInt(0) && currentIndex > BigInt(0)) {
+        estimatedClaim = userShares * currentIndex / indexScale;
+        if (estimatedClaim > stakeBalanceBN.toBigInt()) {
+          estimatedYield = estimatedClaim - stakeBalanceBN.toBigInt();
+        }
+      }
       const portfolio = {
         native: {
           amount: nativeBalance.toBigInt(),
@@ -35692,11 +36003,9 @@ class Staker {
     if (!Array.isArray(config)) config = [config];
     config.forEach((cfg) => {
       switch (cfg.network.chainId) {
-        case SolChainID.Mainnet:
         case SolChainID.Devnet:
           this.clients.set(cfg.network.chainId, new SolanaStakingClient(cfg));
           break;
-        case EvmChainID.Ethereum:
         case EvmChainID.Hoodi:
           this.clients.set(cfg.network.chainId, new EthereumStakingClient(cfg));
           break;