genlayer-js 0.18.4 → 0.18.6

package/dist/index.d.cts

@@ -1,11 +1,11 @@
 import * as viem from 'viem';
 import { Account, Address, Hex } from 'viem';
-import { G as GenLayerChain } from './chains-BIe_Q0mF.cjs';
-import { G as GenLayerClient, D as DecodedDeployData, a as DecodedCallData, b as GenLayerRawTransaction, c as GenLayerTransaction, C as CalldataEncodable, T as TransactionDataElement } from './index-BYma5s90.cjs';
+import { G as GenLayerChain } from './chains-B7B7UXdn.cjs';
+import { G as GenLayerClient, D as DecodedDeployData, a as DecodedCallData, b as GenLayerRawTransaction, c as GenLayerTransaction, C as CalldataEncodable, T as TransactionDataElement, S as STAKING_ABI, V as VALIDATOR_WALLET_ABI } from './index-3leEwFoq.cjs';
 import * as abitype from 'abitype';
 import * as viem__types_types_authorization from 'viem/_types/types/authorization';
 import * as viem_accounts from 'viem/accounts';
-export { i as chains } from './index-C5zeayBB.cjs';
+export { i as chains } from './index-BVDASTaU.cjs';
 
 interface ClientConfig {
     chain?: {
@@ -88,10 +88,22 @@ declare namespace tx {
 declare const calldata: typeof cd;
 declare const transactions: typeof tx;
 
+declare const index_STAKING_ABI: typeof STAKING_ABI;
+declare const index_VALIDATOR_WALLET_ABI: typeof VALIDATOR_WALLET_ABI;
 declare const index_calldata: typeof calldata;
 declare const index_transactions: typeof transactions;
 declare namespace index {
-  export { index_calldata as calldata, index_transactions as transactions };
+  export { index_STAKING_ABI as STAKING_ABI, index_VALIDATOR_WALLET_ABI as VALIDATOR_WALLET_ABI, index_calldata as calldata, index_transactions as transactions };
 }
 
-export { index as abi, createAccount, createClient, decodeInputData, decodeLocalnetTransaction, decodeTransaction, generatePrivateKey, simplifyTransactionReceipt };
+/**
+ * Parse staking amount. Use "gen" suffix for GEN tokens (e.g. "42gen"),
+ * otherwise value is treated as wei (e.g. "42000000000000000000" = 42 GEN).
+ */
+declare function parseStakingAmount(amount: string | bigint): bigint;
+/**
+ * Format bigint amount to human-readable GEN string.
+ */
+declare function formatStakingAmount(amount: bigint): string;
+
+export { index as abi, createAccount, createClient, decodeInputData, decodeLocalnetTransaction, decodeTransaction, formatStakingAmount, generatePrivateKey, parseStakingAmount, simplifyTransactionReceipt };

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import * as viem from 'viem';
 import { Account, Address, Hex } from 'viem';
-import { G as GenLayerChain } from './chains-BIe_Q0mF.js';
-import { G as GenLayerClient, D as DecodedDeployData, a as DecodedCallData, b as GenLayerRawTransaction, c as GenLayerTransaction, C as CalldataEncodable, T as TransactionDataElement } from './index-B2AY6_eD.js';
+import { G as GenLayerChain } from './chains-B7B7UXdn.js';
+import { G as GenLayerClient, D as DecodedDeployData, a as DecodedCallData, b as GenLayerRawTransaction, c as GenLayerTransaction, C as CalldataEncodable, T as TransactionDataElement, S as STAKING_ABI, V as VALIDATOR_WALLET_ABI } from './index-BBh1NZjP.js';
 import * as abitype from 'abitype';
 import * as viem__types_types_authorization from 'viem/_types/types/authorization';
 import * as viem_accounts from 'viem/accounts';
-export { i as chains } from './index-BpFWfpio.js';
+export { i as chains } from './index-ucNO2REF.js';
 
 interface ClientConfig {
     chain?: {
@@ -88,10 +88,22 @@ declare namespace tx {
 declare const calldata: typeof cd;
 declare const transactions: typeof tx;
 
+declare const index_STAKING_ABI: typeof STAKING_ABI;
+declare const index_VALIDATOR_WALLET_ABI: typeof VALIDATOR_WALLET_ABI;
 declare const index_calldata: typeof calldata;
 declare const index_transactions: typeof transactions;
 declare namespace index {
-  export { index_calldata as calldata, index_transactions as transactions };
+  export { index_STAKING_ABI as STAKING_ABI, index_VALIDATOR_WALLET_ABI as VALIDATOR_WALLET_ABI, index_calldata as calldata, index_transactions as transactions };
 }
 
-export { index as abi, createAccount, createClient, decodeInputData, decodeLocalnetTransaction, decodeTransaction, generatePrivateKey, simplifyTransactionReceipt };
+/**
+ * Parse staking amount. Use "gen" suffix for GEN tokens (e.g. "42gen"),
+ * otherwise value is treated as wei (e.g. "42000000000000000000" = 42 GEN).
+ */
+declare function parseStakingAmount(amount: string | bigint): bigint;
+/**
+ * Format bigint amount to human-readable GEN string.
+ */
+declare function formatStakingAmount(amount: bigint): string;
+
+export { index as abi, createAccount, createClient, decodeInputData, decodeLocalnetTransaction, decodeTransaction, formatStakingAmount, generatePrivateKey, parseStakingAmount, simplifyTransactionReceipt };

package/dist/index.js

@@ -1,9 +1,11 @@
 import {
+  STAKING_ABI,
+  VALIDATOR_WALLET_ABI,
   chains_exports,
   localnet,
   studionet,
   testnetAsimov
-} from "./chunk-NO75TOQL.js";
+} from "./chunk-KVHGQTAI.js";
 import {
   CalldataAddress,
   isDecidedState,
@@ -11,7 +13,7 @@ import {
   transactionsStatusNameToNumber,
   transactionsStatusNumberToName,
   voteTypeNumberToName
-} from "./chunk-47QDX7IX.js";
+} from "./chunk-ZHBOSLFN.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -413,6 +415,8 @@ import { fromHex, toHex as toHex3, zeroAddress, encodeFunctionData, parseEventLo
 // src/abi/index.ts
 var abi_exports = {};
 __export(abi_exports, {
+  STAKING_ABI: () => STAKING_ABI,
+  VALIDATOR_WALLET_ABI: () => VALIDATOR_WALLET_ABI,
   calldata: () => calldata,
   transactions: () => transactions
 });
@@ -681,13 +685,13 @@ var contractActions = (client, publicClient) => {
     }
   };
 };
-var validateAccount = (Account3) => {
-  if (!Account3) {
+var validateAccount = (Account4) => {
+  if (!Account4) {
     throw new Error(
       "No account set. Configure the client with an account or pass an account to this function."
     );
   }
-  return Account3;
+  return Account4;
 };
 var _encodeAddTransactionData = ({
   client,
@@ -1212,6 +1216,509 @@ function walletActions(client) {
   };
 }
 
+// src/staking/actions.ts
+import { getContract, decodeEventLog, toHex as toHex4, encodeFunctionData as encodeFunctionData2, BaseError, ContractFunctionRevertedError } from "viem";
+
+// src/staking/utils.ts
+import { parseEther, formatEther } from "viem";
+function parseStakingAmount(amount) {
+  if (typeof amount === "bigint") return amount;
+  const trimmed = amount.trim();
+  const lower = trimmed.toLowerCase();
+  if (lower.endsWith("gen")) {
+    return parseEther(lower.slice(0, -3).trim());
+  }
+  return BigInt(trimmed);
+}
+function formatStakingAmount(amount) {
+  return `${formatEther(amount)} GEN`;
+}
+
+// src/staking/actions.ts
+var FALLBACK_GAS = 1000000n;
+var GAS_BUFFER_MULTIPLIER = 2n;
+function extractRevertReason(err) {
+  if (err instanceof BaseError) {
+    const revertError = err.walk((e) => e instanceof ContractFunctionRevertedError);
+    if (revertError instanceof ContractFunctionRevertedError) {
+      return revertError.data?.errorName || revertError.reason || "Unknown reason";
+    }
+    if (err.shortMessage) return err.shortMessage;
+  }
+  if (err instanceof Error) return err.message;
+  return "Unknown reason";
+}
+var stakingActions = (client, publicClient) => {
+  const executeWrite = async (options) => {
+    if (!client.account) {
+      throw new Error("Account is required for write operations. Initialize client with a wallet account.");
+    }
+    const account = client.account;
+    try {
+      await publicClient.call({
+        account,
+        to: options.to,
+        data: options.data,
+        value: options.value
+      });
+    } catch (err) {
+      const revertReason = extractRevertReason(err);
+      throw new Error(`Transaction would revert: ${revertReason}`);
+    }
+    let gasLimit = options.gas;
+    if (!gasLimit) {
+      try {
+        const estimated = await publicClient.estimateGas({
+          account,
+          to: options.to,
+          data: options.data,
+          value: options.value
+        });
+        gasLimit = estimated * GAS_BUFFER_MULTIPLIER;
+      } catch {
+        gasLimit = FALLBACK_GAS;
+      }
+    }
+    const nonce = await publicClient.getTransactionCount({ address: account.address });
+    const txRequest = await publicClient.prepareTransactionRequest({
+      account,
+      to: options.to,
+      data: options.data,
+      value: options.value,
+      type: "legacy",
+      nonce,
+      gas: gasLimit,
+      chain: client.chain
+    });
+    const signTransaction = account.signTransaction;
+    if (!signTransaction) {
+      throw new Error("Account does not support signing transactions");
+    }
+    const serializedTx = await signTransaction(txRequest);
+    const hash = await publicClient.sendRawTransaction({ serializedTransaction: serializedTx });
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      let revertReason = "Unknown reason";
+      try {
+        await publicClient.call({
+          account,
+          to: options.to,
+          data: options.data,
+          value: options.value,
+          blockNumber: receipt.blockNumber
+        });
+        const gasUsed = receipt.gasUsed;
+        if (gasUsed >= gasLimit - 1000n) {
+          revertReason = `Out of gas (used ${gasUsed}, limit ${gasLimit})`;
+        } else {
+          revertReason = `Unknown (simulation passes but tx reverts). Gas: ${gasUsed}/${gasLimit}`;
+        }
+      } catch (err) {
+        revertReason = extractRevertReason(err);
+      }
+      throw new Error(`Transaction reverted: ${revertReason} (tx: ${hash})`);
+    }
+    return {
+      transactionHash: receipt.transactionHash,
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.gasUsed
+    };
+  };
+  const getStakingAddress = () => {
+    const stakingConfig = client.chain.stakingContract;
+    if (!stakingConfig?.address || stakingConfig.address === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Staking is not supported on studio-based networks. Use testnet-asimov for staking operations.");
+    }
+    return stakingConfig.address;
+  };
+  const getStakingContract = () => {
+    const address = getStakingAddress();
+    return getContract({
+      address,
+      abi: STAKING_ABI,
+      client: { public: publicClient, wallet: client }
+    });
+  };
+  const getReadOnlyStakingContract = () => {
+    const address = getStakingAddress();
+    return getContract({
+      address,
+      abi: STAKING_ABI,
+      client: publicClient
+    });
+  };
+  return {
+    validatorJoin: async (options) => {
+      const amount = parseStakingAmount(options.amount);
+      const stakingAddress = getStakingAddress();
+      const data = options.operator ? encodeFunctionData2({
+        abi: STAKING_ABI,
+        functionName: "validatorJoin",
+        args: [options.operator]
+      }) : encodeFunctionData2({
+        abi: STAKING_ABI,
+        functionName: "validatorJoin"
+      });
+      const result = await executeWrite({ to: stakingAddress, data, value: amount });
+      const receipt = await publicClient.getTransactionReceipt({ hash: result.transactionHash });
+      let validatorWallet;
+      let eventFound = false;
+      for (const log of receipt.logs) {
+        try {
+          const decoded = decodeEventLog({ abi: STAKING_ABI, data: log.data, topics: log.topics });
+          if (decoded.eventName === "ValidatorJoin") {
+            validatorWallet = decoded.args.validator;
+            eventFound = true;
+            break;
+          }
+        } catch {
+        }
+      }
+      if (!eventFound) {
+        throw new Error(
+          `ValidatorJoin event not found in transaction ${result.transactionHash}. Transaction succeeded but validator wallet address could not be determined.`
+        );
+      }
+      return {
+        transactionHash: receipt.transactionHash,
+        blockNumber: receipt.blockNumber,
+        gasUsed: receipt.gasUsed,
+        validatorWallet,
+        operator: options.operator || client.account.address,
+        amount: formatStakingAmount(amount),
+        amountRaw: amount
+      };
+    },
+    validatorDeposit: async (options) => {
+      const amount = parseStakingAmount(options.amount);
+      const data = encodeFunctionData2({
+        abi: STAKING_ABI,
+        functionName: "validatorDeposit"
+      });
+      return executeWrite({ to: getStakingAddress(), data, value: amount });
+    },
+    validatorExit: async (options) => {
+      const shares = typeof options.shares === "string" ? BigInt(options.shares) : options.shares;
+      const data = encodeFunctionData2({
+        abi: STAKING_ABI,
+        functionName: "validatorExit",
+        args: [shares]
+      });
+      return executeWrite({ to: getStakingAddress(), data });
+    },
+    validatorClaim: async (options) => {
+      if (!options?.validator && !client.account) {
+        throw new Error("Either provide validator address or initialize client with an account");
+      }
+      const validatorAddress = options?.validator || client.account.address;
+      const data = encodeFunctionData2({
+        abi: STAKING_ABI,
+        functionName: "validatorClaim",
+        args: [validatorAddress]
+      });
+      const result = await executeWrite({ to: getStakingAddress(), data });
+      return { ...result, claimedAmount: 0n };
+    },
+    validatorPrime: async (options) => {
+      const data = encodeFunctionData2({
+        abi: STAKING_ABI,
+        functionName: "validatorPrime",
+        args: [options.validator]
+      });
+      return executeWrite({ to: getStakingAddress(), data });
+    },
+    setOperator: async (options) => {
+      const data = encodeFunctionData2({
+        abi: VALIDATOR_WALLET_ABI,
+        functionName: "setOperator",
+        args: [options.operator]
+      });
+      return executeWrite({ to: options.validator, data });
+    },
+    setIdentity: async (options) => {
+      let extraCidBytes = "0x";
+      if (options.extraCid) {
+        if (options.extraCid.startsWith("0x")) {
+          extraCidBytes = options.extraCid;
+        } else {
+          extraCidBytes = toHex4(new TextEncoder().encode(options.extraCid));
+        }
+      }
+      const data = encodeFunctionData2({
+        abi: VALIDATOR_WALLET_ABI,
+        functionName: "setIdentity",
+        args: [
+          options.moniker,
+          options.logoUri || "",
+          options.website || "",
+          options.description || "",
+          options.email || "",
+          options.twitter || "",
+          options.telegram || "",
+          options.github || "",
+          extraCidBytes
+        ]
+      });
+      return executeWrite({ to: options.validator, data });
+    },
+    delegatorJoin: async (options) => {
+      const amount = parseStakingAmount(options.amount);
+      const data = encodeFunctionData2({
+        abi: STAKING_ABI,
+        functionName: "delegatorJoin",
+        args: [options.validator]
+      });
+      const result = await executeWrite({ to: getStakingAddress(), data, value: amount });
+      return {
+        ...result,
+        validator: options.validator,
+        delegator: client.account.address,
+        amount: formatStakingAmount(amount),
+        amountRaw: amount
+      };
+    },
+    delegatorExit: async (options) => {
+      const shares = typeof options.shares === "string" ? BigInt(options.shares) : options.shares;
+      const data = encodeFunctionData2({
+        abi: STAKING_ABI,
+        functionName: "delegatorExit",
+        args: [options.validator, shares]
+      });
+      return executeWrite({ to: getStakingAddress(), data });
+    },
+    delegatorClaim: async (options) => {
+      if (!options.delegator && !client.account) {
+        throw new Error("Either provide delegator address or initialize client with an account");
+      }
+      const delegatorAddress = options.delegator || client.account.address;
+      const data = encodeFunctionData2({
+        abi: STAKING_ABI,
+        functionName: "delegatorClaim",
+        args: [delegatorAddress, options.validator]
+      });
+      return executeWrite({ to: getStakingAddress(), data });
+    },
+    isValidator: async (address) => {
+      const contract = getReadOnlyStakingContract();
+      return contract.read.isValidator([address]);
+    },
+    getValidatorInfo: async (validator) => {
+      const contract = getReadOnlyStakingContract();
+      const isVal = await contract.read.isValidator([validator]);
+      if (!isVal) {
+        throw new Error(`Address ${validator} is not a validator`);
+      }
+      const walletContract = getContract({
+        address: validator,
+        abi: VALIDATOR_WALLET_ABI,
+        client: publicClient
+      });
+      const [view, owner, operator, identityRaw, currentEpoch] = await Promise.all([
+        contract.read.validatorView([validator]),
+        walletContract.read.owner(),
+        walletContract.read.operator(),
+        walletContract.read.getIdentity().catch(() => null),
+        contract.read.epoch()
+      ]);
+      let identity;
+      if (identityRaw && identityRaw.moniker) {
+        identity = {
+          moniker: identityRaw.moniker,
+          logoUri: identityRaw.logoUri,
+          website: identityRaw.website,
+          description: identityRaw.description,
+          email: identityRaw.email,
+          twitter: identityRaw.twitter,
+          telegram: identityRaw.telegram,
+          github: identityRaw.github,
+          extraCid: identityRaw.extraCid ? toHex4(identityRaw.extraCid) : ""
+        };
+      }
+      const needsPriming = currentEpoch > 0n && view.ePrimed < currentEpoch - 1n;
+      const depositLen = await contract.read.validatorDepositLen([validator]);
+      const pendingDeposits = [];
+      for (let i = 0n; i < depositLen; i++) {
+        const [epoch, commit] = await contract.read.validatorDeposit([validator, i]);
+        pendingDeposits.push({
+          epoch,
+          stake: formatStakingAmount(commit.input),
+          stakeRaw: commit.input,
+          shares: commit.output
+        });
+      }
+      const withdrawalLen = await contract.read.validatorWithdrawalLen([validator]);
+      const pendingWithdrawals = [];
+      for (let i = 0n; i < withdrawalLen; i++) {
+        const [epoch, commit] = await contract.read.validatorWithdrawal([validator, i]);
+        pendingWithdrawals.push({
+          epoch,
+          shares: commit.input,
+          stake: formatStakingAmount(commit.output),
+          stakeRaw: commit.output
+        });
+      }
+      return {
+        address: validator,
+        owner,
+        operator,
+        vStake: formatStakingAmount(view.vStake),
+        vStakeRaw: view.vStake,
+        vShares: view.vShares,
+        dStake: formatStakingAmount(view.dStake),
+        dStakeRaw: view.dStake,
+        dShares: view.dShares,
+        vDeposit: formatStakingAmount(view.vDeposit),
+        vDepositRaw: view.vDeposit,
+        vWithdrawal: formatStakingAmount(view.vWithdrawal),
+        vWithdrawalRaw: view.vWithdrawal,
+        ePrimed: view.ePrimed,
+        live: view.live,
+        banned: view.eBanned > 0n,
+        bannedEpoch: view.eBanned > 0n ? view.eBanned : void 0,
+        needsPriming,
+        identity,
+        pendingDeposits,
+        pendingWithdrawals
+      };
+    },
+    getStakeInfo: async (delegator, validator) => {
+      const contract = getReadOnlyStakingContract();
+      const shares = await contract.read.sharesOf([delegator, validator]);
+      let stake = 0n;
+      if (shares > 0n) {
+        stake = await contract.read.stakeOf([delegator, validator]);
+      }
+      const depositLen = await contract.read.delegatorDepositLen([
+        delegator,
+        validator
+      ]);
+      const pendingDeposits = [];
+      for (let i = 0n; i < depositLen; i++) {
+        const [claim, commit] = await contract.read.delegatorDeposit([
+          delegator,
+          validator,
+          i
+        ]);
+        pendingDeposits.push({
+          epoch: commit.epoch,
+          stake: formatStakingAmount(commit.input),
+          stakeRaw: commit.input,
+          shares: claim.quantity
+        });
+      }
+      const withdrawalLen = await contract.read.delegatorWithdrawalLen([
+        delegator,
+        validator
+      ]);
+      const pendingWithdrawals = [];
+      for (let i = 0n; i < withdrawalLen; i++) {
+        const [claim, commit] = await contract.read.delegatorWithdrawal([
+          delegator,
+          validator,
+          i
+        ]);
+        pendingWithdrawals.push({
+          epoch: commit.epoch,
+          shares: claim.quantity,
+          stake: formatStakingAmount(commit.output),
+          stakeRaw: commit.output
+        });
+      }
+      return {
+        delegator,
+        validator,
+        shares,
+        stake: formatStakingAmount(stake),
+        stakeRaw: stake,
+        pendingDeposits,
+        pendingWithdrawals
+      };
+    },
+    getEpochInfo: async () => {
+      const contract = getReadOnlyStakingContract();
+      const [
+        epoch,
+        validatorMinStake,
+        delegatorMinStake,
+        activeCount,
+        epochMinDuration,
+        epochZeroMinDuration,
+        epochOdd,
+        epochEven
+      ] = await Promise.all([
+        contract.read.epoch(),
+        contract.read.validatorMinStake(),
+        contract.read.delegatorMinStake(),
+        contract.read.activeValidatorsCount(),
+        contract.read.epochMinDuration(),
+        contract.read.epochZeroMinDuration(),
+        contract.read.epochOdd(),
+        contract.read.epochEven()
+      ]);
+      const currentEpochData = epoch % 2n === 0n ? epochEven : epochOdd;
+      const currentEpochStart = new Date(Number(currentEpochData.start) * 1e3);
+      const currentEpochEnd = currentEpochData.end > 0n ? new Date(Number(currentEpochData.end) * 1e3) : null;
+      let nextEpochEstimate = null;
+      if (!currentEpochEnd) {
+        const duration = epoch === 0n ? epochZeroMinDuration : epochMinDuration;
+        const estimatedEndMs = Number(currentEpochData.start + duration) * 1e3;
+        nextEpochEstimate = new Date(estimatedEndMs);
+      }
+      return {
+        currentEpoch: epoch,
+        validatorMinStake: formatStakingAmount(validatorMinStake),
+        validatorMinStakeRaw: validatorMinStake,
+        delegatorMinStake: formatStakingAmount(delegatorMinStake),
+        delegatorMinStakeRaw: delegatorMinStake,
+        activeValidatorsCount: activeCount,
+        epochMinDuration,
+        currentEpochStart,
+        currentEpochEnd,
+        nextEpochEstimate,
+        inflation: formatStakingAmount(currentEpochData.inflation),
+        inflationRaw: currentEpochData.inflation,
+        totalWeight: currentEpochData.weight,
+        totalClaimed: formatStakingAmount(currentEpochData.claimed),
+        totalClaimedRaw: currentEpochData.claimed
+      };
+    },
+    getActiveValidators: async () => {
+      const contract = getReadOnlyStakingContract();
+      const validators = await contract.read.activeValidators();
+      return validators.filter((v) => v !== "0x0000000000000000000000000000000000000000");
+    },
+    getActiveValidatorsCount: async () => {
+      const contract = getReadOnlyStakingContract();
+      return contract.read.activeValidatorsCount();
+    },
+    getQuarantinedValidators: async () => {
+      const contract = getReadOnlyStakingContract();
+      return contract.read.getQuarantinedValidators();
+    },
+    getBannedValidators: async (startIndex = 0n, size = 100n) => {
+      const contract = getReadOnlyStakingContract();
+      const result = await contract.read.getAllBannedValidators([startIndex, size]);
+      return result.map((v) => ({
+        validator: v.validator,
+        untilEpoch: v.untilEpochBanned,
+        permanentlyBanned: v.permanentlyBanned
+      }));
+    },
+    getQuarantinedValidatorsDetailed: async (startIndex = 0n, size = 100n) => {
+      const contract = getReadOnlyStakingContract();
+      const result = await contract.read.getAllQuarantinedValidators([startIndex, size]);
+      return result.map((v) => ({
+        validator: v.validator,
+        untilEpoch: v.untilEpochBanned,
+        permanentlyBanned: v.permanentlyBanned
+      }));
+    },
+    getStakingContract,
+    parseStakingAmount,
+    formatStakingAmount
+  };
+};
+
 // src/chains/actions.ts
 function chainActions(client) {
   return {
@@ -1249,17 +1756,17 @@ var getCustomTransportConfig = (config) => {
   return {
     async request({ method, params = [] }) {
       if (method.startsWith("eth_") && isAddress) {
-        try {
-          const provider = config.provider || window.ethereum;
-          if (!provider) {
-            throw new Error("No wallet provider available");
+        const provider = config.provider || (typeof window !== "undefined" ? window.ethereum : void 0);
+        if (provider) {
+          try {
+            return await provider.request({ method, params });
+          } catch (err) {
+            console.warn(`Error using provider for method ${method}:`, err);
+            throw err;
           }
-          return await provider.request({ method, params });
-        } catch (err) {
-          console.warn(`Error using provider for method ${method}:`, err);
-          throw err;
         }
-      } else {
+      }
+      {
         if (!config.chain) {
           throw new Error("Chain is not set");
         }
@@ -1314,10 +1821,14 @@ var createClient = (config = { chain: localnet }) => {
     ...clientWithTransactionActions,
     ...contractActions(clientWithTransactionActions, publicClient)
   };
-  const finalClient = {
+  const clientWithReceiptActions = {
     ...clientWithAllActions,
     ...receiptActions(clientWithAllActions, publicClient)
   };
+  const finalClient = {
+    ...clientWithReceiptActions,
+    ...stakingActions(clientWithReceiptActions, publicClient)
+  };
   finalClient.initializeConsensusSmartContract().catch((error) => {
     console.error("Failed to initialize consensus smart contract:", error);
   });
@@ -1343,6 +1854,8 @@ export {
   decodeInputData,
   decodeLocalnetTransaction,
   decodeTransaction,
+  formatStakingAmount,
   generatePrivateKey,
+  parseStakingAmount,
   simplifyTransactionReceipt
 };