genlayer-js 0.9.4 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 
 
+## 0.10.0 (2025-05-22)
+
+
+### Features
+
+* adjust submitAppeal call to consensus smart contract ([#80](https://github.com/yeagerai/genlayer-js/issues/80)) ([9e4a88e](https://github.com/yeagerai/genlayer-js/commit/9e4a88ed9a094af067302f8c4aa170c7129bf53d))
+
+## 0.9.5 (2025-05-21)
+
+
+### Bug Fixes
+
+* update readContract with TransactionHashVariant ([#86](https://github.com/yeagerai/genlayer-js/issues/86)) ([7cbeb04](https://github.com/yeagerai/genlayer-js/commit/7cbeb040b55c4bc3acf173bdae51da51deef7a83))
+
 ## 0.9.4 (2025-05-20)
 
 

package/dist/{index-B_gpaVzJ.d.cts → index-BhRfI25e.d.cts}

@@ -323,12 +323,12 @@ type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<Client<Transpor
         account?: Account;
         address: Address;
         functionName: string;
-        stateStatus?: TransactionStatus;
         args?: CalldataEncodable[];
         kwargs?: Map<string, CalldataEncodable> | {
             [key: string]: CalldataEncodable;
         };
         rawReturn?: RawReturn;
+        transactionHashVariant?: TransactionHashVariant;
     }) => Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable>;
     writeContract: (args: {
         account?: Account;
@@ -369,6 +369,10 @@ type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<Client<Transpor
     initializeConsensusSmartContract: (forceReset?: boolean) => Promise<void>;
     connect: (network?: Network, snapSource?: SnapSource) => Promise<void>;
     metamaskClient: (snapSource?: SnapSource) => Promise<MetaMaskClientResult>;
+    appealTransaction: (args: {
+        account?: Account;
+        txId: `0x${string}`;
+    }) => Promise<any>;
 };
 
 export { type CalldataEncodable as C, type DecodedDeployData as D, type GenLayerClient as G, type Hash as H, type MethodDescription as M, type Network as N, type SnapSource as S, type TransactionDataElement as T, VoteType as V, CalldataAddress as a, type GenLayerMethod as b, type ContractParamsArraySchemaElement as c, type ContractParamsSchema as d, type ContractMethodBase as e, type ContractMethod as f, type ContractSchema as g, type TransactionHash as h, TransactionStatus as i, TransactionResult as j, transactionsStatusNameToNumber as k, transactionResultNumberToName as l, TransactionResultNameToNumber as m, voteTypeNameToNumber as n, type TransactionType as o, TransactionHashVariant as p, type DecodedCallData as q, type GenLayerTransaction as r, type GenLayerRawTransaction as s, transactionsStatusNumberToName as t, voteTypeNumberToName as v };

package/dist/{index-to6d0Hzj.d.ts → index-dnt5ldCd.d.ts}

@@ -323,12 +323,12 @@ type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<Client<Transpor
         account?: Account;
         address: Address;
         functionName: string;
-        stateStatus?: TransactionStatus;
         args?: CalldataEncodable[];
         kwargs?: Map<string, CalldataEncodable> | {
             [key: string]: CalldataEncodable;
         };
         rawReturn?: RawReturn;
+        transactionHashVariant?: TransactionHashVariant;
     }) => Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable>;
     writeContract: (args: {
         account?: Account;
@@ -369,6 +369,10 @@ type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<Client<Transpor
     initializeConsensusSmartContract: (forceReset?: boolean) => Promise<void>;
     connect: (network?: Network, snapSource?: SnapSource) => Promise<void>;
     metamaskClient: (snapSource?: SnapSource) => Promise<MetaMaskClientResult>;
+    appealTransaction: (args: {
+        account?: Account;
+        txId: `0x${string}`;
+    }) => Promise<any>;
 };
 
 export { type CalldataEncodable as C, type DecodedDeployData as D, type GenLayerClient as G, type Hash as H, type MethodDescription as M, type Network as N, type SnapSource as S, type TransactionDataElement as T, VoteType as V, CalldataAddress as a, type GenLayerMethod as b, type ContractParamsArraySchemaElement as c, type ContractParamsSchema as d, type ContractMethodBase as e, type ContractMethod as f, type ContractSchema as g, type TransactionHash as h, TransactionStatus as i, TransactionResult as j, transactionsStatusNameToNumber as k, transactionResultNumberToName as l, TransactionResultNameToNumber as m, voteTypeNameToNumber as n, type TransactionType as o, TransactionHashVariant as p, type DecodedCallData as q, type GenLayerTransaction as r, type GenLayerRawTransaction as s, transactionsStatusNumberToName as t, voteTypeNumberToName as v };

package/dist/index.cjs

@@ -472,13 +472,19 @@ var contractActions = (client, publicClient) => {
       } = args;
       const data = [encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
       const serializedData = serialize(data);
-      return _sendTransaction({
+      const senderAccount = account || client.account;
+      const encodedData = _encodeAddTransactionData({
         client,
-        publicClient,
+        senderAccount,
         recipient: address,
         data: serializedData,
-        senderAccount: account || client.account,
-        consensusMaxRotations,
+        consensusMaxRotations
+      });
+      return _sendTransaction({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
         value
       });
     },
@@ -497,55 +503,93 @@ var contractActions = (client, publicClient) => {
         leaderOnly
       ];
       const serializedData = serialize(data);
-      return _sendTransaction({
+      const senderAccount = account || client.account;
+      const encodedData = _encodeAddTransactionData({
         client,
-        publicClient,
+        senderAccount,
         recipient: _viem.zeroAddress,
         data: serializedData,
-        senderAccount: account || client.account,
         consensusMaxRotations
       });
+      return _sendTransaction({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount
+      });
+    },
+    appealTransaction: async (args) => {
+      const { account, txId } = args;
+      const senderAccount = account || client.account;
+      const encodedData = _encodeSubmitAppealData({ client, txId });
+      return _sendTransaction({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount
+      });
     }
   };
 };
-var _sendTransaction = async ({
-  client,
-  publicClient,
-  recipient,
-  data,
-  senderAccount,
-  consensusMaxRotations,
-  value
-}) => {
-  if (!senderAccount) {
+var validateAccount = (Account3) => {
+  if (!Account3) {
     throw new Error(
       "No account set. Configure the client with an account or pass an account to this function."
     );
   }
-  if (!_optionalChain([client, 'access', _8 => _8.chain, 'access', _9 => _9.consensusMainContract, 'optionalAccess', _10 => _10.address])) {
-    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
-  }
-  const encodedData = _viem.encodeFunctionData.call(void 0, {
-    abi: _optionalChain([client, 'access', _11 => _11.chain, 'access', _12 => _12.consensusMainContract, 'optionalAccess', _13 => _13.abi]),
+  return Account3;
+};
+var _encodeAddTransactionData = ({
+  client,
+  senderAccount,
+  recipient,
+  data,
+  consensusMaxRotations = client.chain.defaultConsensusMaxRotations
+}) => {
+  const validatedSenderAccount = validateAccount(senderAccount);
+  return _viem.encodeFunctionData.call(void 0, {
+    abi: _optionalChain([client, 'access', _8 => _8.chain, 'access', _9 => _9.consensusMainContract, 'optionalAccess', _10 => _10.abi]),
     functionName: "addTransaction",
     args: [
-      senderAccount.address,
+      validatedSenderAccount.address,
       recipient,
       client.chain.defaultNumberOfInitialValidators,
       consensusMaxRotations,
       data
     ]
   });
-  const nonce = await client.getCurrentNonce({ address: senderAccount.address });
+};
+var _encodeSubmitAppealData = ({
+  client,
+  txId
+}) => {
+  return _viem.encodeFunctionData.call(void 0, {
+    abi: _optionalChain([client, 'access', _11 => _11.chain, 'access', _12 => _12.consensusMainContract, 'optionalAccess', _13 => _13.abi]),
+    functionName: "submitAppeal",
+    args: [txId]
+  });
+};
+var _sendTransaction = async ({
+  client,
+  publicClient,
+  encodedData,
+  senderAccount,
+  value = 0n
+}) => {
+  if (!_optionalChain([client, 'access', _14 => _14.chain, 'access', _15 => _15.consensusMainContract, 'optionalAccess', _16 => _16.address])) {
+    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
+  }
+  const validatedSenderAccount = validateAccount(senderAccount);
+  const nonce = await client.getCurrentNonce({ address: validatedSenderAccount.address });
   const transactionRequest = await client.prepareTransactionRequest({
-    account: senderAccount,
-    to: _optionalChain([client, 'access', _14 => _14.chain, 'access', _15 => _15.consensusMainContract, 'optionalAccess', _16 => _16.address]),
+    account: validatedSenderAccount,
+    to: _optionalChain([client, 'access', _17 => _17.chain, 'access', _18 => _18.consensusMainContract, 'optionalAccess', _19 => _19.address]),
     data: encodedData,
     type: "legacy",
     nonce: Number(nonce),
-    value: _nullishCoalesce(value, () => ( 0n))
+    value
   });
-  if (_optionalChain([senderAccount, 'optionalAccess', _17 => _17.type]) !== "local") {
+  if (_optionalChain([validatedSenderAccount, 'optionalAccess', _20 => _20.type]) !== "local") {
     const formattedRequest = {
       from: transactionRequest.from,
       to: transactionRequest.to,
@@ -557,17 +601,17 @@ var _sendTransaction = async ({
       params: [formattedRequest]
     });
   }
-  if (!_optionalChain([senderAccount, 'optionalAccess', _18 => _18.signTransaction])) {
+  if (!_optionalChain([validatedSenderAccount, 'optionalAccess', _21 => _21.signTransaction])) {
     throw new Error("Account does not support signTransaction");
   }
-  const serializedTransaction = await senderAccount.signTransaction(transactionRequest);
+  const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest);
   const txHash = await client.sendRawTransaction({ serializedTransaction });
   const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
   if (receipt.status === "reverted") {
     throw new Error("Transaction reverted");
   }
   const newTxEvents = _viem.parseEventLogs.call(void 0, {
-    abi: _optionalChain([client, 'access', _19 => _19.chain, 'access', _20 => _20.consensusMainContract, 'optionalAccess', _21 => _21.abi]),
+    abi: _optionalChain([client, 'access', _22 => _22.chain, 'access', _23 => _23.consensusMainContract, 'optionalAccess', _24 => _24.abi]),
     eventName: "NewTransaction",
     logs: receipt.logs
   });
@@ -683,8 +727,8 @@ var transactionActions = (client, publicClient) => ({
       return _decodeLocalnetTransaction(transaction2);
     }
     const transaction = await publicClient.readContract({
-      address: _optionalChain([client, 'access', _22 => _22.chain, 'access', _23 => _23.consensusDataContract, 'optionalAccess', _24 => _24.address]),
-      abi: _optionalChain([client, 'access', _25 => _25.chain, 'access', _26 => _26.consensusDataContract, 'optionalAccess', _27 => _27.abi]),
+      address: _optionalChain([client, 'access', _25 => _25.chain, 'access', _26 => _26.consensusDataContract, 'optionalAccess', _27 => _27.address]),
+      abi: _optionalChain([client, 'access', _28 => _28.chain, 'access', _29 => _29.consensusDataContract, 'optionalAccess', _30 => _30.abi]),
       functionName: "getTransactionData",
       args: [
         hash,
@@ -772,7 +816,7 @@ var _decodeTransaction = (tx) => {
 var _decodeLocalnetTransaction = (tx) => {
   if (!tx.data) return tx;
   try {
-    const leaderReceipt = _optionalChain([tx, 'access', _28 => _28.consensus_data, 'optionalAccess', _29 => _29.leader_receipt]);
+    const leaderReceipt = _optionalChain([tx, 'access', _31 => _31.consensus_data, 'optionalAccess', _32 => _32.leader_receipt]);
     if (leaderReceipt) {
       if (leaderReceipt.result && typeof leaderReceipt.result === "string") {
         leaderReceipt.result = resultToUserFriendlyJson(leaderReceipt.result);
@@ -792,7 +836,7 @@ var _decodeLocalnetTransaction = (tx) => {
         );
       }
     }
-    if (_optionalChain([tx, 'access', _30 => _30.data, 'optionalAccess', _31 => _31.calldata]) && typeof tx.data.calldata === "string") {
+    if (_optionalChain([tx, 'access', _33 => _33.data, 'optionalAccess', _34 => _34.calldata]) && typeof tx.data.calldata === "string") {
       tx.data.calldata = {
         base64: tx.data.calldata,
         ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
@@ -4845,7 +4889,7 @@ var connect = async (client, network = "studionet", snapSource = "npm") => {
     chainName: selectedNetwork.name,
     rpcUrls: selectedNetwork.rpcUrls.default.http,
     nativeCurrency: selectedNetwork.nativeCurrency,
-    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _32 => _32.blockExplorers, 'optionalAccess', _33 => _33.default, 'access', _34 => _34.url])]
+    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _35 => _35.blockExplorers, 'optionalAccess', _36 => _36.default, 'access', _37 => _37.url])]
   };
   const currentChainId = await window.ethereum.request({ method: "eth_chainId" });
   if (currentChainId !== chainIdHex) {
@@ -4879,10 +4923,10 @@ var metamaskClient = async (snapSource = "npm") => {
   }
   const isFlask = async () => {
     try {
-      const clientVersion = await _optionalChain([window, 'access', _35 => _35.ethereum, 'optionalAccess', _36 => _36.request, 'call', _37 => _37({
+      const clientVersion = await _optionalChain([window, 'access', _38 => _38.ethereum, 'optionalAccess', _39 => _39.request, 'call', _40 => _40({
         method: "web3_clientVersion"
       })]);
-      return _optionalChain([clientVersion, 'optionalAccess', _38 => _38.includes, 'call', _39 => _39("flask")]);
+      return _optionalChain([clientVersion, 'optionalAccess', _41 => _41.includes, 'call', _42 => _42("flask")]);
     } catch (error) {
       console.error("Error detecting Flask:", error);
       return false;
@@ -4890,7 +4934,7 @@ var metamaskClient = async (snapSource = "npm") => {
   };
   const installedSnaps = async () => {
     try {
-      return await _optionalChain([window, 'access', _40 => _40.ethereum, 'optionalAccess', _41 => _41.request, 'call', _42 => _42({
+      return await _optionalChain([window, 'access', _43 => _43.ethereum, 'optionalAccess', _44 => _44.request, 'call', _45 => _45({
         method: "wallet_getSnaps"
       })]);
     } catch (error) {
@@ -4925,10 +4969,10 @@ function walletActions(client) {
 function chainActions(client) {
   return {
     initializeConsensusSmartContract: async (forceReset = false) => {
-      if (_optionalChain([client, 'access', _43 => _43.chain, 'optionalAccess', _44 => _44.id]) === _chunkSMCXL465cjs.testnetAsimov.id) {
+      if (_optionalChain([client, 'access', _46 => _46.chain, 'optionalAccess', _47 => _47.id]) === _chunkSMCXL465cjs.testnetAsimov.id) {
         return;
       }
-      if (!forceReset && _optionalChain([client, 'access', _45 => _45.chain, 'access', _46 => _46.consensusMainContract, 'optionalAccess', _47 => _47.address]) && _optionalChain([client, 'access', _48 => _48.chain, 'access', _49 => _49.consensusMainContract, 'optionalAccess', _50 => _50.abi])) {
+      if (!forceReset && _optionalChain([client, 'access', _48 => _48.chain, 'access', _49 => _49.consensusMainContract, 'optionalAccess', _50 => _50.address]) && _optionalChain([client, 'access', _51 => _51.chain, 'access', _52 => _52.consensusMainContract, 'optionalAccess', _53 => _53.abi])) {
         return;
       }
       const contractsResponse = await fetch(client.chain.rpcUrls.default.http[0], {
@@ -4959,7 +5003,7 @@ var getCustomTransportConfig = (config) => {
     async request({ method, params = [] }) {
       if (method.startsWith("eth_") && isAddress) {
         try {
-          return await _optionalChain([window, 'access', _51 => _51.ethereum, 'optionalAccess', _52 => _52.request, 'call', _53 => _53({ method, params })]);
+          return await _optionalChain([window, 'access', _54 => _54.ethereum, 'optionalAccess', _55 => _55.request, 'call', _56 => _56({ method, params })]);
         } catch (err) {
           console.warn(`Error using window.ethereum for method ${method}:`, err);
           throw err;

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as viem from 'viem';
 import { Account, Address } from 'viem';
 import { G as GenLayerChain } from './chains-BYSCF33g.cjs';
-import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-B_gpaVzJ.cjs';
+import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-BhRfI25e.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 } from 'viem';
 import { G as GenLayerChain } from './chains-BYSCF33g.js';
-import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-to6d0Hzj.js';
+import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-dnt5ldCd.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

@@ -472,13 +472,19 @@ var contractActions = (client, publicClient) => {
       } = args;
       const data = [encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
       const serializedData = serialize(data);
-      return _sendTransaction({
+      const senderAccount = account || client.account;
+      const encodedData = _encodeAddTransactionData({
         client,
-        publicClient,
+        senderAccount,
         recipient: address,
         data: serializedData,
-        senderAccount: account || client.account,
-        consensusMaxRotations,
+        consensusMaxRotations
+      });
+      return _sendTransaction({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
         value
       });
     },
@@ -497,55 +503,93 @@ var contractActions = (client, publicClient) => {
         leaderOnly
       ];
       const serializedData = serialize(data);
-      return _sendTransaction({
+      const senderAccount = account || client.account;
+      const encodedData = _encodeAddTransactionData({
         client,
-        publicClient,
+        senderAccount,
         recipient: zeroAddress,
         data: serializedData,
-        senderAccount: account || client.account,
         consensusMaxRotations
       });
+      return _sendTransaction({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount
+      });
+    },
+    appealTransaction: async (args) => {
+      const { account, txId } = args;
+      const senderAccount = account || client.account;
+      const encodedData = _encodeSubmitAppealData({ client, txId });
+      return _sendTransaction({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount
+      });
     }
   };
 };
-var _sendTransaction = async ({
-  client,
-  publicClient,
-  recipient,
-  data,
-  senderAccount,
-  consensusMaxRotations,
-  value
-}) => {
-  if (!senderAccount) {
+var validateAccount = (Account3) => {
+  if (!Account3) {
     throw new Error(
       "No account set. Configure the client with an account or pass an account to this function."
     );
   }
-  if (!client.chain.consensusMainContract?.address) {
-    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
-  }
-  const encodedData = encodeFunctionData({
+  return Account3;
+};
+var _encodeAddTransactionData = ({
+  client,
+  senderAccount,
+  recipient,
+  data,
+  consensusMaxRotations = client.chain.defaultConsensusMaxRotations
+}) => {
+  const validatedSenderAccount = validateAccount(senderAccount);
+  return encodeFunctionData({
     abi: client.chain.consensusMainContract?.abi,
     functionName: "addTransaction",
     args: [
-      senderAccount.address,
+      validatedSenderAccount.address,
       recipient,
       client.chain.defaultNumberOfInitialValidators,
       consensusMaxRotations,
       data
     ]
   });
-  const nonce = await client.getCurrentNonce({ address: senderAccount.address });
+};
+var _encodeSubmitAppealData = ({
+  client,
+  txId
+}) => {
+  return encodeFunctionData({
+    abi: client.chain.consensusMainContract?.abi,
+    functionName: "submitAppeal",
+    args: [txId]
+  });
+};
+var _sendTransaction = async ({
+  client,
+  publicClient,
+  encodedData,
+  senderAccount,
+  value = 0n
+}) => {
+  if (!client.chain.consensusMainContract?.address) {
+    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
+  }
+  const validatedSenderAccount = validateAccount(senderAccount);
+  const nonce = await client.getCurrentNonce({ address: validatedSenderAccount.address });
   const transactionRequest = await client.prepareTransactionRequest({
-    account: senderAccount,
+    account: validatedSenderAccount,
     to: client.chain.consensusMainContract?.address,
     data: encodedData,
     type: "legacy",
     nonce: Number(nonce),
-    value: value ?? 0n
+    value
   });
-  if (senderAccount?.type !== "local") {
+  if (validatedSenderAccount?.type !== "local") {
     const formattedRequest = {
       from: transactionRequest.from,
       to: transactionRequest.to,
@@ -557,10 +601,10 @@ var _sendTransaction = async ({
       params: [formattedRequest]
     });
   }
-  if (!senderAccount?.signTransaction) {
+  if (!validatedSenderAccount?.signTransaction) {
     throw new Error("Account does not support signTransaction");
   }
-  const serializedTransaction = await senderAccount.signTransaction(transactionRequest);
+  const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest);
   const txHash = await client.sendRawTransaction({ serializedTransaction });
   const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
   if (receipt.status === "reverted") {

package/dist/types/index.d.cts

@@ -1,3 +1,3 @@
 export { Account, Address } from 'viem';
-export { a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, q as DecodedCallData, D as DecodedDeployData, G as GenLayerClient, b as GenLayerMethod, s as GenLayerRawTransaction, r as GenLayerTransaction, H as Hash, M as MethodDescription, N as Network, S as SnapSource, h as TransactionHash, p as TransactionHashVariant, j as TransactionResult, m as TransactionResultNameToNumber, i as TransactionStatus, o as TransactionType, V as VoteType, l as transactionResultNumberToName, k as transactionsStatusNameToNumber, t as transactionsStatusNumberToName, n as voteTypeNameToNumber, v as voteTypeNumberToName } from '../index-B_gpaVzJ.cjs';
+export { a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, q as DecodedCallData, D as DecodedDeployData, G as GenLayerClient, b as GenLayerMethod, s as GenLayerRawTransaction, r as GenLayerTransaction, H as Hash, M as MethodDescription, N as Network, S as SnapSource, h as TransactionHash, p as TransactionHashVariant, j as TransactionResult, m as TransactionResultNameToNumber, i as TransactionStatus, o as TransactionType, V as VoteType, l as transactionResultNumberToName, k as transactionsStatusNameToNumber, t as transactionsStatusNumberToName, n as voteTypeNameToNumber, v as voteTypeNumberToName } from '../index-BhRfI25e.cjs';
 export { G as GenLayerChain } from '../chains-BYSCF33g.cjs';

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
 export { Account, Address } from 'viem';
-export { a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, q as DecodedCallData, D as DecodedDeployData, G as GenLayerClient, b as GenLayerMethod, s as GenLayerRawTransaction, r as GenLayerTransaction, H as Hash, M as MethodDescription, N as Network, S as SnapSource, h as TransactionHash, p as TransactionHashVariant, j as TransactionResult, m as TransactionResultNameToNumber, i as TransactionStatus, o as TransactionType, V as VoteType, l as transactionResultNumberToName, k as transactionsStatusNameToNumber, t as transactionsStatusNumberToName, n as voteTypeNameToNumber, v as voteTypeNumberToName } from '../index-to6d0Hzj.js';
+export { a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, q as DecodedCallData, D as DecodedDeployData, G as GenLayerClient, b as GenLayerMethod, s as GenLayerRawTransaction, r as GenLayerTransaction, H as Hash, M as MethodDescription, N as Network, S as SnapSource, h as TransactionHash, p as TransactionHashVariant, j as TransactionResult, m as TransactionResultNameToNumber, i as TransactionStatus, o as TransactionType, V as VoteType, l as transactionResultNumberToName, k as transactionsStatusNameToNumber, t as transactionsStatusNumberToName, n as voteTypeNameToNumber, v as voteTypeNumberToName } from '../index-dnt5ldCd.js';
 export { G as GenLayerChain } from '../chains-BYSCF33g.js';

package/package.json

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

package/src/contracts/actions.ts

@@ -137,13 +137,19 @@ export const contractActions = (client: GenLayerClient<GenLayerChain>, publicCli
       } = args;
       const data = [calldata.encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
       const serializedData = serialize(data);
-      return _sendTransaction({
+      const senderAccount = account || client.account;
+      const encodedData = _encodeAddTransactionData({
         client,
-        publicClient,
+        senderAccount,
         recipient: address,
         data: serializedData,
-        senderAccount: account || client.account,
         consensusMaxRotations,
+      });
+      return _sendTransaction({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
         value,
       });
     },
@@ -169,68 +175,118 @@ export const contractActions = (client: GenLayerClient<GenLayerChain>, publicCli
         leaderOnly,
       ];
       const serializedData = serialize(data);
-      return _sendTransaction({
+      const senderAccount = account || client.account;
+      const encodedData = _encodeAddTransactionData({
         client,
-        publicClient: publicClient,
+        senderAccount,
         recipient: zeroAddress,
         data: serializedData,
-        senderAccount: account || client.account,
         consensusMaxRotations,
       });
+      return _sendTransaction({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
+      });
+    },
+    appealTransaction: async (args: {
+      account?: Account;
+      txId: `0x${string}`;
+    }) => {
+      const {account, txId} = args;
+      const senderAccount = account || client.account;
+      const encodedData = _encodeSubmitAppealData({client, txId});
+      return _sendTransaction({
+        client,
+        publicClient,
+        encodedData,
+        senderAccount,
+      });
     },
   };
 };
 
-const _sendTransaction = async ({
+const validateAccount = (Account?: Account): Account => {
+  if (!Account) {
+    throw new Error(
+      "No account set. Configure the client with an account or pass an account to this function.",
+    );
+  }
+  return Account;
+};
+
+const _encodeAddTransactionData = ({
   client,
-  publicClient,
+  senderAccount,
   recipient,
   data,
-  senderAccount,
-  consensusMaxRotations,
-  value,
+  consensusMaxRotations = client.chain.defaultConsensusMaxRotations,
 }: {
   client: GenLayerClient<GenLayerChain>;
-  publicClient: PublicClient;
-  recipient: `0x${string}`;
-  data: `0x${string}`;
   senderAccount?: Account;
+  recipient?: `0x${string}`;
+  data?: `0x${string}`;
   consensusMaxRotations?: number;
-  value?: bigint;
-}) => {
-  if (!senderAccount) {
-    throw new Error(
-      "No account set. Configure the client with an account or pass an account to this function.",
-    );
-  }
-
-  if (!client.chain.consensusMainContract?.address) {
-    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
-  }
-
-  const encodedData = encodeFunctionData({
+}): `0x${string}` => {
+  const validatedSenderAccount = validateAccount(senderAccount);
+  return encodeFunctionData({
     abi: client.chain.consensusMainContract?.abi as any,
     functionName: "addTransaction",
     args: [
-      senderAccount.address,
+      validatedSenderAccount.address,
       recipient,
       client.chain.defaultNumberOfInitialValidators,
       consensusMaxRotations,
       data,
     ],
   });
+};
+
+const _encodeSubmitAppealData = ({
+  client,
+  txId,
+}: {
+  client: GenLayerClient<GenLayerChain>;
+  txId: `0x${string}`;
+}): `0x${string}` => {
+  return encodeFunctionData({
+    abi: client.chain.consensusMainContract?.abi as any,
+    functionName: "submitAppeal",
+    args: [txId],
+  });
+};
+
+const _sendTransaction = async ({
+  client,
+  publicClient,
+  encodedData,
+  senderAccount,
+  value = 0n,
+}: {
+  client: GenLayerClient<GenLayerChain>;
+  publicClient: PublicClient;
+  encodedData: `0x${string}`;
+  senderAccount?: Account;
+  value?: bigint;
+}) => {
+  if (!client.chain.consensusMainContract?.address) {
+    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
+  }
+
+  const validatedSenderAccount = validateAccount(senderAccount);
 
-  const nonce = await client.getCurrentNonce({address: senderAccount.address});
+  const nonce = await client.getCurrentNonce({address: validatedSenderAccount.address});
   const transactionRequest = await client.prepareTransactionRequest({
-    account: senderAccount,
+    account: validatedSenderAccount,
     to: client.chain.consensusMainContract?.address as Address,
     data: encodedData,
     type: "legacy",
     nonce: Number(nonce),
-    value: value ?? 0n,
+    value: value,
   });
 
-  if (senderAccount?.type !== "local") {
+  if (validatedSenderAccount?.type !== "local") {
     const formattedRequest = {
       from: transactionRequest.from,
       to: transactionRequest.to,
@@ -244,11 +300,11 @@ const _sendTransaction = async ({
     });
   }
 
-  if (!senderAccount?.signTransaction) {
+  if (!validatedSenderAccount?.signTransaction) {
     throw new Error("Account does not support signTransaction");
   }
 
-  const serializedTransaction = await senderAccount.signTransaction(transactionRequest);
+  const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest);
 
   const txHash = await client.sendRawTransaction({serializedTransaction: serializedTransaction});
 

package/src/types/clients.ts

@@ -1,5 +1,5 @@
 import {Transport, Client, PublicActions, WalletActions} from "viem";
-import {GenLayerTransaction, TransactionHash, TransactionStatus} from "./transactions";
+import {GenLayerTransaction, TransactionHash, TransactionStatus, TransactionHashVariant} from "./transactions";
 import {GenLayerChain} from "./chains";
 import {Address, Account} from "./accounts";
 import {CalldataEncodable} from "./calldata";
@@ -43,10 +43,10 @@ export type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<
       account?: Account;
       address: Address;
       functionName: string;
-      stateStatus?: TransactionStatus;
       args?: CalldataEncodable[];
       kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
       rawReturn?: RawReturn;
+      transactionHashVariant?: TransactionHashVariant;
     }) => Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable>;
     writeContract: (args: {
       account?: Account;
@@ -79,4 +79,8 @@ export type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<
     initializeConsensusSmartContract: (forceReset?: boolean) => Promise<void>;
     connect: (network?: Network, snapSource?: SnapSource) => Promise<void>;
     metamaskClient: (snapSource?: SnapSource) => Promise<MetaMaskClientResult>;
+    appealTransaction: (args: {
+      account?: Account;
+      txId: `0x${string}`;
+    }) => Promise<any>;
   };

package/tests/client.test.ts

@@ -4,7 +4,7 @@ import {localnet} from "@/chains/localnet";
 import {Address} from "../src/types/accounts";
 import {createAccount, generatePrivateKey} from "../src/accounts/account";
 import {vi} from "vitest";
-import {TransactionStatus} from "../src/types/transactions";
+import {TransactionHashVariant} from "../src/types/transactions";
 
 // Setup fetch mock
 const mockFetch = vi.fn();
@@ -95,7 +95,7 @@ describe("Client Overrides", () => {
       address: contractAddress as Address,
       functionName: "testFunction",
       args: ["arg1", "arg2"],
-      stateStatus: TransactionStatus.ACCEPTED, // Kept as is, matches type, ignored by current gen_call impl.
+      transactionHashVariant: TransactionHashVariant.LATEST_NONFINAL,
     });
 
     expect(lastGenCallParams).toEqual([
@@ -104,7 +104,7 @@ describe("Client Overrides", () => {
         to: contractAddress,
         from: account.address,
         data: expect.any(String), // The data is complex, checking type is often sufficient
-        transaction_hash_variant: "latest-final",
+        transaction_hash_variant: TransactionHashVariant.LATEST_NONFINAL,
       },
     ]);
   });
@@ -126,7 +126,7 @@ describe("Client Overrides", () => {
       address: contractAddress as Address,
       functionName: "testFunction",
       args: ["arg1", "arg2"],
-      stateStatus: TransactionStatus.ACCEPTED,
+      transactionHashVariant: TransactionHashVariant.LATEST_FINAL,
     });
 
     expect(lastGenCallParams).toEqual([
@@ -135,7 +135,7 @@ describe("Client Overrides", () => {
         to: contractAddress,
         from: overrideAccount.address,
         data: expect.any(String),
-        transaction_hash_variant: "latest-final",
+        transaction_hash_variant: TransactionHashVariant.LATEST_FINAL,
       },
     ]);
   });
@@ -164,7 +164,7 @@ describe("Client Overrides", () => {
         to: contractAddress,
         from: accountAddressString, // Expecting the address string directly
         data: expect.any(String),
-        transaction_hash_variant: "latest-final",
+        transaction_hash_variant: TransactionHashVariant.LATEST_FINAL,
       },
     ]);
   });