genlayer-js 0.27.8 → 0.28.0

package/dist/index.cjs

@@ -6,7 +6,7 @@
 
 
 
-var _chunkNOMVZBCRcjs = require('./chunk-NOMVZBCR.cjs');
+var _chunkPZEHAYIUcjs = require('./chunk-PZEHAYIU.cjs');
 
 
 
@@ -33,7 +33,7 @@ var _viem = require('viem');
 function accountActions(client) {
   return {
     fundAccount: async ({ address, amount }) => {
-      if (_optionalChain([client, 'access', _ => _.chain, 'optionalAccess', _2 => _2.id]) !== _chunkNOMVZBCRcjs.localnet.id) {
+      if (_optionalChain([client, 'access', _ => _.chain, 'optionalAccess', _2 => _2.id]) !== _chunkPZEHAYIUcjs.localnet.id) {
         throw new Error("Client is not connected to the localnet");
       }
       return client.request({
@@ -417,8 +417,8 @@ function serialize(data) {
 // src/abi/index.ts
 var abi_exports = {};
 _chunk75ZPJI57cjs.__export.call(void 0, abi_exports, {
-  STAKING_ABI: () => _chunkNOMVZBCRcjs.STAKING_ABI,
-  VALIDATOR_WALLET_ABI: () => _chunkNOMVZBCRcjs.VALIDATOR_WALLET_ABI,
+  STAKING_ABI: () => _chunkPZEHAYIUcjs.STAKING_ABI,
+  VALIDATOR_WALLET_ABI: () => _chunkPZEHAYIUcjs.VALIDATOR_WALLET_ABI,
   calldata: () => calldata,
   transactions: () => transactions
 });
@@ -532,8 +532,8 @@ var contractActions = (client, publicClient) => {
   return {
     /** Retrieves the source code of a deployed contract. Localnet only. */
     getContractCode: async (address) => {
-      if (client.chain.id !== _chunkNOMVZBCRcjs.localnet.id) {
-        throw new Error("Getting contract code is not supported on this network");
+      if (client.chain.id !== _chunkPZEHAYIUcjs.localnet.id) {
+        throw new Error(`getContractCode is only available on localnet (current chain: ${client.chain.name})`);
       }
       const result = await client.request({
         method: "gen_getContractCode",
@@ -544,8 +544,8 @@ var contractActions = (client, publicClient) => {
     },
     /** Gets the schema (methods and constructor) of a deployed contract. Localnet only. */
     getContractSchema: async (address) => {
-      if (client.chain.id !== _chunkNOMVZBCRcjs.localnet.id) {
-        throw new Error("Contract schema is not supported on this network");
+      if (client.chain.id !== _chunkPZEHAYIUcjs.localnet.id) {
+        throw new Error(`getContractSchema is only available on localnet (current chain: ${client.chain.name})`);
       }
       const schema = await client.request({
         method: "gen_getContractSchema",
@@ -555,8 +555,8 @@ var contractActions = (client, publicClient) => {
     },
     /** Generates a schema for contract code without deploying it. Localnet only. */
     getContractSchemaForCode: async (contractCode) => {
-      if (client.chain.id !== _chunkNOMVZBCRcjs.localnet.id) {
-        throw new Error("Contract schema is not supported on this network");
+      if (client.chain.id !== _chunkPZEHAYIUcjs.localnet.id) {
+        throw new Error(`getContractSchema is only available on localnet (current chain: ${client.chain.name})`);
       }
       const schema = await client.request({
         method: "gen_getContractSchemaForCode",
@@ -718,12 +718,60 @@ var contractActions = (client, publicClient) => {
       });
       return minBond;
     },
+    /** Returns the current consensus round number for a transaction. */
+    getRoundNumber: async (args) => {
+      if (!_optionalChain([client, 'access', _17 => _17.chain, 'access', _18 => _18.roundsStorageContract, 'optionalAccess', _19 => _19.address])) {
+        throw new Error("getRoundNumber not supported on this chain (missing roundsStorageContract)");
+      }
+      return publicClient.readContract({
+        address: client.chain.roundsStorageContract.address,
+        abi: client.chain.roundsStorageContract.abi,
+        functionName: "getRoundNumber",
+        args: [args.txId]
+      });
+    },
+    /** Returns detailed data for a specific consensus round. */
+    getRoundData: async (args) => {
+      if (!_optionalChain([client, 'access', _20 => _20.chain, 'access', _21 => _21.roundsStorageContract, 'optionalAccess', _22 => _22.address])) {
+        throw new Error("getRoundData not supported on this chain (missing roundsStorageContract)");
+      }
+      return publicClient.readContract({
+        address: client.chain.roundsStorageContract.address,
+        abi: client.chain.roundsStorageContract.abi,
+        functionName: "getRoundData",
+        args: [args.txId, args.round]
+      });
+    },
+    /** Returns the current round number and its data for a transaction. */
+    getLastRoundData: async (args) => {
+      if (!_optionalChain([client, 'access', _23 => _23.chain, 'access', _24 => _24.roundsStorageContract, 'optionalAccess', _25 => _25.address])) {
+        throw new Error("getLastRoundData not supported on this chain (missing roundsStorageContract)");
+      }
+      return publicClient.readContract({
+        address: client.chain.roundsStorageContract.address,
+        abi: client.chain.roundsStorageContract.abi,
+        functionName: "getLastRoundData",
+        args: [args.txId]
+      });
+    },
+    /** Checks if a transaction can be appealed. */
+    canAppeal: async (args) => {
+      if (!_optionalChain([client, 'access', _26 => _26.chain, 'access', _27 => _27.appealsContract, 'optionalAccess', _28 => _28.address])) {
+        throw new Error("canAppeal not supported on this chain (missing appealsContract)");
+      }
+      return publicClient.readContract({
+        address: client.chain.appealsContract.address,
+        abi: client.chain.appealsContract.abi,
+        functionName: "canAppeal",
+        args: [args.txId]
+      });
+    },
     /** Appeals a consensus transaction to trigger a new round of validation. */
     appealTransaction: async (args) => {
       const { account, txId } = args;
       let { value } = args;
       if (value === void 0) {
-        if (_optionalChain([client, 'access', _17 => _17.chain, 'access', _18 => _18.feeManagerContract, 'optionalAccess', _19 => _19.address]) && _optionalChain([client, 'access', _20 => _20.chain, 'access', _21 => _21.roundsStorageContract, 'optionalAccess', _22 => _22.address])) {
+        if (_optionalChain([client, 'access', _29 => _29.chain, 'access', _30 => _30.feeManagerContract, 'optionalAccess', _31 => _31.address]) && _optionalChain([client, 'access', _32 => _32.chain, 'access', _33 => _33.roundsStorageContract, 'optionalAccess', _34 => _34.address])) {
           const roundNumber = await publicClient.readContract({
             address: client.chain.roundsStorageContract.address,
             abi: client.chain.roundsStorageContract.abi,
@@ -744,13 +792,61 @@ var contractActions = (client, publicClient) => {
       }
       const senderAccount = account || client.account;
       const encodedData = _encodeSubmitAppealData({ client, txId });
-      return _sendTransaction({
-        client,
-        publicClient,
-        encodedData,
-        senderAccount,
-        value
-      });
+      const validatedAccount = validateAccount(senderAccount);
+      if (!_optionalChain([client, 'access', _35 => _35.chain, 'access', _36 => _36.consensusMainContract, 'optionalAccess', _37 => _37.address])) {
+        throw new Error("Consensus main contract not initialized.");
+      }
+      const nonce = await client.getCurrentNonce({ address: validatedAccount.address });
+      let estimatedGas;
+      try {
+        estimatedGas = await client.estimateTransactionGas({
+          to: client.chain.consensusMainContract.address,
+          data: encodedData,
+          value,
+          nonce
+        });
+      } catch (err) {
+        console.error("Gas estimation failed, using default 200_000:", err);
+        estimatedGas = 200000n;
+      }
+      const gasPriceHex = await client.request({ method: "eth_gasPrice" });
+      const txRequest = {
+        account: validatedAccount,
+        to: client.chain.consensusMainContract.address,
+        data: encodedData,
+        value,
+        gas: estimatedGas,
+        gasPrice: BigInt(gasPriceHex),
+        nonce,
+        chainId: client.chain.id
+      };
+      if (validatedAccount.type === "local") {
+        if (!validatedAccount.signTransaction) {
+          throw new Error("Local account does not support signTransaction.");
+        }
+        const serializedTransaction = await validatedAccount.signTransaction(txRequest);
+        const evmHash = await client.sendRawTransaction({ serializedTransaction });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: evmHash });
+        if (receipt.status === "reverted") {
+          throw new Error(`Appeal reverted: EVM tx ${evmHash}`);
+        }
+      } else {
+        const evmHash = await client.request({
+          method: "eth_sendTransaction",
+          params: [{
+            from: validatedAccount.address,
+            to: client.chain.consensusMainContract.address,
+            data: encodedData,
+            value: value ? `0x${value.toString(16)}` : void 0,
+            gas: `0x${estimatedGas.toString(16)}`
+          }]
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: evmHash });
+        if (receipt.status === "reverted") {
+          throw new Error(`Appeal reverted: EVM tx ${evmHash}`);
+        }
+      }
+      return txId;
     }
   };
 };
@@ -762,6 +858,17 @@ var validateAccount = (Account4) => {
   }
   return Account4;
 };
+var CREATED_TRANSACTION_EVENT_ABI = [
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "bytes32", name: "txId", type: "bytes32" },
+      { indexed: false, internalType: "uint256", name: "txSlot", type: "uint256" }
+    ],
+    name: "CreatedTransaction",
+    type: "event"
+  }
+];
 var ADD_TRANSACTION_ABI_V5 = [
   {
     type: "function",
@@ -804,7 +911,7 @@ var getAddTransactionInputCount = (abi) => {
     const candidate = item;
     return candidate.type === "function" && candidate.name === "addTransaction";
   });
-  return Array.isArray(_optionalChain([addTransactionFunction, 'optionalAccess', _23 => _23.inputs])) ? addTransactionFunction.inputs.length : 0;
+  return Array.isArray(_optionalChain([addTransactionFunction, 'optionalAccess', _38 => _38.inputs])) ? addTransactionFunction.inputs.length : 0;
 };
 var _encodeAddTransactionData = ({
   client,
@@ -831,7 +938,7 @@ var _encodeAddTransactionData = ({
     functionName: "addTransaction",
     args: [...addTransactionArgs, 0n]
   });
-  if (getAddTransactionInputCount(_optionalChain([client, 'access', _24 => _24.chain, 'access', _25 => _25.consensusMainContract, 'optionalAccess', _26 => _26.abi])) >= 6) {
+  if (getAddTransactionInputCount(_optionalChain([client, 'access', _39 => _39.chain, 'access', _40 => _40.consensusMainContract, 'optionalAccess', _41 => _41.abi])) >= 6) {
     return {
       primaryEncodedData: encodedDataV6,
       fallbackEncodedData: encodedDataV5
@@ -847,7 +954,7 @@ var _encodeSubmitAppealData = ({
   txId
 }) => {
   return _viem.encodeFunctionData.call(void 0, {
-    abi: _optionalChain([client, 'access', _27 => _27.chain, 'access', _28 => _28.consensusMainContract, 'optionalAccess', _29 => _29.abi]),
+    abi: _optionalChain([client, 'access', _42 => _42.chain, 'access', _43 => _43.consensusMainContract, 'optionalAccess', _44 => _44.abi]),
     functionName: "submitAppeal",
     args: [txId]
   });
@@ -868,14 +975,33 @@ var isAddTransactionAbiMismatchError = (error) => {
   }) : "";
   const errorObject = error;
   const errorMessage = [
-    _optionalChain([errorObject, 'optionalAccess', _30 => _30.shortMessage]),
-    _optionalChain([errorObject, 'optionalAccess', _31 => _31.details]),
-    _optionalChain([errorObject, 'optionalAccess', _32 => _32.message]),
+    _optionalChain([errorObject, 'optionalAccess', _45 => _45.shortMessage]),
+    _optionalChain([errorObject, 'optionalAccess', _46 => _46.details]),
+    _optionalChain([errorObject, 'optionalAccess', _47 => _47.message]),
     serializedError,
     String(_nullishCoalesce(error, () => ( "")))
   ].filter(Boolean).join(" ").toLowerCase();
   return errorMessage.includes("invalid pointer in tuple") || errorMessage.includes("invalid pointer") || errorMessage.includes("could not decode") || errorMessage.includes("invalid arrayify value") || errorMessage.includes("types/value length mismatch");
 };
+var extractTxIdFromLogs = (client, logs) => {
+  const newTxEvents = _viem.parseEventLogs.call(void 0, {
+    abi: _optionalChain([client, 'access', _48 => _48.chain, 'access', _49 => _49.consensusMainContract, 'optionalAccess', _50 => _50.abi]),
+    eventName: "NewTransaction",
+    logs
+  });
+  if (newTxEvents.length > 0) {
+    return newTxEvents[0].args["txId"];
+  }
+  const createdTxEvents = _viem.parseEventLogs.call(void 0, {
+    abi: CREATED_TRANSACTION_EVENT_ABI,
+    eventName: "CreatedTransaction",
+    logs
+  });
+  if (createdTxEvents.length > 0) {
+    return createdTxEvents[0].args["txId"];
+  }
+  return null;
+};
 var _sendTransaction = async ({
   client,
   publicClient,
@@ -884,8 +1010,8 @@ var _sendTransaction = async ({
   senderAccount,
   value = 0n
 }) => {
-  if (!_optionalChain([client, 'access', _33 => _33.chain, 'access', _34 => _34.consensusMainContract, 'optionalAccess', _35 => _35.address])) {
-    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
+  if (!_optionalChain([client, 'access', _51 => _51.chain, 'access', _52 => _52.consensusMainContract, 'optionalAccess', _53 => _53.address])) {
+    throw new Error(`Consensus main contract address not found in chain config for "${client.chain.name}".`);
   }
   const validatedSenderAccount = validateAccount(senderAccount);
   const nonce = await client.getCurrentNonce({ address: validatedSenderAccount.address });
@@ -894,7 +1020,7 @@ var _sendTransaction = async ({
     try {
       estimatedGas = await client.estimateTransactionGas({
         from: validatedSenderAccount.address,
-        to: _optionalChain([client, 'access', _36 => _36.chain, 'access', _37 => _37.consensusMainContract, 'optionalAccess', _38 => _38.address]),
+        to: _optionalChain([client, 'access', _54 => _54.chain, 'access', _55 => _55.consensusMainContract, 'optionalAccess', _56 => _56.address]),
         data: encodedDataForSend,
         value
       });
@@ -902,16 +1028,16 @@ var _sendTransaction = async ({
       console.error("Gas estimation failed, using default 200_000:", err);
       estimatedGas = 200000n;
     }
-    if (_optionalChain([validatedSenderAccount, 'optionalAccess', _39 => _39.type]) === "local") {
-      if (!_optionalChain([validatedSenderAccount, 'optionalAccess', _40 => _40.signTransaction])) {
-        throw new Error("Account does not support signTransaction");
+    if (_optionalChain([validatedSenderAccount, 'optionalAccess', _57 => _57.type]) === "local") {
+      if (!_optionalChain([validatedSenderAccount, 'optionalAccess', _58 => _58.signTransaction])) {
+        throw new Error("Local account does not support signTransaction. Use a private key account created via privateKeyToAccount().");
       }
       const gasPriceHex2 = await client.request({
         method: "eth_gasPrice"
       });
       const transactionRequest = {
         account: validatedSenderAccount,
-        to: _optionalChain([client, 'access', _41 => _41.chain, 'access', _42 => _42.consensusMainContract, 'optionalAccess', _43 => _43.address]),
+        to: _optionalChain([client, 'access', _59 => _59.chain, 'access', _60 => _60.consensusMainContract, 'optionalAccess', _61 => _61.address]),
         data: encodedDataForSend,
         type: "legacy",
         nonce: Number(nonce),
@@ -924,17 +1050,15 @@ var _sendTransaction = async ({
       const txHash = await client.sendRawTransaction({ serializedTransaction });
       const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       if (receipt.status === "reverted") {
-        throw new Error("Transaction reverted");
+        throw new Error(`Transaction reverted: EVM tx ${txHash} to consensus contract ${_optionalChain([client, 'access', _62 => _62.chain, 'access', _63 => _63.consensusMainContract, 'optionalAccess', _64 => _64.address])} was reverted.`);
       }
-      const newTxEvents = _viem.parseEventLogs.call(void 0, {
-        abi: _optionalChain([client, 'access', _44 => _44.chain, 'access', _45 => _45.consensusMainContract, 'optionalAccess', _46 => _46.abi]),
-        eventName: "NewTransaction",
-        logs: receipt.logs
-      });
-      if (newTxEvents.length === 0) {
-        throw new Error("Transaction not processed by consensus");
+      const txId = extractTxIdFromLogs(client, receipt.logs);
+      if (!txId) {
+        throw new Error(
+          `Transaction not processed by consensus: EVM tx ${txHash} succeeded but no NewTransaction or CreatedTransaction event was found in the receipt logs.`
+        );
       }
-      return newTxEvents[0].args["txId"];
+      return txId;
     }
     let gasPriceHex;
     try {
@@ -950,7 +1074,7 @@ var _sendTransaction = async ({
     const nonceBigInt = typeof nonce === "bigint" ? nonce : typeof nonce === "string" ? BigInt(nonce) : BigInt(Number(nonce));
     const formattedRequest = {
       from: validatedSenderAccount.address,
-      to: _optionalChain([client, 'access', _47 => _47.chain, 'access', _48 => _48.consensusMainContract, 'optionalAccess', _49 => _49.address]),
+      to: _optionalChain([client, 'access', _65 => _65.chain, 'access', _66 => _66.consensusMainContract, 'optionalAccess', _67 => _67.address]),
       data: encodedDataForSend,
       value: `0x${value.toString(16)}`,
       gas: `0x${estimatedGas.toString(16)}`,
@@ -966,17 +1090,15 @@ var _sendTransaction = async ({
     });
     const externalReceipt = await publicClient.waitForTransactionReceipt({ hash: evmTxHash });
     if (externalReceipt.status === "reverted") {
-      throw new Error("Transaction reverted");
+      throw new Error(`Transaction reverted: EVM tx ${evmTxHash} to consensus contract ${_optionalChain([client, 'access', _68 => _68.chain, 'access', _69 => _69.consensusMainContract, 'optionalAccess', _70 => _70.address])} was reverted.`);
     }
-    const externalNewTxEvents = _viem.parseEventLogs.call(void 0, {
-      abi: _optionalChain([client, 'access', _50 => _50.chain, 'access', _51 => _51.consensusMainContract, 'optionalAccess', _52 => _52.abi]),
-      eventName: "NewTransaction",
-      logs: externalReceipt.logs
-    });
-    if (externalNewTxEvents.length === 0) {
-      throw new Error("Transaction not processed by consensus");
+    const externalTxId = extractTxIdFromLogs(client, externalReceipt.logs);
+    if (!externalTxId) {
+      throw new Error(
+        `Transaction not processed by consensus: EVM tx ${evmTxHash} succeeded but no NewTransaction or CreatedTransaction event was found in the receipt logs.`
+      );
     }
-    return externalNewTxEvents[0].args["txId"];
+    return externalTxId;
   };
   try {
     return await sendWithEncodedData(encodedData);
@@ -1093,7 +1215,7 @@ var decodeTransaction = (tx) => {
     txData,
     txDataDecoded,
     currentTimestamp: tx.currentTimestamp.toString(),
-    numOfInitialValidators: _nullishCoalesce(_optionalChain([numOfInitialValidators, 'optionalAccess', _53 => _53.toString, 'call', _54 => _54()]), () => ( "0")),
+    numOfInitialValidators: _nullishCoalesce(_optionalChain([numOfInitialValidators, 'optionalAccess', _71 => _71.toString, 'call', _72 => _72()]), () => ( "0")),
     txSlot: tx.txSlot.toString(),
     createdTimestamp: tx.createdTimestamp.toString(),
     lastVoteTimestamp: tx.lastVoteTimestamp.toString(),
@@ -1101,9 +1223,9 @@ var decodeTransaction = (tx) => {
     numOfRounds: tx.numOfRounds.toString(),
     readStateBlockRange: {
       ...tx.readStateBlockRange,
-      activationBlock: _nullishCoalesce(_optionalChain([tx, 'access', _55 => _55.readStateBlockRange, 'optionalAccess', _56 => _56.activationBlock, 'optionalAccess', _57 => _57.toString, 'call', _58 => _58()]), () => ( "0")),
-      processingBlock: _nullishCoalesce(_optionalChain([tx, 'access', _59 => _59.readStateBlockRange, 'optionalAccess', _60 => _60.processingBlock, 'optionalAccess', _61 => _61.toString, 'call', _62 => _62()]), () => ( "0")),
-      proposalBlock: _nullishCoalesce(_optionalChain([tx, 'access', _63 => _63.readStateBlockRange, 'optionalAccess', _64 => _64.proposalBlock, 'optionalAccess', _65 => _65.toString, 'call', _66 => _66()]), () => ( "0"))
+      activationBlock: _nullishCoalesce(_optionalChain([tx, 'access', _73 => _73.readStateBlockRange, 'optionalAccess', _74 => _74.activationBlock, 'optionalAccess', _75 => _75.toString, 'call', _76 => _76()]), () => ( "0")),
+      processingBlock: _nullishCoalesce(_optionalChain([tx, 'access', _77 => _77.readStateBlockRange, 'optionalAccess', _78 => _78.processingBlock, 'optionalAccess', _79 => _79.toString, 'call', _80 => _80()]), () => ( "0")),
+      proposalBlock: _nullishCoalesce(_optionalChain([tx, 'access', _81 => _81.readStateBlockRange, 'optionalAccess', _82 => _82.proposalBlock, 'optionalAccess', _83 => _83.toString, 'call', _84 => _84()]), () => ( "0"))
     },
     statusName: _chunkGJXSECNHcjs.transactionsStatusNumberToName[String(tx.status)],
     resultName: _chunkGJXSECNHcjs.transactionResultNumberToName[String(tx.result)],
@@ -1111,13 +1233,13 @@ var decodeTransaction = (tx) => {
     txExecutionResultName: tx.txExecutionResult !== void 0 ? _chunkGJXSECNHcjs.executionResultNumberToName[String(tx.txExecutionResult)] : void 0,
     lastRound: {
       ...tx.lastRound,
-      round: _nullishCoalesce(_optionalChain([tx, 'access', _67 => _67.lastRound, 'optionalAccess', _68 => _68.round, 'optionalAccess', _69 => _69.toString, 'call', _70 => _70()]), () => ( "0")),
-      leaderIndex: _nullishCoalesce(_optionalChain([tx, 'access', _71 => _71.lastRound, 'optionalAccess', _72 => _72.leaderIndex, 'optionalAccess', _73 => _73.toString, 'call', _74 => _74()]), () => ( "0")),
-      votesCommitted: _nullishCoalesce(_optionalChain([tx, 'access', _75 => _75.lastRound, 'optionalAccess', _76 => _76.votesCommitted, 'optionalAccess', _77 => _77.toString, 'call', _78 => _78()]), () => ( "0")),
-      votesRevealed: _nullishCoalesce(_optionalChain([tx, 'access', _79 => _79.lastRound, 'optionalAccess', _80 => _80.votesRevealed, 'optionalAccess', _81 => _81.toString, 'call', _82 => _82()]), () => ( "0")),
-      appealBond: _nullishCoalesce(_optionalChain([tx, 'access', _83 => _83.lastRound, 'optionalAccess', _84 => _84.appealBond, 'optionalAccess', _85 => _85.toString, 'call', _86 => _86()]), () => ( "0")),
-      rotationsLeft: _nullishCoalesce(_optionalChain([tx, 'access', _87 => _87.lastRound, 'optionalAccess', _88 => _88.rotationsLeft, 'optionalAccess', _89 => _89.toString, 'call', _90 => _90()]), () => ( "0")),
-      validatorVotesName: (_nullishCoalesce(_optionalChain([tx, 'access', _91 => _91.lastRound, 'optionalAccess', _92 => _92.validatorVotes]), () => ( []))).map(
+      round: _nullishCoalesce(_optionalChain([tx, 'access', _85 => _85.lastRound, 'optionalAccess', _86 => _86.round, 'optionalAccess', _87 => _87.toString, 'call', _88 => _88()]), () => ( "0")),
+      leaderIndex: _nullishCoalesce(_optionalChain([tx, 'access', _89 => _89.lastRound, 'optionalAccess', _90 => _90.leaderIndex, 'optionalAccess', _91 => _91.toString, 'call', _92 => _92()]), () => ( "0")),
+      votesCommitted: _nullishCoalesce(_optionalChain([tx, 'access', _93 => _93.lastRound, 'optionalAccess', _94 => _94.votesCommitted, 'optionalAccess', _95 => _95.toString, 'call', _96 => _96()]), () => ( "0")),
+      votesRevealed: _nullishCoalesce(_optionalChain([tx, 'access', _97 => _97.lastRound, 'optionalAccess', _98 => _98.votesRevealed, 'optionalAccess', _99 => _99.toString, 'call', _100 => _100()]), () => ( "0")),
+      appealBond: _nullishCoalesce(_optionalChain([tx, 'access', _101 => _101.lastRound, 'optionalAccess', _102 => _102.appealBond, 'optionalAccess', _103 => _103.toString, 'call', _104 => _104()]), () => ( "0")),
+      rotationsLeft: _nullishCoalesce(_optionalChain([tx, 'access', _105 => _105.lastRound, 'optionalAccess', _106 => _106.rotationsLeft, 'optionalAccess', _107 => _107.toString, 'call', _108 => _108()]), () => ( "0")),
+      validatorVotesName: (_nullishCoalesce(_optionalChain([tx, 'access', _109 => _109.lastRound, 'optionalAccess', _110 => _110.validatorVotes]), () => ( []))).map(
         (vote) => _chunkGJXSECNHcjs.voteTypeNumberToName[String(vote)]
       )
     }
@@ -1199,7 +1321,7 @@ var simplifyTransactionReceipt = (tx) => {
 var decodeLocalnetTransaction = (tx) => {
   if (!tx.data) return tx;
   try {
-    const leaderReceipt = _optionalChain([tx, 'access', _93 => _93.consensus_data, 'optionalAccess', _94 => _94.leader_receipt]);
+    const leaderReceipt = _optionalChain([tx, 'access', _111 => _111.consensus_data, 'optionalAccess', _112 => _112.leader_receipt]);
     if (leaderReceipt) {
       const receipts = Array.isArray(leaderReceipt) ? leaderReceipt : [leaderReceipt];
       receipts.forEach((receipt) => {
@@ -1230,7 +1352,7 @@ var decodeLocalnetTransaction = (tx) => {
         }
       });
     }
-    if (_optionalChain([tx, 'access', _95 => _95.data, 'optionalAccess', _96 => _96.calldata]) && typeof tx.data.calldata === "string") {
+    if (_optionalChain([tx, 'access', _113 => _113.data, 'optionalAccess', _114 => _114.calldata]) && typeof tx.data.calldata === "string") {
       tx.data.calldata = {
         base64: tx.data.calldata,
         ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
@@ -1256,13 +1378,13 @@ var receiptActions = (client, publicClient) => ({
       hash
     });
     if (!transaction) {
-      throw new Error("Transaction not found");
+      throw new Error(`Transaction not found: ${hash}`);
     }
     const transactionStatusString = String(transaction.status);
     const requestedStatus = _chunkGJXSECNHcjs.transactionsStatusNameToNumber[status];
     if (transactionStatusString === requestedStatus || status === "ACCEPTED" /* ACCEPTED */ && _chunkGJXSECNHcjs.isDecidedState.call(void 0, transactionStatusString)) {
       let finalTransaction = transaction;
-      if (client.chain.id === _chunkNOMVZBCRcjs.localnet.id) {
+      if (client.chain.id === _chunkPZEHAYIUcjs.localnet.id) {
         finalTransaction = decodeLocalnetTransaction(transaction);
       }
       if (!fullTransaction) {
@@ -1271,7 +1393,7 @@ var receiptActions = (client, publicClient) => ({
       return finalTransaction;
     }
     if (retries === 0) {
-      throw new Error("Transaction status is not " + status);
+      throw new Error(`Timed out waiting for transaction ${hash} to reach status "${status}" (current status: ${transactionStatusString}).`);
     }
     await sleep(interval);
     return receiptActions(client, publicClient).waitForTransactionReceipt({
@@ -1293,8 +1415,8 @@ var transactionActions = (client, publicClient) => ({
       transaction2.statusName = localnetStatus;
       return decodeLocalnetTransaction(transaction2);
     }
-    const contractAddress = _optionalChain([client, 'access', _97 => _97.chain, 'access', _98 => _98.consensusDataContract, 'optionalAccess', _99 => _99.address]);
-    const contractAbi = _optionalChain([client, 'access', _100 => _100.chain, 'access', _101 => _101.consensusDataContract, 'optionalAccess', _102 => _102.abi]);
+    const contractAddress = _optionalChain([client, 'access', _115 => _115.chain, 'access', _116 => _116.consensusDataContract, 'optionalAccess', _117 => _117.address]);
+    const contractAbi = _optionalChain([client, 'access', _118 => _118.chain, 'access', _119 => _119.consensusDataContract, 'optionalAccess', _120 => _120.abi]);
     const [txDataRaw, allDataRaw] = await Promise.all([
       publicClient.readContract({
         address: contractAddress,
@@ -1324,12 +1446,12 @@ var transactionActions = (client, publicClient) => ({
       return _nullishCoalesce(tx2.triggered_transactions, () => ( []));
     }
     const tx = await transactionActions(client, publicClient).getTransaction({ hash });
-    const proposalBlock = BigInt(_nullishCoalesce(_optionalChain([tx, 'access', _103 => _103.readStateBlockRange, 'optionalAccess', _104 => _104.proposalBlock]), () => ( "0")));
+    const proposalBlock = BigInt(_nullishCoalesce(_optionalChain([tx, 'access', _121 => _121.readStateBlockRange, 'optionalAccess', _122 => _122.proposalBlock]), () => ( "0")));
     if (proposalBlock === BigInt(0)) return [];
     const scanRange = BigInt(100);
     const latestBlock = await publicClient.getBlockNumber();
     const toBlock = proposalBlock + scanRange < latestBlock ? proposalBlock + scanRange : latestBlock;
-    const consensusAddress = _optionalChain([client, 'access', _105 => _105.chain, 'access', _106 => _106.consensusMainContract, 'optionalAccess', _107 => _107.address]);
+    const consensusAddress = _optionalChain([client, 'access', _123 => _123.chain, 'access', _124 => _124.consensusMainContract, 'optionalAccess', _125 => _125.address]);
     const internalMessageProcessedTopic = _viem.keccak256.call(void 0, _viem.stringToBytes.call(void 0, "InternalMessageProcessed(bytes32,address,address)"));
     const logs = await publicClient.getLogs({
       address: consensusAddress,
@@ -1376,10 +1498,36 @@ var transactionActions = (client, publicClient) => ({
       params: [hash, signature]
     });
   },
+  /** Returns the queue slot position of a transaction in the pending queue. */
+  getTransactionQueuePosition: async ({ hash }) => {
+    const consensusAddress = _optionalChain([client, 'access', _126 => _126.chain, 'access', _127 => _127.consensusMainContract, 'optionalAccess', _128 => _128.address]);
+    const consensusAbi = _optionalChain([client, 'access', _129 => _129.chain, 'access', _130 => _130.consensusMainContract, 'optionalAccess', _131 => _131.abi]);
+    const queuesAddress = await publicClient.readContract({
+      address: consensusAddress,
+      abi: consensusAbi,
+      functionName: "queues"
+    });
+    const QUEUES_ABI = [
+      {
+        inputs: [{ internalType: "bytes32", name: "txId", type: "bytes32" }],
+        name: "getTransactionQueuePosition",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function"
+      }
+    ];
+    const position = await publicClient.readContract({
+      address: queuesAddress,
+      abi: QUEUES_ABI,
+      functionName: "getTransactionQueuePosition",
+      args: [hash]
+    });
+    return Number(position);
+  },
   /** Estimates gas required for a transaction. */
   estimateTransactionGas: async (transactionParams) => {
     const formattedParams = {
-      from: transactionParams.from || _optionalChain([client, 'access', _108 => _108.account, 'optionalAccess', _109 => _109.address]),
+      from: transactionParams.from || _optionalChain([client, 'access', _132 => _132.account, 'optionalAccess', _133 => _133.address]),
       to: transactionParams.to,
       data: transactionParams.data || "0x",
       value: transactionParams.value ? `0x${transactionParams.value.toString(16)}` : "0x0"
@@ -1400,10 +1548,10 @@ var snapID = {
 
 // src/wallet/connect.ts
 var networks = {
-  localnet: _chunkNOMVZBCRcjs.localnet,
-  studionet: _chunkNOMVZBCRcjs.studionet,
-  testnetAsimov: _chunkNOMVZBCRcjs.testnetAsimov,
-  testnetBradbury: _chunkNOMVZBCRcjs.testnetBradbury
+  localnet: _chunkPZEHAYIUcjs.localnet,
+  studionet: _chunkPZEHAYIUcjs.studionet,
+  testnetAsimov: _chunkPZEHAYIUcjs.testnetAsimov,
+  testnetBradbury: _chunkPZEHAYIUcjs.testnetBradbury
 };
 var connect = async (client, network = "studionet", snapSource = "npm") => {
   if (!window.ethereum) {
@@ -1422,7 +1570,7 @@ var connect = async (client, network = "studionet", snapSource = "npm") => {
     chainName: selectedNetwork.name,
     rpcUrls: selectedNetwork.rpcUrls.default.http,
     nativeCurrency: selectedNetwork.nativeCurrency,
-    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _110 => _110.blockExplorers, 'optionalAccess', _111 => _111.default, 'access', _112 => _112.url])]
+    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _134 => _134.blockExplorers, 'optionalAccess', _135 => _135.default, 'access', _136 => _136.url])]
   };
   const currentChainId = await window.ethereum.request({ method: "eth_chainId" });
   if (currentChainId !== chainIdHex) {
@@ -1456,10 +1604,10 @@ var metamaskClient = async (snapSource = "npm") => {
   }
   const isFlask = async () => {
     try {
-      const clientVersion = await _optionalChain([window, 'access', _113 => _113.ethereum, 'optionalAccess', _114 => _114.request, 'call', _115 => _115({
+      const clientVersion = await _optionalChain([window, 'access', _137 => _137.ethereum, 'optionalAccess', _138 => _138.request, 'call', _139 => _139({
         method: "web3_clientVersion"
       })]);
-      return _optionalChain([clientVersion, 'optionalAccess', _116 => _116.includes, 'call', _117 => _117("flask")]);
+      return _optionalChain([clientVersion, 'optionalAccess', _140 => _140.includes, 'call', _141 => _141("flask")]);
     } catch (error) {
       console.error("Error detecting Flask:", error);
       return false;
@@ -1467,7 +1615,7 @@ var metamaskClient = async (snapSource = "npm") => {
   };
   const installedSnaps = async () => {
     try {
-      return await _optionalChain([window, 'access', _118 => _118.ethereum, 'optionalAccess', _119 => _119.request, 'call', _120 => _120({
+      return await _optionalChain([window, 'access', _142 => _142.ethereum, 'optionalAccess', _143 => _143.request, 'call', _144 => _144({
         method: "wallet_getSnaps"
       })]);
     } catch (error) {
@@ -1519,7 +1667,7 @@ function formatStakingAmount(amount) {
 // src/staking/actions.ts
 var FALLBACK_GAS = 1000000n;
 var GAS_BUFFER_MULTIPLIER = 2n;
-var COMBINED_ERROR_ABI = [..._chunkNOMVZBCRcjs.STAKING_ABI, ..._chunkNOMVZBCRcjs.VALIDATOR_WALLET_ABI];
+var COMBINED_ERROR_ABI = [..._chunkPZEHAYIUcjs.STAKING_ABI, ..._chunkPZEHAYIUcjs.VALIDATOR_WALLET_ABI];
 function extractRevertReason(err) {
   if (err instanceof _viem.BaseError) {
     const rawError = err.walk((e) => e instanceof _viem.RawContractError);
@@ -1554,7 +1702,7 @@ function extractRevertReason(err) {
     }
     const revertError = err.walk((e) => e instanceof _viem.ContractFunctionRevertedError);
     if (revertError instanceof _viem.ContractFunctionRevertedError) {
-      if (_optionalChain([revertError, 'access', _121 => _121.data, 'optionalAccess', _122 => _122.errorName])) {
+      if (_optionalChain([revertError, 'access', _145 => _145.data, 'optionalAccess', _146 => _146.errorName])) {
         return revertError.data.errorName;
       }
       return revertError.reason || "Unknown reason";
@@ -1642,7 +1790,7 @@ var stakingActions = (client, publicClient) => {
   };
   const getStakingAddress = () => {
     const stakingConfig = client.chain.stakingContract;
-    if (!_optionalChain([stakingConfig, 'optionalAccess', _123 => _123.address]) || stakingConfig.address === "0x0000000000000000000000000000000000000000") {
+    if (!_optionalChain([stakingConfig, 'optionalAccess', _147 => _147.address]) || stakingConfig.address === "0x0000000000000000000000000000000000000000") {
       throw new Error("Staking is not supported on studio-based networks. Use testnet-asimov for staking operations.");
     }
     return stakingConfig.address;
@@ -1651,7 +1799,7 @@ var stakingActions = (client, publicClient) => {
     const address = getStakingAddress();
     return _viem.getContract.call(void 0, {
       address,
-      abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+      abi: _chunkPZEHAYIUcjs.STAKING_ABI,
       client: { public: publicClient, wallet: client }
     });
   };
@@ -1659,7 +1807,7 @@ var stakingActions = (client, publicClient) => {
     const address = getStakingAddress();
     return _viem.getContract.call(void 0, {
       address,
-      abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+      abi: _chunkPZEHAYIUcjs.STAKING_ABI,
       client: publicClient
     });
   };
@@ -1669,11 +1817,11 @@ var stakingActions = (client, publicClient) => {
       const amount = parseStakingAmount(options.amount);
       const stakingAddress = getStakingAddress();
       const data = options.operator ? _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+        abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "validatorJoin",
         args: [options.operator]
       }) : _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+        abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "validatorJoin"
       });
       const result = await executeWrite({ to: stakingAddress, data, value: amount });
@@ -1682,7 +1830,7 @@ var stakingActions = (client, publicClient) => {
       let eventFound = false;
       for (const log of receipt.logs) {
         try {
-          const decoded = _viem.decodeEventLog.call(void 0, { abi: _chunkNOMVZBCRcjs.STAKING_ABI, data: log.data, topics: log.topics });
+          const decoded = _viem.decodeEventLog.call(void 0, { abi: _chunkPZEHAYIUcjs.STAKING_ABI, data: log.data, topics: log.topics });
           if (decoded.eventName === "ValidatorJoin") {
             validatorWallet = decoded.args.validator;
             eventFound = true;
@@ -1710,7 +1858,7 @@ var stakingActions = (client, publicClient) => {
     validatorDeposit: async (options) => {
       const amount = parseStakingAmount(options.amount);
       const data = _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+        abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "validatorDeposit"
       });
       return executeWrite({ to: getStakingAddress(), data, value: amount });
@@ -1719,7 +1867,7 @@ var stakingActions = (client, publicClient) => {
     validatorExit: async (options) => {
       const shares = typeof options.shares === "string" ? BigInt(options.shares) : options.shares;
       const data = _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+        abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "validatorExit",
         args: [shares]
       });
@@ -1727,12 +1875,12 @@ var stakingActions = (client, publicClient) => {
     },
     /** Claims pending validator withdrawals. */
     validatorClaim: async (options) => {
-      if (!_optionalChain([options, 'optionalAccess', _124 => _124.validator]) && !client.account) {
+      if (!_optionalChain([options, 'optionalAccess', _148 => _148.validator]) && !client.account) {
         throw new Error("Either provide validator address or initialize client with an account");
       }
-      const validatorAddress = _optionalChain([options, 'optionalAccess', _125 => _125.validator]) || client.account.address;
+      const validatorAddress = _optionalChain([options, 'optionalAccess', _149 => _149.validator]) || client.account.address;
       const data = _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+        abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "validatorClaim",
         args: [validatorAddress]
       });
@@ -1742,7 +1890,7 @@ var stakingActions = (client, publicClient) => {
     /** Primes a validator for participation in the next epoch. */
     validatorPrime: async (options) => {
       const data = _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+        abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "validatorPrime",
         args: [options.validator]
       });
@@ -1751,7 +1899,7 @@ var stakingActions = (client, publicClient) => {
     /** Sets the operator address for a validator wallet. */
     setOperator: async (options) => {
       const data = _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.VALIDATOR_WALLET_ABI,
+        abi: _chunkPZEHAYIUcjs.VALIDATOR_WALLET_ABI,
         functionName: "setOperator",
         args: [options.operator]
       });
@@ -1768,7 +1916,7 @@ var stakingActions = (client, publicClient) => {
         }
       }
       const data = _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.VALIDATOR_WALLET_ABI,
+        abi: _chunkPZEHAYIUcjs.VALIDATOR_WALLET_ABI,
         functionName: "setIdentity",
         args: [
           options.moniker,
@@ -1788,7 +1936,7 @@ var stakingActions = (client, publicClient) => {
     delegatorJoin: async (options) => {
       const amount = parseStakingAmount(options.amount);
       const data = _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+        abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "delegatorJoin",
         args: [options.validator]
       });
@@ -1805,7 +1953,7 @@ var stakingActions = (client, publicClient) => {
     delegatorExit: async (options) => {
       const shares = typeof options.shares === "string" ? BigInt(options.shares) : options.shares;
       const data = _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+        abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "delegatorExit",
         args: [options.validator, shares]
       });
@@ -1818,7 +1966,7 @@ var stakingActions = (client, publicClient) => {
       }
       const delegatorAddress = options.delegator || client.account.address;
       const data = _viem.encodeFunctionData.call(void 0, {
-        abi: _chunkNOMVZBCRcjs.STAKING_ABI,
+        abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "delegatorClaim",
         args: [delegatorAddress, options.validator]
       });
@@ -1838,7 +1986,7 @@ var stakingActions = (client, publicClient) => {
       }
       const walletContract = _viem.getContract.call(void 0, {
         address: validator,
-        abi: _chunkNOMVZBCRcjs.VALIDATOR_WALLET_ABI,
+        abi: _chunkPZEHAYIUcjs.VALIDATOR_WALLET_ABI,
         client: publicClient
       });
       const [view, owner, operator, identityRaw, currentEpoch] = await Promise.all([
@@ -2155,8 +2303,8 @@ var getCustomTransportConfig = (config, chainConfig) => {
     }
   };
 };
-var createClient = (config = { chain: _chunkNOMVZBCRcjs.localnet }) => {
-  const chainConfig = config.chain || _chunkNOMVZBCRcjs.localnet;
+var createClient = (config = { chain: _chunkPZEHAYIUcjs.localnet }) => {
+  const chainConfig = config.chain || _chunkPZEHAYIUcjs.localnet;
   if (config.endpoint) {
     chainConfig.rpcUrls.default.http = [config.endpoint];
   }
@@ -2293,4 +2441,4 @@ function validateValueAgainstType(value, type) {
 
 
 
-exports.abi = abi_exports; exports.buildGenVmPositionalArgs = buildGenVmPositionalArgs; exports.chains = _chunkNOMVZBCRcjs.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;
+exports.abi = abi_exports; exports.buildGenVmPositionalArgs = buildGenVmPositionalArgs; exports.chains = _chunkPZEHAYIUcjs.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;