genlayer-js 0.18.4 → 0.18.5

package/dist/index.cjs

@@ -3,15 +3,17 @@
 
 
 
-var _chunkSMGWE7OHcjs = require('./chunk-SMGWE7OH.cjs');
 
 
+var _chunkTBF5WZHLcjs = require('./chunk-TBF5WZHL.cjs');
 
 
 
 
 
-var _chunkFPZNF3JHcjs = require('./chunk-FPZNF3JH.cjs');
+
+
+var _chunkW4V73RPNcjs = require('./chunk-W4V73RPN.cjs');
 
 
 var _chunk75ZPJI57cjs = require('./chunk-75ZPJI57.cjs');
@@ -29,7 +31,7 @@ var _viem = require('viem');
 function accountActions(client) {
   return {
     fundAccount: async ({ address, amount }) => {
-      if (_optionalChain([client, 'access', _ => _.chain, 'optionalAccess', _2 => _2.id]) !== _chunkSMGWE7OHcjs.localnet.id) {
+      if (_optionalChain([client, 'access', _ => _.chain, 'optionalAccess', _2 => _2.id]) !== _chunkTBF5WZHLcjs.localnet.id) {
         throw new Error("Client is not connected to the localnet");
       }
       return client.request({
@@ -184,7 +186,7 @@ function encodeImpl(to, data) {
         }
       } else if (data instanceof Map) {
         encodeMap(to, data);
-      } else if (data instanceof _chunkFPZNF3JHcjs.CalldataAddress) {
+      } else if (data instanceof _chunkW4V73RPNcjs.CalldataAddress) {
         to.push(SPECIAL_ADDR);
         for (const c of data.bytes) {
           to.push(c);
@@ -259,7 +261,7 @@ function decodeImpl(data, index) {
     case BigInt(SPECIAL_ADDR): {
       const res = data.slice(index.i, index.i + 20);
       index.i += 20;
-      return new (0, _chunkFPZNF3JHcjs.CalldataAddress)(res);
+      return new (0, _chunkW4V73RPNcjs.CalldataAddress)(res);
     }
   }
   const type = Number(cur & 0xffn) & (1 << BITS_IN_TYPE) - 1;
@@ -371,7 +373,7 @@ function toStringImpl(data, to) {
         to.push("]");
       } else if (data instanceof Map) {
         toStringImplMap(data.entries(), to);
-      } else if (data instanceof _chunkFPZNF3JHcjs.CalldataAddress) {
+      } else if (data instanceof _chunkW4V73RPNcjs.CalldataAddress) {
         to.push("addr#");
         for (const c of data.bytes) {
           to.push(c.toString(16));
@@ -413,6 +415,8 @@ function serialize(data) {
 // src/abi/index.ts
 var abi_exports = {};
 _chunk75ZPJI57cjs.__export.call(void 0, abi_exports, {
+  STAKING_ABI: () => _chunkTBF5WZHLcjs.STAKING_ABI,
+  VALIDATOR_WALLET_ABI: () => _chunkTBF5WZHLcjs.VALIDATOR_WALLET_ABI,
   calldata: () => calldata,
   transactions: () => transactions
 });
@@ -494,7 +498,7 @@ function _toJsonSafeDeep(value, seen) {
       }
       return obj;
     }
-    if (value instanceof _chunkFPZNF3JHcjs.CalldataAddress) {
+    if (value instanceof _chunkW4V73RPNcjs.CalldataAddress) {
       return _viem.toHex.call(void 0, value.bytes);
     }
     if (Object.getPrototypeOf(value) === Object.prototype) {
@@ -512,7 +516,7 @@ function _toJsonSafeDeep(value, seen) {
 var contractActions = (client, publicClient) => {
   return {
     getContractCode: async (address) => {
-      if (client.chain.id !== _chunkSMGWE7OHcjs.localnet.id) {
+      if (client.chain.id !== _chunkTBF5WZHLcjs.localnet.id) {
         throw new Error("Getting contract code is not supported on this network");
       }
       const result = await client.request({
@@ -523,7 +527,7 @@ var contractActions = (client, publicClient) => {
       return new TextDecoder().decode(codeBytes);
     },
     getContractSchema: async (address) => {
-      if (client.chain.id !== _chunkSMGWE7OHcjs.localnet.id) {
+      if (client.chain.id !== _chunkTBF5WZHLcjs.localnet.id) {
         throw new Error("Contract schema is not supported on this network");
       }
       const schema = await client.request({
@@ -533,7 +537,7 @@ var contractActions = (client, publicClient) => {
       return schema;
     },
     getContractSchemaForCode: async (contractCode) => {
-      if (client.chain.id !== _chunkSMGWE7OHcjs.localnet.id) {
+      if (client.chain.id !== _chunkTBF5WZHLcjs.localnet.id) {
         throw new Error("Contract schema is not supported on this network");
       }
       const schema = await client.request({
@@ -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,
@@ -897,8 +901,8 @@ var decodeTransaction = (tx) => {
       processingBlock: tx.readStateBlockRange.processingBlock.toString(),
       proposalBlock: tx.readStateBlockRange.proposalBlock.toString()
     },
-    statusName: _chunkFPZNF3JHcjs.transactionsStatusNumberToName[String(tx.status)],
-    resultName: _chunkFPZNF3JHcjs.transactionResultNumberToName[String(tx.result)],
+    statusName: _chunkW4V73RPNcjs.transactionsStatusNumberToName[String(tx.status)],
+    resultName: _chunkW4V73RPNcjs.transactionResultNumberToName[String(tx.result)],
     lastRound: {
       ...tx.lastRound,
       round: tx.lastRound.round.toString(),
@@ -908,7 +912,7 @@ var decodeTransaction = (tx) => {
       appealBond: tx.lastRound.appealBond.toString(),
       rotationsLeft: tx.lastRound.rotationsLeft.toString(),
       validatorVotesName: tx.lastRound.validatorVotes.map(
-        (vote) => _chunkFPZNF3JHcjs.voteTypeNumberToName[String(vote)]
+        (vote) => _chunkW4V73RPNcjs.voteTypeNumberToName[String(vote)]
       )
     }
   };
@@ -1047,10 +1051,10 @@ var receiptActions = (client, publicClient) => ({
       throw new Error("Transaction not found");
     }
     const transactionStatusString = String(transaction.status);
-    const requestedStatus = _chunkFPZNF3JHcjs.transactionsStatusNameToNumber[status];
-    if (transactionStatusString === requestedStatus || status === "ACCEPTED" /* ACCEPTED */ && _chunkFPZNF3JHcjs.isDecidedState.call(void 0, transactionStatusString)) {
+    const requestedStatus = _chunkW4V73RPNcjs.transactionsStatusNameToNumber[status];
+    if (transactionStatusString === requestedStatus || status === "ACCEPTED" /* ACCEPTED */ && _chunkW4V73RPNcjs.isDecidedState.call(void 0, transactionStatusString)) {
       let finalTransaction = transaction;
-      if (client.chain.id === _chunkSMGWE7OHcjs.localnet.id) {
+      if (client.chain.id === _chunkTBF5WZHLcjs.localnet.id) {
         finalTransaction = decodeLocalnetTransaction(transaction);
       }
       if (!fullTransaction) {
@@ -1076,7 +1080,7 @@ var transactionActions = (client, publicClient) => ({
     if (client.chain.isStudio) {
       const transaction2 = await client.getTransaction({ hash });
       const localnetStatus = transaction2.status === "ACTIVATED" ? "PENDING" /* PENDING */ : transaction2.status;
-      transaction2.status = Number(_chunkFPZNF3JHcjs.transactionsStatusNameToNumber[localnetStatus]);
+      transaction2.status = Number(_chunkW4V73RPNcjs.transactionsStatusNameToNumber[localnetStatus]);
       transaction2.statusName = localnetStatus;
       return decodeLocalnetTransaction(transaction2);
     }
@@ -1115,9 +1119,9 @@ var snapID = {
 
 // src/wallet/connect.ts
 var networks = {
-  localnet: _chunkSMGWE7OHcjs.localnet,
-  studionet: _chunkSMGWE7OHcjs.studionet,
-  testnetAsimov: _chunkSMGWE7OHcjs.testnetAsimov
+  localnet: _chunkTBF5WZHLcjs.localnet,
+  studionet: _chunkTBF5WZHLcjs.studionet,
+  testnetAsimov: _chunkTBF5WZHLcjs.testnetAsimov
 };
 var connect = async (client, network = "studionet", snapSource = "npm") => {
   if (!window.ethereum) {
@@ -1212,14 +1216,506 @@ function walletActions(client) {
   };
 }
 
+// src/staking/actions.ts
+
+
+// src/staking/utils.ts
+
+function parseStakingAmount(amount) {
+  if (typeof amount === "bigint") return amount;
+  const trimmed = amount.trim();
+  const lower = trimmed.toLowerCase();
+  if (lower.endsWith("gen")) {
+    return _viem.parseEther.call(void 0, lower.slice(0, -3).trim());
+  }
+  return BigInt(trimmed);
+}
+function formatStakingAmount(amount) {
+  return `${_viem.formatEther.call(void 0, amount)} GEN`;
+}
+
+// src/staking/actions.ts
+var FALLBACK_GAS = 1000000n;
+var GAS_BUFFER_MULTIPLIER = 2n;
+function extractRevertReason(err) {
+  if (err instanceof _viem.BaseError) {
+    const revertError = err.walk((e) => e instanceof _viem.ContractFunctionRevertedError);
+    if (revertError instanceof _viem.ContractFunctionRevertedError) {
+      return _optionalChain([revertError, 'access', _54 => _54.data, 'optionalAccess', _55 => _55.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 (e2) {
+        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 (!_optionalChain([stakingConfig, 'optionalAccess', _56 => _56.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 _viem.getContract.call(void 0, {
+      address,
+      abi: _chunkTBF5WZHLcjs.STAKING_ABI,
+      client: { public: publicClient, wallet: client }
+    });
+  };
+  const getReadOnlyStakingContract = () => {
+    const address = getStakingAddress();
+    return _viem.getContract.call(void 0, {
+      address,
+      abi: _chunkTBF5WZHLcjs.STAKING_ABI,
+      client: publicClient
+    });
+  };
+  return {
+    validatorJoin: async (options) => {
+      const amount = parseStakingAmount(options.amount);
+      const stakingAddress = getStakingAddress();
+      const data = options.operator ? _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.STAKING_ABI,
+        functionName: "validatorJoin",
+        args: [options.operator]
+      }) : _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.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 = _viem.decodeEventLog.call(void 0, { abi: _chunkTBF5WZHLcjs.STAKING_ABI, data: log.data, topics: log.topics });
+          if (decoded.eventName === "ValidatorJoin") {
+            validatorWallet = decoded.args.validator;
+            eventFound = true;
+            break;
+          }
+        } catch (e3) {
+        }
+      }
+      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 = _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.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 = _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.STAKING_ABI,
+        functionName: "validatorExit",
+        args: [shares]
+      });
+      return executeWrite({ to: getStakingAddress(), data });
+    },
+    validatorClaim: async (options) => {
+      if (!_optionalChain([options, 'optionalAccess', _57 => _57.validator]) && !client.account) {
+        throw new Error("Either provide validator address or initialize client with an account");
+      }
+      const validatorAddress = _optionalChain([options, 'optionalAccess', _58 => _58.validator]) || client.account.address;
+      const data = _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.STAKING_ABI,
+        functionName: "validatorClaim",
+        args: [validatorAddress]
+      });
+      const result = await executeWrite({ to: getStakingAddress(), data });
+      return { ...result, claimedAmount: 0n };
+    },
+    validatorPrime: async (options) => {
+      const data = _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.STAKING_ABI,
+        functionName: "validatorPrime",
+        args: [options.validator]
+      });
+      return executeWrite({ to: getStakingAddress(), data });
+    },
+    setOperator: async (options) => {
+      const data = _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.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 = _viem.toHex.call(void 0, new TextEncoder().encode(options.extraCid));
+        }
+      }
+      const data = _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.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 = _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.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 = _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.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 = _viem.encodeFunctionData.call(void 0, {
+        abi: _chunkTBF5WZHLcjs.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 = _viem.getContract.call(void 0, {
+        address: validator,
+        abi: _chunkTBF5WZHLcjs.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 ? _viem.toHex.call(void 0, 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, epochOdd, epochEven] = await Promise.all([
+        contract.read.epoch(),
+        contract.read.validatorMinStake(),
+        contract.read.delegatorMinStake(),
+        contract.read.activeValidatorsCount(),
+        contract.read.epochMinDuration(),
+        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 estimatedEndMs = Number(currentEpochData.start + epochMinDuration) * 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 {
     initializeConsensusSmartContract: async (forceReset = false) => {
-      if (_optionalChain([client, 'access', _54 => _54.chain, 'optionalAccess', _55 => _55.id]) === _chunkSMGWE7OHcjs.testnetAsimov.id) {
+      if (_optionalChain([client, 'access', _59 => _59.chain, 'optionalAccess', _60 => _60.id]) === _chunkTBF5WZHLcjs.testnetAsimov.id) {
         return;
       }
-      if (!forceReset && _optionalChain([client, 'access', _56 => _56.chain, 'access', _57 => _57.consensusMainContract, 'optionalAccess', _58 => _58.address]) && _optionalChain([client, 'access', _59 => _59.chain, 'access', _60 => _60.consensusMainContract, 'optionalAccess', _61 => _61.abi])) {
+      if (!forceReset && _optionalChain([client, 'access', _61 => _61.chain, 'access', _62 => _62.consensusMainContract, 'optionalAccess', _63 => _63.address]) && _optionalChain([client, 'access', _64 => _64.chain, 'access', _65 => _65.consensusMainContract, 'optionalAccess', _66 => _66.abi])) {
         return;
       }
       const contractsResponse = await fetch(client.chain.rpcUrls.default.http[0], {
@@ -1249,17 +1745,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");
         }
@@ -1289,8 +1785,8 @@ var getCustomTransportConfig = (config) => {
     }
   };
 };
-var createClient = (config = { chain: _chunkSMGWE7OHcjs.localnet }) => {
-  const chainConfig = config.chain || _chunkSMGWE7OHcjs.localnet;
+var createClient = (config = { chain: _chunkTBF5WZHLcjs.localnet }) => {
+  const chainConfig = config.chain || _chunkTBF5WZHLcjs.localnet;
   if (config.endpoint) {
     chainConfig.rpcUrls.default.http = [config.endpoint];
   }
@@ -1314,10 +1810,14 @@ var createClient = (config = { chain: _chunkSMGWE7OHcjs.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);
   });
@@ -1345,4 +1845,6 @@ var createAccount = (accountPrivateKey) => {
 
 
 
-exports.abi = abi_exports; exports.chains = _chunkSMGWE7OHcjs.chains_exports; exports.createAccount = createAccount; exports.createClient = createClient; exports.decodeInputData = decodeInputData; exports.decodeLocalnetTransaction = decodeLocalnetTransaction; exports.decodeTransaction = decodeTransaction; exports.generatePrivateKey = generatePrivateKey; exports.simplifyTransactionReceipt = simplifyTransactionReceipt;
+
+
+exports.abi = abi_exports; exports.chains = _chunkTBF5WZHLcjs.chains_exports; exports.createAccount = createAccount; exports.createClient = createClient; exports.decodeInputData = decodeInputData; exports.decodeLocalnetTransaction = decodeLocalnetTransaction; exports.decodeTransaction = decodeTransaction; exports.formatStakingAmount = formatStakingAmount; exports.generatePrivateKey = generatePrivateKey; exports.parseStakingAmount = parseStakingAmount; exports.simplifyTransactionReceipt = simplifyTransactionReceipt;