genlayer-js 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 
 
+## 0.9.0 (2025-03-12)
+
+
+### Features
+
+* decoding params ([#77](https://github.com/yeagerai/genlayer-js/issues/77)) ([ada41ce](https://github.com/yeagerai/genlayer-js/commit/ada41ce375eaf6a94886bc50c13c3f0df247d7c2))
+
+## 0.8.0 (2025-03-12)
+
+
+### Features
+
+* overwrite defaultConsensusMaxRotations ([#75](https://github.com/yeagerai/genlayer-js/issues/75)) ([8d64b42](https://github.com/yeagerai/genlayer-js/commit/8d64b428d8232394cfe1ac5b56edba7c1837d0e5))
+
 ## 0.7.0 (2025-03-05)
 
 

package/dist/{index-DJTO3-o3.d.cts → index-BCbofn6t.d.cts}

@@ -51,6 +51,7 @@ type GenLayerTransaction = {
             node_config: Record<string, unknown>;
             pending_transactions: unknown[];
             vote: string;
+            result: string;
         };
         validators?: Record<string, unknown>[];
         votes?: Record<string, string>;
@@ -153,6 +154,7 @@ type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<Client<Transp
         };
         value: bigint;
         leaderOnly?: boolean;
+        consensusMaxRotations?: number;
     }) => Promise<any>;
     deployContract: (args: {
         account?: Account;
@@ -162,6 +164,7 @@ type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<Client<Transp
             [key: string]: CalldataEncodable;
         };
         leaderOnly?: boolean;
+        consensusMaxRotations?: number;
     }) => Promise<`0x${string}`>;
     getTransaction: (args: {
         hash: TransactionHash;

package/dist/{index-CpcNUbXb.d.ts → index-Ctmshvtv.d.ts}

@@ -51,6 +51,7 @@ type GenLayerTransaction = {
             node_config: Record<string, unknown>;
             pending_transactions: unknown[];
             vote: string;
+            result: string;
         };
         validators?: Record<string, unknown>[];
         votes?: Record<string, string>;
@@ -153,6 +154,7 @@ type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<Client<Transp
         };
         value: bigint;
         leaderOnly?: boolean;
+        consensusMaxRotations?: number;
     }) => Promise<any>;
     deployContract: (args: {
         account?: Account;
@@ -162,6 +164,7 @@ type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<Client<Transp
             [key: string]: CalldataEncodable;
         };
         leaderOnly?: boolean;
+        consensusMaxRotations?: number;
     }) => Promise<`0x${string}`>;
     getTransaction: (args: {
         hash: TransactionHash;

package/dist/index.cjs

@@ -440,18 +440,18 @@ var overrideContractActions = (client) => {
     return decode(resultBinary);
   };
   client.writeContract = async (args) => {
-    const { account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false } = args;
+    const { account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations } = args;
     const data = [encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
-    return _sendTransaction(address, serializedData, account || client.account, value);
+    return _sendTransaction(address, serializedData, account || client.account, consensusMaxRotations, value);
   };
   client.deployContract = async (args) => {
-    const { account, code, args: constructorArgs, kwargs, leaderOnly = false } = args;
+    const { account, code, args: constructorArgs, kwargs, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations } = args;
     const data = [code, encode(makeCalldataObject(void 0, constructorArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
-    return _sendTransaction(_viem.zeroAddress, serializedData, account || client.account);
+    return _sendTransaction(_viem.zeroAddress, serializedData, account || client.account, consensusMaxRotations);
   };
-  const _sendTransaction = async (recipient, data, senderAccount, value) => {
+  const _sendTransaction = async (recipient, data, senderAccount, consensusMaxRotations, value) => {
     if (!senderAccount) {
       throw new Error(
         "No account set. Configure the client with an account or pass an account to this function."
@@ -469,7 +469,7 @@ var overrideContractActions = (client) => {
         senderAccount.address,
         recipient,
         client.chain.defaultNumberOfInitialValidators,
-        client.chain.defaultConsensusMaxRotations,
+        consensusMaxRotations,
         data
       ]
     });
@@ -514,6 +514,55 @@ async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/abi/index.ts
+var abi_exports = {};
+_chunk75ZPJI57cjs.__export.call(void 0, abi_exports, {
+  calldata: () => calldata,
+  transactions: () => transactions
+});
+var calldata = calldata_exports;
+var transactions = transactions_exports;
+
+// src/utils/jsonifier.ts
+function b64ToArray(b64) {
+  return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+}
+function calldataToUserFriendlyJson(cd) {
+  return {
+    raw: Array.from(cd),
+    readable: calldata.toString(calldata.decode(cd))
+  };
+}
+var RESULT_CODES = /* @__PURE__ */ new Map([
+  [0, "return"],
+  [1, "rollback"],
+  [2, "contract_error"],
+  [3, "error"],
+  [4, "none"],
+  [5, "no_leaders"]
+]);
+function resultToUserFriendlyJson(cd64) {
+  const raw = b64ToArray(cd64);
+  const code = RESULT_CODES.get(raw[0]);
+  let status;
+  let payload = null;
+  if (code === void 0) {
+    status = "<unknown>";
+  } else {
+    status = code;
+    if ([1, 2].includes(raw[0])) {
+      payload = new TextDecoder("utf-8").decode(raw.slice(1));
+    } else if (raw[0] == 0) {
+      payload = calldataToUserFriendlyJson(raw.slice(1));
+    }
+  }
+  return {
+    raw: cd64,
+    status,
+    payload
+  };
+}
+
 // src/transactions/actions.ts
 var transactionActions = (client) => ({
   waitForTransactionReceipt: async ({
@@ -527,7 +576,7 @@ var transactionActions = (client) => ({
       throw new Error("Transaction not found");
     }
     if (transaction.status === status || status === "ACCEPTED" /* ACCEPTED */ && transaction.status === "FINALIZED" /* FINALIZED */) {
-      return transaction;
+      return _decodeTransaction(transaction);
     }
     if (retries === 0) {
       throw new Error("Transaction status is not " + status);
@@ -541,6 +590,40 @@ var transactionActions = (client) => ({
     });
   }
 });
+var _decodeTransaction = (tx) => {
+  if (!tx.data) return tx;
+  try {
+    const leaderReceipt = _optionalChain([tx, 'access', _19 => _19.consensus_data, 'optionalAccess', _20 => _20.leader_receipt]);
+    if (leaderReceipt) {
+      if (leaderReceipt.result) {
+        leaderReceipt.result = resultToUserFriendlyJson(leaderReceipt.result);
+      }
+      if (leaderReceipt.calldata) {
+        leaderReceipt.calldata = {
+          base64: leaderReceipt.calldata,
+          ...calldataToUserFriendlyJson(b64ToArray(leaderReceipt.calldata))
+        };
+      }
+      if (leaderReceipt.eq_outputs) {
+        leaderReceipt.eq_outputs = Object.fromEntries(
+          Object.entries(leaderReceipt.eq_outputs).map(([key, value]) => {
+            const decodedValue = new TextDecoder().decode(b64ToArray(String(value)));
+            return [key, resultToUserFriendlyJson(decodedValue)];
+          })
+        );
+      }
+    }
+    if (tx.data.calldata) {
+      tx.data.calldata = {
+        base64: tx.data.calldata,
+        ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
+      };
+    }
+  } catch (e) {
+    console.error("Error decoding transaction:", e);
+  }
+  return tx;
+};
 
 // src/config/snapID.ts
 var snapID = {
@@ -569,7 +652,7 @@ var connect = async (client, network = "localnet", snapSource = "npm") => {
     chainName: selectedNetwork.name,
     rpcUrls: selectedNetwork.rpcUrls.default.http,
     nativeCurrency: selectedNetwork.nativeCurrency,
-    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _19 => _19.blockExplorers, 'optionalAccess', _20 => _20.default, 'access', _21 => _21.url])]
+    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _21 => _21.blockExplorers, 'optionalAccess', _22 => _22.default, 'access', _23 => _23.url])]
   };
   const currentChainId = await window.ethereum.request({ method: "eth_chainId" });
   if (currentChainId !== chainIdHex) {
@@ -605,10 +688,10 @@ var metamaskClient = async (snapSource = "npm") => {
   }
   const isFlask = async () => {
     try {
-      const clientVersion = await _optionalChain([window, 'access', _22 => _22.ethereum, 'optionalAccess', _23 => _23.request, 'call', _24 => _24({
+      const clientVersion = await _optionalChain([window, 'access', _24 => _24.ethereum, 'optionalAccess', _25 => _25.request, 'call', _26 => _26({
         method: "web3_clientVersion"
       })]);
-      return _optionalChain([clientVersion, 'optionalAccess', _25 => _25.includes, 'call', _26 => _26("flask")]);
+      return _optionalChain([clientVersion, 'optionalAccess', _27 => _27.includes, 'call', _28 => _28("flask")]);
     } catch (error) {
       console.error("Error detecting Flask:", error);
       return false;
@@ -616,7 +699,7 @@ var metamaskClient = async (snapSource = "npm") => {
   };
   const installedSnaps = async () => {
     try {
-      return await _optionalChain([window, 'access', _27 => _27.ethereum, 'optionalAccess', _28 => _28.request, 'call', _29 => _29({
+      return await _optionalChain([window, 'access', _29 => _29.ethereum, 'optionalAccess', _30 => _30.request, 'call', _31 => _31({
         method: "wallet_getSnaps"
       })]);
     } catch (error) {
@@ -651,10 +734,10 @@ function walletActions(client) {
 function chainActions(client) {
   return {
     initializeConsensusSmartContract: async (forceReset = false) => {
-      if (_optionalChain([client, 'access', _30 => _30.chain, 'optionalAccess', _31 => _31.id]) !== _chunkI6HC44KDcjs.simulator.id) {
+      if (_optionalChain([client, 'access', _32 => _32.chain, 'optionalAccess', _33 => _33.id]) !== _chunkI6HC44KDcjs.simulator.id) {
         throw new Error("Client is not connected to the simulator");
       }
-      if (!forceReset && _optionalChain([client, 'access', _32 => _32.chain, 'access', _33 => _33.consensusMainContract, 'optionalAccess', _34 => _34.address]) && _optionalChain([client, 'access', _35 => _35.chain, 'access', _36 => _36.consensusMainContract, 'optionalAccess', _37 => _37.abi])) {
+      if (!forceReset && _optionalChain([client, 'access', _34 => _34.chain, 'access', _35 => _35.consensusMainContract, 'optionalAccess', _36 => _36.address]) && _optionalChain([client, 'access', _37 => _37.chain, 'access', _38 => _38.consensusMainContract, 'optionalAccess', _39 => _39.abi])) {
         return;
       }
       const contractsResponse = await fetch(client.chain.rpcUrls.default.http[0], {
@@ -689,7 +772,7 @@ var createClient = (config = { chain: _chunkI6HC44KDcjs.localnet }) => {
     async request({ method, params }) {
       if (method.startsWith("eth_") && isAddress) {
         try {
-          return await _optionalChain([window, 'access', _38 => _38.ethereum, 'optionalAccess', _39 => _39.request, 'call', _40 => _40({ method, params })]);
+          return await _optionalChain([window, 'access', _40 => _40.ethereum, 'optionalAccess', _41 => _41.request, 'call', _42 => _42({ method, params })]);
         } catch (err) {
           console.warn(`Error using window.ethereum for method ${method}:`, err);
           throw err;
@@ -740,15 +823,6 @@ var createAccount = (accountPrivateKey) => {
   return account;
 };
 
-// src/abi/index.ts
-var abi_exports = {};
-_chunk75ZPJI57cjs.__export.call(void 0, abi_exports, {
-  calldata: () => calldata,
-  transactions: () => transactions
-});
-var calldata = calldata_exports;
-var transactions = transactions_exports;
-
 
 
 

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as viem from 'viem';
 import { Account, Address } from 'viem';
 import { S as SimulatorChain } from './chains-C5PI_Nr_.cjs';
-import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-DJTO3-o3.cjs';
+import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-BCbofn6t.cjs';
 import * as abitype from 'abitype';
 import * as viem__types_experimental_eip7702_types_authorization from 'viem/_types/experimental/eip7702/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 { S as SimulatorChain } from './chains-C5PI_Nr_.js';
-import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-CpcNUbXb.js';
+import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-Ctmshvtv.js';
 import * as abitype from 'abitype';
 import * as viem__types_experimental_eip7702_types_authorization from 'viem/_types/experimental/eip7702/types/authorization';
 import * as viem_accounts from 'viem/accounts';

package/dist/index.js

@@ -440,18 +440,18 @@ var overrideContractActions = (client) => {
     return decode(resultBinary);
   };
   client.writeContract = async (args) => {
-    const { account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false } = args;
+    const { account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations } = args;
     const data = [encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
-    return _sendTransaction(address, serializedData, account || client.account, value);
+    return _sendTransaction(address, serializedData, account || client.account, consensusMaxRotations, value);
   };
   client.deployContract = async (args) => {
-    const { account, code, args: constructorArgs, kwargs, leaderOnly = false } = args;
+    const { account, code, args: constructorArgs, kwargs, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations } = args;
     const data = [code, encode(makeCalldataObject(void 0, constructorArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
-    return _sendTransaction(zeroAddress, serializedData, account || client.account);
+    return _sendTransaction(zeroAddress, serializedData, account || client.account, consensusMaxRotations);
   };
-  const _sendTransaction = async (recipient, data, senderAccount, value) => {
+  const _sendTransaction = async (recipient, data, senderAccount, consensusMaxRotations, value) => {
     if (!senderAccount) {
       throw new Error(
         "No account set. Configure the client with an account or pass an account to this function."
@@ -469,7 +469,7 @@ var overrideContractActions = (client) => {
         senderAccount.address,
         recipient,
         client.chain.defaultNumberOfInitialValidators,
-        client.chain.defaultConsensusMaxRotations,
+        consensusMaxRotations,
         data
       ]
     });
@@ -514,6 +514,55 @@ async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/abi/index.ts
+var abi_exports = {};
+__export(abi_exports, {
+  calldata: () => calldata,
+  transactions: () => transactions
+});
+var calldata = calldata_exports;
+var transactions = transactions_exports;
+
+// src/utils/jsonifier.ts
+function b64ToArray(b64) {
+  return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+}
+function calldataToUserFriendlyJson(cd) {
+  return {
+    raw: Array.from(cd),
+    readable: calldata.toString(calldata.decode(cd))
+  };
+}
+var RESULT_CODES = /* @__PURE__ */ new Map([
+  [0, "return"],
+  [1, "rollback"],
+  [2, "contract_error"],
+  [3, "error"],
+  [4, "none"],
+  [5, "no_leaders"]
+]);
+function resultToUserFriendlyJson(cd64) {
+  const raw = b64ToArray(cd64);
+  const code = RESULT_CODES.get(raw[0]);
+  let status;
+  let payload = null;
+  if (code === void 0) {
+    status = "<unknown>";
+  } else {
+    status = code;
+    if ([1, 2].includes(raw[0])) {
+      payload = new TextDecoder("utf-8").decode(raw.slice(1));
+    } else if (raw[0] == 0) {
+      payload = calldataToUserFriendlyJson(raw.slice(1));
+    }
+  }
+  return {
+    raw: cd64,
+    status,
+    payload
+  };
+}
+
 // src/transactions/actions.ts
 var transactionActions = (client) => ({
   waitForTransactionReceipt: async ({
@@ -527,7 +576,7 @@ var transactionActions = (client) => ({
       throw new Error("Transaction not found");
     }
     if (transaction.status === status || status === "ACCEPTED" /* ACCEPTED */ && transaction.status === "FINALIZED" /* FINALIZED */) {
-      return transaction;
+      return _decodeTransaction(transaction);
     }
     if (retries === 0) {
       throw new Error("Transaction status is not " + status);
@@ -541,6 +590,40 @@ var transactionActions = (client) => ({
     });
   }
 });
+var _decodeTransaction = (tx) => {
+  if (!tx.data) return tx;
+  try {
+    const leaderReceipt = tx.consensus_data?.leader_receipt;
+    if (leaderReceipt) {
+      if (leaderReceipt.result) {
+        leaderReceipt.result = resultToUserFriendlyJson(leaderReceipt.result);
+      }
+      if (leaderReceipt.calldata) {
+        leaderReceipt.calldata = {
+          base64: leaderReceipt.calldata,
+          ...calldataToUserFriendlyJson(b64ToArray(leaderReceipt.calldata))
+        };
+      }
+      if (leaderReceipt.eq_outputs) {
+        leaderReceipt.eq_outputs = Object.fromEntries(
+          Object.entries(leaderReceipt.eq_outputs).map(([key, value]) => {
+            const decodedValue = new TextDecoder().decode(b64ToArray(String(value)));
+            return [key, resultToUserFriendlyJson(decodedValue)];
+          })
+        );
+      }
+    }
+    if (tx.data.calldata) {
+      tx.data.calldata = {
+        base64: tx.data.calldata,
+        ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
+      };
+    }
+  } catch (e) {
+    console.error("Error decoding transaction:", e);
+  }
+  return tx;
+};
 
 // src/config/snapID.ts
 var snapID = {
@@ -739,15 +822,6 @@ var createAccount = (accountPrivateKey) => {
   const account = privateKeyToAccount(privateKey);
   return account;
 };
-
-// src/abi/index.ts
-var abi_exports = {};
-__export(abi_exports, {
-  calldata: () => calldata,
-  transactions: () => transactions
-});
-var calldata = calldata_exports;
-var transactions = transactions_exports;
 export {
   abi_exports as abi,
   chains_exports as chains,

package/dist/types/index.d.cts

@@ -1,3 +1,3 @@
-export { A as Address, a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, G as GenLayerClient, b as GenLayerMethod, j as GenLayerTransaction, M as MethodDescription, N as Network, S as SnapSource, k as TransactionDataElement, h as TransactionHash, i as TransactionStatus } from '../index-DJTO3-o3.cjs';
+export { A as Address, a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, G as GenLayerClient, b as GenLayerMethod, j as GenLayerTransaction, M as MethodDescription, N as Network, S as SnapSource, k as TransactionDataElement, h as TransactionHash, i as TransactionStatus } from '../index-BCbofn6t.cjs';
 export { S as SimulatorChain } from '../chains-C5PI_Nr_.cjs';
 export { Account } from 'viem';

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
-export { A as Address, a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, G as GenLayerClient, b as GenLayerMethod, j as GenLayerTransaction, M as MethodDescription, N as Network, S as SnapSource, k as TransactionDataElement, h as TransactionHash, i as TransactionStatus } from '../index-CpcNUbXb.js';
+export { A as Address, a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, G as GenLayerClient, b as GenLayerMethod, j as GenLayerTransaction, M as MethodDescription, N as Network, S as SnapSource, k as TransactionDataElement, h as TransactionHash, i as TransactionStatus } from '../index-Ctmshvtv.js';
 export { S as SimulatorChain } from '../chains-C5PI_Nr_.js';
 export { Account } from 'viem';

package/package.json

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

package/src/contracts/actions.ts

@@ -115,11 +115,12 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
     kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
     value: bigint;
     leaderOnly?: boolean;
+    consensusMaxRotations?: number;
   }): Promise<`0x${string}`> => {
-    const {account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false} = args;
+    const {account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations} = args;
     const data = [calldata.encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
-    return _sendTransaction(address, serializedData, account || client.account, value);
+    return _sendTransaction(address, serializedData, account || client.account, consensusMaxRotations, value);
   };
 
   client.deployContract = async (args: {
@@ -128,17 +129,19 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
     args?: CalldataEncodable[];
     kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
     leaderOnly?: boolean;
+    consensusMaxRotations?: number;
   }) => {
-    const {account, code, args: constructorArgs, kwargs, leaderOnly = false} = args;
+    const {account, code, args: constructorArgs, kwargs, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations} = args;
     const data = [code, calldata.encode(makeCalldataObject(undefined, constructorArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
-    return _sendTransaction(zeroAddress, serializedData, account || client.account);
+    return _sendTransaction(zeroAddress, serializedData, account || client.account, consensusMaxRotations);
   };
 
   const _sendTransaction = async (
     recipient: `0x${string}`,
     data: `0x${string}`,
     senderAccount?: Account,
+    consensusMaxRotations?: number,
     value?: bigint,
   ) => {
     if (!senderAccount) {
@@ -160,7 +163,7 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
         senderAccount.address,
         recipient,
         client.chain.defaultNumberOfInitialValidators,
-        client.chain.defaultConsensusMaxRotations,
+        consensusMaxRotations,
         data,
       ],
     });

package/src/transactions/actions.ts

@@ -3,6 +3,7 @@ import {TransactionHash, TransactionStatus, GenLayerTransaction} from "../types/
 import {transactionsConfig} from "../config/transactions";
 import {sleep} from "../utils/async";
 import {SimulatorChain} from "@/types";
+import {b64ToArray, calldataToUserFriendlyJson, resultToUserFriendlyJson} from "@/utils/jsonifier";
 
 export const transactionActions = (client: GenLayerClient<SimulatorChain>) => ({
   waitForTransactionReceipt: async ({
@@ -26,7 +27,7 @@ export const transactionActions = (client: GenLayerClient<SimulatorChain>) => ({
       transaction.status === status ||
       (status === TransactionStatus.ACCEPTED && transaction.status === TransactionStatus.FINALIZED)
     ) {
-      return transaction;
+      return _decodeTransaction(transaction);
     }
 
     if (retries === 0) {
@@ -42,3 +43,43 @@ export const transactionActions = (client: GenLayerClient<SimulatorChain>) => ({
     });
   },
 });
+
+const _decodeTransaction = (tx: GenLayerTransaction): GenLayerTransaction => {
+  if (!tx.data) return tx;
+
+  try {
+    const leaderReceipt = tx.consensus_data?.leader_receipt;
+    if (leaderReceipt) {
+      if (leaderReceipt.result) {
+        leaderReceipt.result = resultToUserFriendlyJson(leaderReceipt.result);
+      }
+
+      if (leaderReceipt.calldata) {
+        leaderReceipt.calldata = {
+          base64: leaderReceipt.calldata,
+          ...calldataToUserFriendlyJson(b64ToArray(leaderReceipt.calldata)),
+        };
+      }
+
+      if (leaderReceipt.eq_outputs) {
+        leaderReceipt.eq_outputs = Object.fromEntries(
+          Object.entries(leaderReceipt.eq_outputs).map(([key, value]) => {
+            const decodedValue = new TextDecoder().decode(b64ToArray(String(value)));
+            return [key, resultToUserFriendlyJson(decodedValue)];
+          })
+        );
+      }
+    }
+
+    if (tx.data.calldata) {
+      tx.data.calldata = {
+        base64: tx.data.calldata as string,
+        ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata as string)),
+      };
+    }
+  } catch (e) {
+    console.error("Error decoding transaction:", e);
+  }
+
+  return tx;
+}

package/src/types/clients.ts

@@ -55,6 +55,7 @@ export type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<
       kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
       value: bigint;
       leaderOnly?: boolean;
+      consensusMaxRotations?: number;
     }) => Promise<any>;
     deployContract: (args: {
       account?: Account;
@@ -62,6 +63,7 @@ export type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<
       args?: CalldataEncodable[];
       kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
       leaderOnly?: boolean;
+      consensusMaxRotations?: number;
     }) => Promise<`0x${string}`>;
     getTransaction: (args: {hash: TransactionHash}) => Promise<GenLayerTransaction>;
     getCurrentNonce: (args: {address: string}) => Promise<number>;

package/src/types/transactions.ts

@@ -31,6 +31,7 @@ export type GenLayerTransaction = {
       node_config: Record<string, unknown>;
       pending_transactions: unknown[];
       vote: string;
+      result: string;
     };
     validators?: Record<string, unknown>[];
     votes?: Record<string, string>;

package/src/utils/jsonifier.ts

@@ -0,0 +1,47 @@
+import {calldata} from "@/abi";
+
+
+export function b64ToArray(b64: string): Uint8Array {
+  return Uint8Array.from(atob(b64 as string), (c) => c.charCodeAt(0));
+}
+
+export function calldataToUserFriendlyJson(cd: Uint8Array): any {
+  return {
+    raw: Array.from(cd),
+    readable: calldata.toString(calldata.decode(cd)),
+  };
+}
+
+const RESULT_CODES = new Map([
+  [0, 'return'],
+  [1, 'rollback'],
+  [2, 'contract_error'],
+  [3, 'error'],
+  [4, 'none'],
+  [5, 'no_leaders'],
+]);
+
+export function resultToUserFriendlyJson(cd64: string): any {
+  const raw = b64ToArray(cd64);
+
+  const code = RESULT_CODES.get(raw[0]);
+  let status: string;
+  let payload: string | null = null;
+
+  if (code === undefined) {
+    status = '<unknown>';
+  } else {
+    status = code;
+    if ([1, 2].includes(raw[0])) {
+      payload = new TextDecoder('utf-8').decode(raw.slice(1));
+    } else if (raw[0] == 0) {
+      payload = calldataToUserFriendlyJson(raw.slice(1));
+    }
+  }
+
+  return {
+    raw: cd64,
+    status,
+    payload,
+  };
+}