genlayer-js 0.28.4 → 0.28.5

package/dist/{index-DDgbU3hK.d.ts → index-BpBLcwxn.d.ts}

@@ -2916,6 +2916,14 @@ type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<Client<Transpor
         txId: `0x${string}`;
         value?: bigint;
     }) => Promise<any>;
+    finalizeTransaction: (args: {
+        account?: Account;
+        txId: `0x${string}`;
+    }) => Promise<`0x${string}`>;
+    finalizeIdlenessTxs: (args: {
+        account?: Account;
+        txIds: readonly `0x${string}`[];
+    }) => Promise<`0x${string}`>;
     getMinAppealBond: (args: {
         txId: `0x${string}`;
     }) => Promise<bigint>;

package/dist/{index-DQCfqVjw.d.cts → index-D3H572Cz.d.cts}

@@ -2916,6 +2916,14 @@ type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<Client<Transpor
         txId: `0x${string}`;
         value?: bigint;
     }) => Promise<any>;
+    finalizeTransaction: (args: {
+        account?: Account;
+        txId: `0x${string}`;
+    }) => Promise<`0x${string}`>;
+    finalizeIdlenessTxs: (args: {
+        account?: Account;
+        txIds: readonly `0x${string}`[];
+    }) => Promise<`0x${string}`>;
     getMinAppealBond: (args: {
         txId: `0x${string}`;
     }) => Promise<bigint>;

package/dist/index.cjs

@@ -792,60 +792,52 @@ var contractActions = (client, publicClient) => {
       }
       const senderAccount = account || client.account;
       const encodedData = _encodeSubmitAppealData({ client, txId });
-      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
-        });
-      } 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,
+      await _sendConsensusCall({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
         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}`);
-        }
-      }
+        operationName: "Appeal"
+      });
       return txId;
+    },
+    /** Finalizes a single GenLayer transaction that is ready to be finalized. Returns the EVM transaction hash. */
+    finalizeTransaction: async (args) => {
+      const { account, txId } = args;
+      const senderAccount = account || client.account;
+      const encodedData = _viem.encodeFunctionData.call(void 0, {
+        abi: _optionalChain([client, 'access', _35 => _35.chain, 'access', _36 => _36.consensusMainContract, 'optionalAccess', _37 => _37.abi]),
+        functionName: "finalizeTransaction",
+        args: [txId]
+      });
+      return _sendConsensusCall({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
+        operationName: "Finalize"
+      });
+    },
+    /** Batch-finalizes idle GenLayer transactions (those stuck without progressing). Returns the EVM transaction hash. */
+    finalizeIdlenessTxs: async (args) => {
+      const { account, txIds } = args;
+      if (txIds.length === 0) {
+        throw new Error("finalizeIdlenessTxs requires at least one txId.");
+      }
+      const senderAccount = account || client.account;
+      const encodedData = _viem.encodeFunctionData.call(void 0, {
+        abi: _optionalChain([client, 'access', _38 => _38.chain, 'access', _39 => _39.consensusMainContract, 'optionalAccess', _40 => _40.abi]),
+        functionName: "finalizeIdlenessTxs",
+        args: [txIds]
+      });
+      return _sendConsensusCall({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
+        operationName: "Finalize idleness"
+      });
     }
   };
 };
@@ -910,7 +902,7 @@ var getAddTransactionInputCount = (abi) => {
     const candidate = item;
     return candidate.type === "function" && candidate.name === "addTransaction";
   });
-  return Array.isArray(_optionalChain([addTransactionFunction, 'optionalAccess', _38 => _38.inputs])) ? addTransactionFunction.inputs.length : 0;
+  return Array.isArray(_optionalChain([addTransactionFunction, 'optionalAccess', _41 => _41.inputs])) ? addTransactionFunction.inputs.length : 0;
 };
 var _encodeAddTransactionData = ({
   client,
@@ -937,7 +929,7 @@ var _encodeAddTransactionData = ({
     functionName: "addTransaction",
     args: [...addTransactionArgs, 0n]
   });
-  if (getAddTransactionInputCount(_optionalChain([client, 'access', _39 => _39.chain, 'access', _40 => _40.consensusMainContract, 'optionalAccess', _41 => _41.abi])) >= 6) {
+  if (getAddTransactionInputCount(_optionalChain([client, 'access', _42 => _42.chain, 'access', _43 => _43.consensusMainContract, 'optionalAccess', _44 => _44.abi])) >= 6) {
     return {
       primaryEncodedData: encodedDataV6,
       fallbackEncodedData: encodedDataV5
@@ -953,11 +945,74 @@ var _encodeSubmitAppealData = ({
   txId
 }) => {
   return _viem.encodeFunctionData.call(void 0, {
-    abi: _optionalChain([client, 'access', _42 => _42.chain, 'access', _43 => _43.consensusMainContract, 'optionalAccess', _44 => _44.abi]),
+    abi: _optionalChain([client, 'access', _45 => _45.chain, 'access', _46 => _46.consensusMainContract, 'optionalAccess', _47 => _47.abi]),
     functionName: "submitAppeal",
     args: [txId]
   });
 };
+var _sendConsensusCall = async ({
+  client,
+  publicClient,
+  encodedData,
+  senderAccount,
+  value = 0n,
+  operationName = "Consensus call"
+}) => {
+  if (!_optionalChain([client, 'access', _48 => _48.chain, 'access', _49 => _49.consensusMainContract, 'optionalAccess', _50 => _50.address])) {
+    throw new Error("Consensus main contract not initialized.");
+  }
+  const validatedAccount = validateAccount(senderAccount);
+  const nonce = await client.getCurrentNonce({ address: validatedAccount.address });
+  let estimatedGas;
+  try {
+    estimatedGas = await client.estimateTransactionGas({
+      to: client.chain.consensusMainContract.address,
+      data: encodedData,
+      value
+    });
+  } catch (err) {
+    console.error("Gas estimation failed, using default 200_000:", err);
+    estimatedGas = 200000n;
+  }
+  const gasPriceHex = await client.request({ method: "eth_gasPrice" });
+  if (validatedAccount.type === "local") {
+    if (!validatedAccount.signTransaction) {
+      throw new Error("Local account does not support signTransaction.");
+    }
+    const txRequest = {
+      account: validatedAccount,
+      to: client.chain.consensusMainContract.address,
+      data: encodedData,
+      value,
+      gas: estimatedGas,
+      gasPrice: BigInt(gasPriceHex),
+      nonce,
+      chainId: client.chain.id
+    };
+    const serializedTransaction = await validatedAccount.signTransaction(txRequest);
+    const evmHash2 = await client.sendRawTransaction({ serializedTransaction });
+    const receipt2 = await publicClient.waitForTransactionReceipt({ hash: evmHash2 });
+    if (receipt2.status === "reverted") {
+      throw new Error(`${operationName} reverted: EVM tx ${evmHash2}`);
+    }
+    return evmHash2;
+  }
+  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(`${operationName} reverted: EVM tx ${evmHash}`);
+  }
+  return evmHash;
+};
 var isAddTransactionAbiMismatchError = (error) => {
   const seen = /* @__PURE__ */ new WeakSet();
   const serializedError = typeof error === "object" && error !== null ? JSON.stringify(error, (_key, value) => {
@@ -974,9 +1029,9 @@ var isAddTransactionAbiMismatchError = (error) => {
   }) : "";
   const errorObject = error;
   const errorMessage = [
-    _optionalChain([errorObject, 'optionalAccess', _45 => _45.shortMessage]),
-    _optionalChain([errorObject, 'optionalAccess', _46 => _46.details]),
-    _optionalChain([errorObject, 'optionalAccess', _47 => _47.message]),
+    _optionalChain([errorObject, 'optionalAccess', _51 => _51.shortMessage]),
+    _optionalChain([errorObject, 'optionalAccess', _52 => _52.details]),
+    _optionalChain([errorObject, 'optionalAccess', _53 => _53.message]),
     serializedError,
     String(_nullishCoalesce(error, () => ( "")))
   ].filter(Boolean).join(" ").toLowerCase();
@@ -984,7 +1039,7 @@ var isAddTransactionAbiMismatchError = (error) => {
 };
 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]),
+    abi: _optionalChain([client, 'access', _54 => _54.chain, 'access', _55 => _55.consensusMainContract, 'optionalAccess', _56 => _56.abi]),
     eventName: "NewTransaction",
     logs
   });
@@ -1009,7 +1064,7 @@ var _sendTransaction = async ({
   senderAccount,
   value = 0n
 }) => {
-  if (!_optionalChain([client, 'access', _51 => _51.chain, 'access', _52 => _52.consensusMainContract, 'optionalAccess', _53 => _53.address])) {
+  if (!_optionalChain([client, 'access', _57 => _57.chain, 'access', _58 => _58.consensusMainContract, 'optionalAccess', _59 => _59.address])) {
     throw new Error(`Consensus main contract address not found in chain config for "${client.chain.name}".`);
   }
   const validatedSenderAccount = validateAccount(senderAccount);
@@ -1019,7 +1074,7 @@ var _sendTransaction = async ({
     try {
       estimatedGas = await client.estimateTransactionGas({
         from: validatedSenderAccount.address,
-        to: _optionalChain([client, 'access', _54 => _54.chain, 'access', _55 => _55.consensusMainContract, 'optionalAccess', _56 => _56.address]),
+        to: _optionalChain([client, 'access', _60 => _60.chain, 'access', _61 => _61.consensusMainContract, 'optionalAccess', _62 => _62.address]),
         data: encodedDataForSend,
         value
       });
@@ -1027,8 +1082,8 @@ var _sendTransaction = async ({
       console.error("Gas estimation failed, using default 200_000:", err);
       estimatedGas = 200000n;
     }
-    if (_optionalChain([validatedSenderAccount, 'optionalAccess', _57 => _57.type]) === "local") {
-      if (!_optionalChain([validatedSenderAccount, 'optionalAccess', _58 => _58.signTransaction])) {
+    if (_optionalChain([validatedSenderAccount, 'optionalAccess', _63 => _63.type]) === "local") {
+      if (!_optionalChain([validatedSenderAccount, 'optionalAccess', _64 => _64.signTransaction])) {
         throw new Error("Local account does not support signTransaction. Use a private key account created via privateKeyToAccount().");
       }
       const gasPriceHex2 = await client.request({
@@ -1036,7 +1091,7 @@ var _sendTransaction = async ({
       });
       const transactionRequest = {
         account: validatedSenderAccount,
-        to: _optionalChain([client, 'access', _59 => _59.chain, 'access', _60 => _60.consensusMainContract, 'optionalAccess', _61 => _61.address]),
+        to: _optionalChain([client, 'access', _65 => _65.chain, 'access', _66 => _66.consensusMainContract, 'optionalAccess', _67 => _67.address]),
         data: encodedDataForSend,
         type: "legacy",
         nonce: Number(nonce),
@@ -1049,7 +1104,7 @@ 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: EVM tx ${txHash} to consensus contract ${_optionalChain([client, 'access', _62 => _62.chain, 'access', _63 => _63.consensusMainContract, 'optionalAccess', _64 => _64.address])} was reverted.`);
+        throw new Error(`Transaction reverted: EVM tx ${txHash} to consensus contract ${_optionalChain([client, 'access', _68 => _68.chain, 'access', _69 => _69.consensusMainContract, 'optionalAccess', _70 => _70.address])} was reverted.`);
       }
       const txId = extractTxIdFromLogs(client, receipt.logs);
       if (!txId) {
@@ -1073,7 +1128,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', _65 => _65.chain, 'access', _66 => _66.consensusMainContract, 'optionalAccess', _67 => _67.address]),
+      to: _optionalChain([client, 'access', _71 => _71.chain, 'access', _72 => _72.consensusMainContract, 'optionalAccess', _73 => _73.address]),
       data: encodedDataForSend,
       value: `0x${value.toString(16)}`,
       gas: `0x${estimatedGas.toString(16)}`,
@@ -1092,7 +1147,7 @@ var _sendTransaction = async ({
     }
     const externalReceipt = await publicClient.waitForTransactionReceipt({ hash: evmTxHash });
     if (externalReceipt.status === "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.`);
+      throw new Error(`Transaction reverted: EVM tx ${evmTxHash} to consensus contract ${_optionalChain([client, 'access', _74 => _74.chain, 'access', _75 => _75.consensusMainContract, 'optionalAccess', _76 => _76.address])} was reverted.`);
     }
     const externalTxId = extractTxIdFromLogs(client, externalReceipt.logs);
     if (!externalTxId) {
@@ -1217,7 +1272,7 @@ var decodeTransaction = (tx) => {
     txData,
     txDataDecoded,
     currentTimestamp: tx.currentTimestamp.toString(),
-    numOfInitialValidators: _nullishCoalesce(_optionalChain([numOfInitialValidators, 'optionalAccess', _71 => _71.toString, 'call', _72 => _72()]), () => ( "0")),
+    numOfInitialValidators: _nullishCoalesce(_optionalChain([numOfInitialValidators, 'optionalAccess', _77 => _77.toString, 'call', _78 => _78()]), () => ( "0")),
     txSlot: tx.txSlot.toString(),
     createdTimestamp: tx.createdTimestamp.toString(),
     lastVoteTimestamp: tx.lastVoteTimestamp.toString(),
@@ -1225,9 +1280,9 @@ var decodeTransaction = (tx) => {
     numOfRounds: tx.numOfRounds.toString(),
     readStateBlockRange: {
       ...tx.readStateBlockRange,
-      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"))
+      activationBlock: _nullishCoalesce(_optionalChain([tx, 'access', _79 => _79.readStateBlockRange, 'optionalAccess', _80 => _80.activationBlock, 'optionalAccess', _81 => _81.toString, 'call', _82 => _82()]), () => ( "0")),
+      processingBlock: _nullishCoalesce(_optionalChain([tx, 'access', _83 => _83.readStateBlockRange, 'optionalAccess', _84 => _84.processingBlock, 'optionalAccess', _85 => _85.toString, 'call', _86 => _86()]), () => ( "0")),
+      proposalBlock: _nullishCoalesce(_optionalChain([tx, 'access', _87 => _87.readStateBlockRange, 'optionalAccess', _88 => _88.proposalBlock, 'optionalAccess', _89 => _89.toString, 'call', _90 => _90()]), () => ( "0"))
     },
     statusName: _chunkGJXSECNHcjs.transactionsStatusNumberToName[String(tx.status)],
     resultName: _chunkGJXSECNHcjs.transactionResultNumberToName[String(tx.result)],
@@ -1235,13 +1290,13 @@ var decodeTransaction = (tx) => {
     txExecutionResultName: tx.txExecutionResult !== void 0 ? _chunkGJXSECNHcjs.executionResultNumberToName[String(tx.txExecutionResult)] : void 0,
     lastRound: {
       ...tx.lastRound,
-      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(
+      round: _nullishCoalesce(_optionalChain([tx, 'access', _91 => _91.lastRound, 'optionalAccess', _92 => _92.round, 'optionalAccess', _93 => _93.toString, 'call', _94 => _94()]), () => ( "0")),
+      leaderIndex: _nullishCoalesce(_optionalChain([tx, 'access', _95 => _95.lastRound, 'optionalAccess', _96 => _96.leaderIndex, 'optionalAccess', _97 => _97.toString, 'call', _98 => _98()]), () => ( "0")),
+      votesCommitted: _nullishCoalesce(_optionalChain([tx, 'access', _99 => _99.lastRound, 'optionalAccess', _100 => _100.votesCommitted, 'optionalAccess', _101 => _101.toString, 'call', _102 => _102()]), () => ( "0")),
+      votesRevealed: _nullishCoalesce(_optionalChain([tx, 'access', _103 => _103.lastRound, 'optionalAccess', _104 => _104.votesRevealed, 'optionalAccess', _105 => _105.toString, 'call', _106 => _106()]), () => ( "0")),
+      appealBond: _nullishCoalesce(_optionalChain([tx, 'access', _107 => _107.lastRound, 'optionalAccess', _108 => _108.appealBond, 'optionalAccess', _109 => _109.toString, 'call', _110 => _110()]), () => ( "0")),
+      rotationsLeft: _nullishCoalesce(_optionalChain([tx, 'access', _111 => _111.lastRound, 'optionalAccess', _112 => _112.rotationsLeft, 'optionalAccess', _113 => _113.toString, 'call', _114 => _114()]), () => ( "0")),
+      validatorVotesName: (_nullishCoalesce(_optionalChain([tx, 'access', _115 => _115.lastRound, 'optionalAccess', _116 => _116.validatorVotes]), () => ( []))).map(
         (vote) => _chunkGJXSECNHcjs.voteTypeNumberToName[String(vote)]
       )
     }
@@ -1323,7 +1378,7 @@ var simplifyTransactionReceipt = (tx) => {
 var decodeLocalnetTransaction = (tx) => {
   if (!tx.data) return tx;
   try {
-    const leaderReceipt = _optionalChain([tx, 'access', _111 => _111.consensus_data, 'optionalAccess', _112 => _112.leader_receipt]);
+    const leaderReceipt = _optionalChain([tx, 'access', _117 => _117.consensus_data, 'optionalAccess', _118 => _118.leader_receipt]);
     if (leaderReceipt) {
       const receipts = Array.isArray(leaderReceipt) ? leaderReceipt : [leaderReceipt];
       receipts.forEach((receipt) => {
@@ -1354,7 +1409,7 @@ var decodeLocalnetTransaction = (tx) => {
         }
       });
     }
-    if (_optionalChain([tx, 'access', _113 => _113.data, 'optionalAccess', _114 => _114.calldata]) && typeof tx.data.calldata === "string") {
+    if (_optionalChain([tx, 'access', _119 => _119.data, 'optionalAccess', _120 => _120.calldata]) && typeof tx.data.calldata === "string") {
       tx.data.calldata = {
         base64: tx.data.calldata,
         ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
@@ -1417,8 +1472,8 @@ var transactionActions = (client, publicClient) => ({
       transaction2.statusName = localnetStatus;
       return decodeLocalnetTransaction(transaction2);
     }
-    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 contractAddress = _optionalChain([client, 'access', _121 => _121.chain, 'access', _122 => _122.consensusDataContract, 'optionalAccess', _123 => _123.address]);
+    const contractAbi = _optionalChain([client, 'access', _124 => _124.chain, 'access', _125 => _125.consensusDataContract, 'optionalAccess', _126 => _126.abi]);
     const [txDataRaw, allDataRaw] = await Promise.all([
       publicClient.readContract({
         address: contractAddress,
@@ -1448,12 +1503,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', _121 => _121.readStateBlockRange, 'optionalAccess', _122 => _122.proposalBlock]), () => ( "0")));
+    const proposalBlock = BigInt(_nullishCoalesce(_optionalChain([tx, 'access', _127 => _127.readStateBlockRange, 'optionalAccess', _128 => _128.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', _123 => _123.chain, 'access', _124 => _124.consensusMainContract, 'optionalAccess', _125 => _125.address]);
+    const consensusAddress = _optionalChain([client, 'access', _129 => _129.chain, 'access', _130 => _130.consensusMainContract, 'optionalAccess', _131 => _131.address]);
     const internalMessageProcessedTopic = _viem.keccak256.call(void 0, _viem.stringToBytes.call(void 0, "InternalMessageProcessed(bytes32,address,address)"));
     const logs = await publicClient.getLogs({
       address: consensusAddress,
@@ -1502,8 +1557,8 @@ var transactionActions = (client, publicClient) => ({
   },
   /** 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 consensusAddress = _optionalChain([client, 'access', _132 => _132.chain, 'access', _133 => _133.consensusMainContract, 'optionalAccess', _134 => _134.address]);
+    const consensusAbi = _optionalChain([client, 'access', _135 => _135.chain, 'access', _136 => _136.consensusMainContract, 'optionalAccess', _137 => _137.abi]);
     const queuesAddress = await publicClient.readContract({
       address: consensusAddress,
       abi: consensusAbi,
@@ -1529,7 +1584,7 @@ var transactionActions = (client, publicClient) => ({
   /** Estimates gas required for a transaction. */
   estimateTransactionGas: async (transactionParams) => {
     const formattedParams = {
-      from: transactionParams.from || _optionalChain([client, 'access', _132 => _132.account, 'optionalAccess', _133 => _133.address]),
+      from: transactionParams.from || _optionalChain([client, 'access', _138 => _138.account, 'optionalAccess', _139 => _139.address]),
       to: transactionParams.to,
       data: transactionParams.data || "0x",
       value: transactionParams.value ? `0x${transactionParams.value.toString(16)}` : "0x0"
@@ -1572,7 +1627,7 @@ var connect = async (client, network = "studionet", snapSource = "npm") => {
     chainName: selectedNetwork.name,
     rpcUrls: selectedNetwork.rpcUrls.default.http,
     nativeCurrency: selectedNetwork.nativeCurrency,
-    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _134 => _134.blockExplorers, 'optionalAccess', _135 => _135.default, 'access', _136 => _136.url])]
+    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _140 => _140.blockExplorers, 'optionalAccess', _141 => _141.default, 'access', _142 => _142.url])]
   };
   const currentChainId = await window.ethereum.request({ method: "eth_chainId" });
   if (currentChainId !== chainIdHex) {
@@ -1606,10 +1661,10 @@ var metamaskClient = async (snapSource = "npm") => {
   }
   const isFlask = async () => {
     try {
-      const clientVersion = await _optionalChain([window, 'access', _137 => _137.ethereum, 'optionalAccess', _138 => _138.request, 'call', _139 => _139({
+      const clientVersion = await _optionalChain([window, 'access', _143 => _143.ethereum, 'optionalAccess', _144 => _144.request, 'call', _145 => _145({
         method: "web3_clientVersion"
       })]);
-      return _optionalChain([clientVersion, 'optionalAccess', _140 => _140.includes, 'call', _141 => _141("flask")]);
+      return _optionalChain([clientVersion, 'optionalAccess', _146 => _146.includes, 'call', _147 => _147("flask")]);
     } catch (error) {
       console.error("Error detecting Flask:", error);
       return false;
@@ -1617,7 +1672,7 @@ var metamaskClient = async (snapSource = "npm") => {
   };
   const installedSnaps = async () => {
     try {
-      return await _optionalChain([window, 'access', _142 => _142.ethereum, 'optionalAccess', _143 => _143.request, 'call', _144 => _144({
+      return await _optionalChain([window, 'access', _148 => _148.ethereum, 'optionalAccess', _149 => _149.request, 'call', _150 => _150({
         method: "wallet_getSnaps"
       })]);
     } catch (error) {
@@ -1704,7 +1759,7 @@ function extractRevertReason(err) {
     }
     const revertError = err.walk((e) => e instanceof _viem.ContractFunctionRevertedError);
     if (revertError instanceof _viem.ContractFunctionRevertedError) {
-      if (_optionalChain([revertError, 'access', _145 => _145.data, 'optionalAccess', _146 => _146.errorName])) {
+      if (_optionalChain([revertError, 'access', _151 => _151.data, 'optionalAccess', _152 => _152.errorName])) {
         return revertError.data.errorName;
       }
       return revertError.reason || "Unknown reason";
@@ -1792,7 +1847,7 @@ var stakingActions = (client, publicClient) => {
   };
   const getStakingAddress = () => {
     const stakingConfig = client.chain.stakingContract;
-    if (!_optionalChain([stakingConfig, 'optionalAccess', _147 => _147.address]) || stakingConfig.address === "0x0000000000000000000000000000000000000000") {
+    if (!_optionalChain([stakingConfig, 'optionalAccess', _153 => _153.address]) || stakingConfig.address === "0x0000000000000000000000000000000000000000") {
       throw new Error("Staking is not supported on studio-based networks. Use testnet-asimov for staking operations.");
     }
     return stakingConfig.address;
@@ -1877,10 +1932,10 @@ var stakingActions = (client, publicClient) => {
     },
     /** Claims pending validator withdrawals. */
     validatorClaim: async (options) => {
-      if (!_optionalChain([options, 'optionalAccess', _148 => _148.validator]) && !client.account) {
+      if (!_optionalChain([options, 'optionalAccess', _154 => _154.validator]) && !client.account) {
         throw new Error("Either provide validator address or initialize client with an account");
       }
-      const validatorAddress = _optionalChain([options, 'optionalAccess', _149 => _149.validator]) || client.account.address;
+      const validatorAddress = _optionalChain([options, 'optionalAccess', _155 => _155.validator]) || client.account.address;
       const data = _viem.encodeFunctionData.call(void 0, {
         abi: _chunkPZEHAYIUcjs.STAKING_ABI,
         functionName: "validatorClaim",

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as viem from 'viem';
 import { Account, Address, Hex } from 'viem';
 import { G as GenLayerChain } from './chains-D6DgvIVA.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, d as ContractSchema } from './index-DQCfqVjw.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, d as ContractSchema } from './index-D3H572Cz.cjs';
 import * as abitype from 'abitype';
 import * as viem__types_types_authorization from 'viem/_types/types/authorization';
 import * as viem_accounts from 'viem/accounts';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as viem from 'viem';
 import { Account, Address, Hex } from 'viem';
 import { G as GenLayerChain } from './chains-D6DgvIVA.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, d as ContractSchema } from './index-DDgbU3hK.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, d as ContractSchema } from './index-BpBLcwxn.js';
 import * as abitype from 'abitype';
 import * as viem__types_types_authorization from 'viem/_types/types/authorization';
 import * as viem_accounts from 'viem/accounts';

package/dist/index.js

@@ -792,60 +792,52 @@ var contractActions = (client, publicClient) => {
       }
       const senderAccount = account || client.account;
       const encodedData = _encodeSubmitAppealData({ client, txId });
-      const validatedAccount = validateAccount(senderAccount);
-      if (!client.chain.consensusMainContract?.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
-        });
-      } 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,
+      await _sendConsensusCall({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
         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}`);
-        }
-      }
+        operationName: "Appeal"
+      });
       return txId;
+    },
+    /** Finalizes a single GenLayer transaction that is ready to be finalized. Returns the EVM transaction hash. */
+    finalizeTransaction: async (args) => {
+      const { account, txId } = args;
+      const senderAccount = account || client.account;
+      const encodedData = encodeFunctionData({
+        abi: client.chain.consensusMainContract?.abi,
+        functionName: "finalizeTransaction",
+        args: [txId]
+      });
+      return _sendConsensusCall({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
+        operationName: "Finalize"
+      });
+    },
+    /** Batch-finalizes idle GenLayer transactions (those stuck without progressing). Returns the EVM transaction hash. */
+    finalizeIdlenessTxs: async (args) => {
+      const { account, txIds } = args;
+      if (txIds.length === 0) {
+        throw new Error("finalizeIdlenessTxs requires at least one txId.");
+      }
+      const senderAccount = account || client.account;
+      const encodedData = encodeFunctionData({
+        abi: client.chain.consensusMainContract?.abi,
+        functionName: "finalizeIdlenessTxs",
+        args: [txIds]
+      });
+      return _sendConsensusCall({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
+        operationName: "Finalize idleness"
+      });
     }
   };
 };
@@ -958,6 +950,69 @@ var _encodeSubmitAppealData = ({
     args: [txId]
   });
 };
+var _sendConsensusCall = async ({
+  client,
+  publicClient,
+  encodedData,
+  senderAccount,
+  value = 0n,
+  operationName = "Consensus call"
+}) => {
+  if (!client.chain.consensusMainContract?.address) {
+    throw new Error("Consensus main contract not initialized.");
+  }
+  const validatedAccount = validateAccount(senderAccount);
+  const nonce = await client.getCurrentNonce({ address: validatedAccount.address });
+  let estimatedGas;
+  try {
+    estimatedGas = await client.estimateTransactionGas({
+      to: client.chain.consensusMainContract.address,
+      data: encodedData,
+      value
+    });
+  } catch (err) {
+    console.error("Gas estimation failed, using default 200_000:", err);
+    estimatedGas = 200000n;
+  }
+  const gasPriceHex = await client.request({ method: "eth_gasPrice" });
+  if (validatedAccount.type === "local") {
+    if (!validatedAccount.signTransaction) {
+      throw new Error("Local account does not support signTransaction.");
+    }
+    const txRequest = {
+      account: validatedAccount,
+      to: client.chain.consensusMainContract.address,
+      data: encodedData,
+      value,
+      gas: estimatedGas,
+      gasPrice: BigInt(gasPriceHex),
+      nonce,
+      chainId: client.chain.id
+    };
+    const serializedTransaction = await validatedAccount.signTransaction(txRequest);
+    const evmHash2 = await client.sendRawTransaction({ serializedTransaction });
+    const receipt2 = await publicClient.waitForTransactionReceipt({ hash: evmHash2 });
+    if (receipt2.status === "reverted") {
+      throw new Error(`${operationName} reverted: EVM tx ${evmHash2}`);
+    }
+    return evmHash2;
+  }
+  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(`${operationName} reverted: EVM tx ${evmHash}`);
+  }
+  return evmHash;
+};
 var isAddTransactionAbiMismatchError = (error) => {
   const seen = /* @__PURE__ */ new WeakSet();
   const serializedError = typeof error === "object" && error !== null ? JSON.stringify(error, (_key, value) => {

package/dist/types/index.d.cts

@@ -1,3 +1,3 @@
 export { Account, Address } from 'viem';
-export { O as BannedValidatorInfo, e as CalldataAddress, C as CalldataEncodable, j as ContractMethod, i as ContractMethodBase, g as ContractParamsArraySchemaElement, h as ContractParamsSchema, d as ContractSchema, o as DECIDED_STATES, z as DebugTraceResult, a as DecodedCallData, D as DecodedDeployData, a7 as DelegatorClaimOptions, a6 as DelegatorExitOptions, a5 as DelegatorJoinOptions, Z as DelegatorJoinResult, R as EpochData, U as EpochInfo, E as ExecutionResult, G as GenLayerClient, f as GenLayerMethod, b as GenLayerRawTransaction, c as GenLayerTransaction, H as Hash, L as LeaderReceipt, M as MethodDescription, N as Network, P as PendingDeposit, K as PendingWithdrawal, a4 as SetIdentityOptions, a3 as SetOperatorOptions, A as SnapSource, Q as StakeInfo, a8 as StakingActions, B as StakingContract, X as StakingTransactionResult, k as TransactionHash, y as TransactionHashVariant, m as TransactionResult, r as TransactionResultNameToNumber, l as TransactionStatus, x as TransactionType, a1 as ValidatorClaimOptions, $ as ValidatorDepositOptions, a0 as ValidatorExitOptions, I as ValidatorIdentity, J as ValidatorInfo, _ as ValidatorJoinOptions, Y as ValidatorJoinResult, a2 as ValidatorPrimeOptions, F as ValidatorView, u as VoteType, W as WithdrawalCommit, s as executionResultNumberToName, p as isDecidedState, q as transactionResultNumberToName, n as transactionsStatusNameToNumber, t as transactionsStatusNumberToName, w as voteTypeNameToNumber, v as voteTypeNumberToName } from '../index-DQCfqVjw.cjs';
+export { O as BannedValidatorInfo, e as CalldataAddress, C as CalldataEncodable, j as ContractMethod, i as ContractMethodBase, g as ContractParamsArraySchemaElement, h as ContractParamsSchema, d as ContractSchema, o as DECIDED_STATES, z as DebugTraceResult, a as DecodedCallData, D as DecodedDeployData, a7 as DelegatorClaimOptions, a6 as DelegatorExitOptions, a5 as DelegatorJoinOptions, Z as DelegatorJoinResult, R as EpochData, U as EpochInfo, E as ExecutionResult, G as GenLayerClient, f as GenLayerMethod, b as GenLayerRawTransaction, c as GenLayerTransaction, H as Hash, L as LeaderReceipt, M as MethodDescription, N as Network, P as PendingDeposit, K as PendingWithdrawal, a4 as SetIdentityOptions, a3 as SetOperatorOptions, A as SnapSource, Q as StakeInfo, a8 as StakingActions, B as StakingContract, X as StakingTransactionResult, k as TransactionHash, y as TransactionHashVariant, m as TransactionResult, r as TransactionResultNameToNumber, l as TransactionStatus, x as TransactionType, a1 as ValidatorClaimOptions, $ as ValidatorDepositOptions, a0 as ValidatorExitOptions, I as ValidatorIdentity, J as ValidatorInfo, _ as ValidatorJoinOptions, Y as ValidatorJoinResult, a2 as ValidatorPrimeOptions, F as ValidatorView, u as VoteType, W as WithdrawalCommit, s as executionResultNumberToName, p as isDecidedState, q as transactionResultNumberToName, n as transactionsStatusNameToNumber, t as transactionsStatusNumberToName, w as voteTypeNameToNumber, v as voteTypeNumberToName } from '../index-D3H572Cz.cjs';
 export { G as GenLayerChain } from '../chains-D6DgvIVA.cjs';

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
 export { Account, Address } from 'viem';
-export { O as BannedValidatorInfo, e as CalldataAddress, C as CalldataEncodable, j as ContractMethod, i as ContractMethodBase, g as ContractParamsArraySchemaElement, h as ContractParamsSchema, d as ContractSchema, o as DECIDED_STATES, z as DebugTraceResult, a as DecodedCallData, D as DecodedDeployData, a7 as DelegatorClaimOptions, a6 as DelegatorExitOptions, a5 as DelegatorJoinOptions, Z as DelegatorJoinResult, R as EpochData, U as EpochInfo, E as ExecutionResult, G as GenLayerClient, f as GenLayerMethod, b as GenLayerRawTransaction, c as GenLayerTransaction, H as Hash, L as LeaderReceipt, M as MethodDescription, N as Network, P as PendingDeposit, K as PendingWithdrawal, a4 as SetIdentityOptions, a3 as SetOperatorOptions, A as SnapSource, Q as StakeInfo, a8 as StakingActions, B as StakingContract, X as StakingTransactionResult, k as TransactionHash, y as TransactionHashVariant, m as TransactionResult, r as TransactionResultNameToNumber, l as TransactionStatus, x as TransactionType, a1 as ValidatorClaimOptions, $ as ValidatorDepositOptions, a0 as ValidatorExitOptions, I as ValidatorIdentity, J as ValidatorInfo, _ as ValidatorJoinOptions, Y as ValidatorJoinResult, a2 as ValidatorPrimeOptions, F as ValidatorView, u as VoteType, W as WithdrawalCommit, s as executionResultNumberToName, p as isDecidedState, q as transactionResultNumberToName, n as transactionsStatusNameToNumber, t as transactionsStatusNumberToName, w as voteTypeNameToNumber, v as voteTypeNumberToName } from '../index-DDgbU3hK.js';
+export { O as BannedValidatorInfo, e as CalldataAddress, C as CalldataEncodable, j as ContractMethod, i as ContractMethodBase, g as ContractParamsArraySchemaElement, h as ContractParamsSchema, d as ContractSchema, o as DECIDED_STATES, z as DebugTraceResult, a as DecodedCallData, D as DecodedDeployData, a7 as DelegatorClaimOptions, a6 as DelegatorExitOptions, a5 as DelegatorJoinOptions, Z as DelegatorJoinResult, R as EpochData, U as EpochInfo, E as ExecutionResult, G as GenLayerClient, f as GenLayerMethod, b as GenLayerRawTransaction, c as GenLayerTransaction, H as Hash, L as LeaderReceipt, M as MethodDescription, N as Network, P as PendingDeposit, K as PendingWithdrawal, a4 as SetIdentityOptions, a3 as SetOperatorOptions, A as SnapSource, Q as StakeInfo, a8 as StakingActions, B as StakingContract, X as StakingTransactionResult, k as TransactionHash, y as TransactionHashVariant, m as TransactionResult, r as TransactionResultNameToNumber, l as TransactionStatus, x as TransactionType, a1 as ValidatorClaimOptions, $ as ValidatorDepositOptions, a0 as ValidatorExitOptions, I as ValidatorIdentity, J as ValidatorInfo, _ as ValidatorJoinOptions, Y as ValidatorJoinResult, a2 as ValidatorPrimeOptions, F as ValidatorView, u as VoteType, W as WithdrawalCommit, s as executionResultNumberToName, p as isDecidedState, q as transactionResultNumberToName, n as transactionsStatusNameToNumber, t as transactionsStatusNumberToName, w as voteTypeNameToNumber, v as voteTypeNumberToName } from '../index-BpBLcwxn.js';
 export { G as GenLayerChain } from '../chains-D6DgvIVA.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "genlayer-js",
   "type": "module",
-  "version": "0.28.4",
+  "version": "0.28.5",
   "description": "GenLayer JavaScript SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",