genlayer-js 0.19.0 → 0.19.2

package/dist/index.cjs

@@ -624,10 +624,11 @@ var contractActions = (client, publicClient) => {
         leaderOnly = false,
         consensusMaxRotations = client.chain.defaultConsensusMaxRotations
       } = args;
+      await client.initializeConsensusSmartContract();
       const data = [encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
       const serializedData = serialize(data);
       const senderAccount = account || client.account;
-      const encodedData = _encodeAddTransactionData({
+      const { primaryEncodedData, fallbackEncodedData } = _encodeAddTransactionData({
         client,
         senderAccount,
         recipient: address,
@@ -637,7 +638,8 @@ var contractActions = (client, publicClient) => {
       return _sendTransaction({
         client,
         publicClient,
-        encodedData,
+        encodedData: primaryEncodedData,
+        fallbackEncodedData,
         senderAccount,
         value
       });
@@ -651,6 +653,7 @@ var contractActions = (client, publicClient) => {
         leaderOnly = false,
         consensusMaxRotations = client.chain.defaultConsensusMaxRotations
       } = args;
+      await client.initializeConsensusSmartContract();
       const data = [
         code,
         encode(makeCalldataObject(void 0, constructorArgs, kwargs)),
@@ -658,7 +661,7 @@ var contractActions = (client, publicClient) => {
       ];
       const serializedData = serialize(data);
       const senderAccount = account || client.account;
-      const encodedData = _encodeAddTransactionData({
+      const { primaryEncodedData, fallbackEncodedData } = _encodeAddTransactionData({
         client,
         senderAccount,
         recipient: _viem.zeroAddress,
@@ -668,7 +671,8 @@ var contractActions = (client, publicClient) => {
       return _sendTransaction({
         client,
         publicClient,
-        encodedData,
+        encodedData: primaryEncodedData,
+        fallbackEncodedData,
         senderAccount
       });
     },
@@ -693,6 +697,50 @@ var validateAccount = (Account4) => {
   }
   return Account4;
 };
+var ADD_TRANSACTION_ABI_V5 = [
+  {
+    type: "function",
+    name: "addTransaction",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "_sender", type: "address" },
+      { name: "_recipient", type: "address" },
+      { name: "_numOfInitialValidators", type: "uint256" },
+      { name: "_maxRotations", type: "uint256" },
+      { name: "_txData", type: "bytes" }
+    ],
+    outputs: []
+  }
+];
+var ADD_TRANSACTION_ABI_V6 = [
+  {
+    type: "function",
+    name: "addTransaction",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "_sender", type: "address" },
+      { name: "_recipient", type: "address" },
+      { name: "_numOfInitialValidators", type: "uint256" },
+      { name: "_maxRotations", type: "uint256" },
+      { name: "_txData", type: "bytes" },
+      { name: "_validUntil", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+var getAddTransactionInputCount = (abi) => {
+  if (!abi || !Array.isArray(abi)) {
+    return 0;
+  }
+  const addTransactionFunction = abi.find((item) => {
+    if (!item || typeof item !== "object") {
+      return false;
+    }
+    const candidate = item;
+    return candidate.type === "function" && candidate.name === "addTransaction";
+  });
+  return Array.isArray(_optionalChain([addTransactionFunction, 'optionalAccess', _11 => _11.inputs])) ? addTransactionFunction.inputs.length : 0;
+};
 var _encodeAddTransactionData = ({
   client,
   senderAccount,
@@ -701,106 +749,139 @@ var _encodeAddTransactionData = ({
   consensusMaxRotations = client.chain.defaultConsensusMaxRotations
 }) => {
   const validatedSenderAccount = validateAccount(senderAccount);
-  return _viem.encodeFunctionData.call(void 0, {
-    abi: _optionalChain([client, 'access', _11 => _11.chain, 'access', _12 => _12.consensusMainContract, 'optionalAccess', _13 => _13.abi]),
+  const addTransactionArgs = [
+    validatedSenderAccount.address,
+    recipient,
+    client.chain.defaultNumberOfInitialValidators,
+    consensusMaxRotations,
+    data
+  ];
+  const encodedDataV5 = _viem.encodeFunctionData.call(void 0, {
+    abi: ADD_TRANSACTION_ABI_V5,
     functionName: "addTransaction",
-    args: [
-      validatedSenderAccount.address,
-      recipient,
-      client.chain.defaultNumberOfInitialValidators,
-      consensusMaxRotations,
-      data
-    ]
+    args: addTransactionArgs
   });
+  const encodedDataV6 = _viem.encodeFunctionData.call(void 0, {
+    abi: ADD_TRANSACTION_ABI_V6,
+    functionName: "addTransaction",
+    args: [...addTransactionArgs, 0n]
+  });
+  if (getAddTransactionInputCount(_optionalChain([client, 'access', _12 => _12.chain, 'access', _13 => _13.consensusMainContract, 'optionalAccess', _14 => _14.abi])) >= 6) {
+    return {
+      primaryEncodedData: encodedDataV6,
+      fallbackEncodedData: encodedDataV5
+    };
+  }
+  return {
+    primaryEncodedData: encodedDataV5,
+    fallbackEncodedData: encodedDataV6
+  };
 };
 var _encodeSubmitAppealData = ({
   client,
   txId
 }) => {
   return _viem.encodeFunctionData.call(void 0, {
-    abi: _optionalChain([client, 'access', _14 => _14.chain, 'access', _15 => _15.consensusMainContract, 'optionalAccess', _16 => _16.abi]),
+    abi: _optionalChain([client, 'access', _15 => _15.chain, 'access', _16 => _16.consensusMainContract, 'optionalAccess', _17 => _17.abi]),
     functionName: "submitAppeal",
     args: [txId]
   });
 };
+var isAddTransactionAbiMismatchError = (error) => {
+  const errorMessage = String(
+    _optionalChain([error, 'optionalAccess', _18 => _18.shortMessage]) || _optionalChain([error, 'optionalAccess', _19 => _19.details]) || _optionalChain([error, 'optionalAccess', _20 => _20.message]) || error || ""
+  ).toLowerCase();
+  return errorMessage.includes("invalid pointer in tuple") || errorMessage.includes("could not decode") || errorMessage.includes("invalid arrayify value") || errorMessage.includes("types/value length mismatch");
+};
 var _sendTransaction = async ({
   client,
   publicClient,
   encodedData,
+  fallbackEncodedData,
   senderAccount,
   value = 0n
 }) => {
-  if (!_optionalChain([client, 'access', _17 => _17.chain, 'access', _18 => _18.consensusMainContract, 'optionalAccess', _19 => _19.address])) {
+  if (!_optionalChain([client, 'access', _21 => _21.chain, 'access', _22 => _22.consensusMainContract, 'optionalAccess', _23 => _23.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 });
-  let estimatedGas;
-  try {
-    estimatedGas = await client.estimateTransactionGas({
-      from: validatedSenderAccount.address,
-      to: _optionalChain([client, 'access', _20 => _20.chain, 'access', _21 => _21.consensusMainContract, 'optionalAccess', _22 => _22.address]),
-      data: encodedData,
-      value
-    });
-  } catch (err) {
-    console.error("Gas estimation failed, using default 200_000:", err);
-    estimatedGas = 200000n;
-  }
-  if (_optionalChain([validatedSenderAccount, 'optionalAccess', _23 => _23.type]) === "local") {
-    if (!_optionalChain([validatedSenderAccount, 'optionalAccess', _24 => _24.signTransaction])) {
-      throw new Error("Account does not support signTransaction");
+  const sendWithEncodedData = async (encodedDataForSend) => {
+    let estimatedGas;
+    try {
+      estimatedGas = await client.estimateTransactionGas({
+        from: validatedSenderAccount.address,
+        to: _optionalChain([client, 'access', _24 => _24.chain, 'access', _25 => _25.consensusMainContract, 'optionalAccess', _26 => _26.address]),
+        data: encodedDataForSend,
+        value
+      });
+    } catch (err) {
+      console.error("Gas estimation failed, using default 200_000:", err);
+      estimatedGas = 200000n;
     }
-    const gasPriceHex = await client.request({
-      method: "eth_gasPrice"
-    });
-    const transactionRequest2 = {
+    if (_optionalChain([validatedSenderAccount, 'optionalAccess', _27 => _27.type]) === "local") {
+      if (!_optionalChain([validatedSenderAccount, 'optionalAccess', _28 => _28.signTransaction])) {
+        throw new Error("Account does not support signTransaction");
+      }
+      const gasPriceHex = await client.request({
+        method: "eth_gasPrice"
+      });
+      const transactionRequest2 = {
+        account: validatedSenderAccount,
+        to: _optionalChain([client, 'access', _29 => _29.chain, 'access', _30 => _30.consensusMainContract, 'optionalAccess', _31 => _31.address]),
+        data: encodedDataForSend,
+        type: "legacy",
+        nonce: Number(nonce),
+        value,
+        gas: estimatedGas,
+        gasPrice: BigInt(gasPriceHex),
+        chainId: client.chain.id
+      };
+      const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest2);
+      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', _32 => _32.chain, 'access', _33 => _33.consensusMainContract, 'optionalAccess', _34 => _34.abi]),
+        eventName: "NewTransaction",
+        logs: receipt.logs
+      });
+      if (newTxEvents.length === 0) {
+        throw new Error("Transaction not processed by consensus");
+      }
+      return newTxEvents[0].args["txId"];
+    }
+    const transactionRequest = await client.prepareTransactionRequest({
       account: validatedSenderAccount,
-      to: _optionalChain([client, 'access', _25 => _25.chain, 'access', _26 => _26.consensusMainContract, 'optionalAccess', _27 => _27.address]),
-      data: encodedData,
+      to: _optionalChain([client, 'access', _35 => _35.chain, 'access', _36 => _36.consensusMainContract, 'optionalAccess', _37 => _37.address]),
+      data: encodedDataForSend,
       type: "legacy",
       nonce: Number(nonce),
       value,
-      gas: estimatedGas,
-      gasPrice: BigInt(gasPriceHex),
-      chainId: client.chain.id
+      gas: estimatedGas
+    });
+    const formattedRequest = {
+      from: transactionRequest.from,
+      to: transactionRequest.to,
+      data: encodedDataForSend,
+      value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0",
+      gas: transactionRequest.gas ? `0x${transactionRequest.gas.toString(16)}` : "0x5208"
     };
-    const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest2);
-    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', _28 => _28.chain, 'access', _29 => _29.consensusMainContract, 'optionalAccess', _30 => _30.abi]),
-      eventName: "NewTransaction",
-      logs: receipt.logs
+    return await client.request({
+      method: "eth_sendTransaction",
+      params: [formattedRequest]
     });
-    if (newTxEvents.length === 0) {
-      throw new Error("Transaction not processed by consensus");
+  };
+  try {
+    return await sendWithEncodedData(encodedData);
+  } catch (error) {
+    if (!fallbackEncodedData || !isAddTransactionAbiMismatchError(error)) {
+      throw error;
     }
-    return newTxEvents[0].args["txId"];
+    return await sendWithEncodedData(fallbackEncodedData);
   }
-  const transactionRequest = await client.prepareTransactionRequest({
-    account: validatedSenderAccount,
-    to: _optionalChain([client, 'access', _31 => _31.chain, 'access', _32 => _32.consensusMainContract, 'optionalAccess', _33 => _33.address]),
-    data: encodedData,
-    type: "legacy",
-    nonce: Number(nonce),
-    value,
-    gas: estimatedGas
-  });
-  const formattedRequest = {
-    from: transactionRequest.from,
-    to: transactionRequest.to,
-    data: encodedData,
-    value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0",
-    gas: transactionRequest.gas ? `0x${transactionRequest.gas.toString(16)}` : "0x5208"
-  };
-  return await client.request({
-    method: "eth_sendTransaction",
-    params: [formattedRequest]
-  });
 };
 
 // src/config/transactions.ts
@@ -1007,7 +1088,7 @@ var simplifyTransactionReceipt = (tx) => {
 var decodeLocalnetTransaction = (tx) => {
   if (!tx.data) return tx;
   try {
-    const leaderReceipt = _optionalChain([tx, 'access', _34 => _34.consensus_data, 'optionalAccess', _35 => _35.leader_receipt]);
+    const leaderReceipt = _optionalChain([tx, 'access', _38 => _38.consensus_data, 'optionalAccess', _39 => _39.leader_receipt]);
     if (leaderReceipt) {
       const receipts = Array.isArray(leaderReceipt) ? leaderReceipt : [leaderReceipt];
       receipts.forEach((receipt) => {
@@ -1038,7 +1119,7 @@ var decodeLocalnetTransaction = (tx) => {
         }
       });
     }
-    if (_optionalChain([tx, 'access', _36 => _36.data, 'optionalAccess', _37 => _37.calldata]) && typeof tx.data.calldata === "string") {
+    if (_optionalChain([tx, 'access', _40 => _40.data, 'optionalAccess', _41 => _41.calldata]) && typeof tx.data.calldata === "string") {
       tx.data.calldata = {
         base64: tx.data.calldata,
         ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
@@ -1100,8 +1181,8 @@ var transactionActions = (client, publicClient) => ({
       return decodeLocalnetTransaction(transaction2);
     }
     const transaction = await publicClient.readContract({
-      address: _optionalChain([client, 'access', _38 => _38.chain, 'access', _39 => _39.consensusDataContract, 'optionalAccess', _40 => _40.address]),
-      abi: _optionalChain([client, 'access', _41 => _41.chain, 'access', _42 => _42.consensusDataContract, 'optionalAccess', _43 => _43.abi]),
+      address: _optionalChain([client, 'access', _42 => _42.chain, 'access', _43 => _43.consensusDataContract, 'optionalAccess', _44 => _44.address]),
+      abi: _optionalChain([client, 'access', _45 => _45.chain, 'access', _46 => _46.consensusDataContract, 'optionalAccess', _47 => _47.abi]),
       functionName: "getTransactionData",
       args: [
         hash,
@@ -1113,7 +1194,7 @@ var transactionActions = (client, publicClient) => ({
   },
   estimateTransactionGas: async (transactionParams) => {
     const formattedParams = {
-      from: transactionParams.from || _optionalChain([client, 'access', _44 => _44.account, 'optionalAccess', _45 => _45.address]),
+      from: transactionParams.from || _optionalChain([client, 'access', _48 => _48.account, 'optionalAccess', _49 => _49.address]),
       to: transactionParams.to,
       data: transactionParams.data || "0x",
       value: transactionParams.value ? `0x${transactionParams.value.toString(16)}` : "0x0"
@@ -1155,7 +1236,7 @@ var connect = async (client, network = "studionet", snapSource = "npm") => {
     chainName: selectedNetwork.name,
     rpcUrls: selectedNetwork.rpcUrls.default.http,
     nativeCurrency: selectedNetwork.nativeCurrency,
-    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _46 => _46.blockExplorers, 'optionalAccess', _47 => _47.default, 'access', _48 => _48.url])]
+    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _50 => _50.blockExplorers, 'optionalAccess', _51 => _51.default, 'access', _52 => _52.url])]
   };
   const currentChainId = await window.ethereum.request({ method: "eth_chainId" });
   if (currentChainId !== chainIdHex) {
@@ -1189,10 +1270,10 @@ var metamaskClient = async (snapSource = "npm") => {
   }
   const isFlask = async () => {
     try {
-      const clientVersion = await _optionalChain([window, 'access', _49 => _49.ethereum, 'optionalAccess', _50 => _50.request, 'call', _51 => _51({
+      const clientVersion = await _optionalChain([window, 'access', _53 => _53.ethereum, 'optionalAccess', _54 => _54.request, 'call', _55 => _55({
         method: "web3_clientVersion"
       })]);
-      return _optionalChain([clientVersion, 'optionalAccess', _52 => _52.includes, 'call', _53 => _53("flask")]);
+      return _optionalChain([clientVersion, 'optionalAccess', _56 => _56.includes, 'call', _57 => _57("flask")]);
     } catch (error) {
       console.error("Error detecting Flask:", error);
       return false;
@@ -1200,7 +1281,7 @@ var metamaskClient = async (snapSource = "npm") => {
   };
   const installedSnaps = async () => {
     try {
-      return await _optionalChain([window, 'access', _54 => _54.ethereum, 'optionalAccess', _55 => _55.request, 'call', _56 => _56({
+      return await _optionalChain([window, 'access', _58 => _58.ethereum, 'optionalAccess', _59 => _59.request, 'call', _60 => _60({
         method: "wallet_getSnaps"
       })]);
     } catch (error) {
@@ -1287,7 +1368,7 @@ function extractRevertReason(err) {
     }
     const revertError = err.walk((e) => e instanceof _viem.ContractFunctionRevertedError);
     if (revertError instanceof _viem.ContractFunctionRevertedError) {
-      if (_optionalChain([revertError, 'access', _57 => _57.data, 'optionalAccess', _58 => _58.errorName])) {
+      if (_optionalChain([revertError, 'access', _61 => _61.data, 'optionalAccess', _62 => _62.errorName])) {
         return revertError.data.errorName;
       }
       return revertError.reason || "Unknown reason";
@@ -1375,7 +1456,7 @@ var stakingActions = (client, publicClient) => {
   };
   const getStakingAddress = () => {
     const stakingConfig = client.chain.stakingContract;
-    if (!_optionalChain([stakingConfig, 'optionalAccess', _59 => _59.address]) || stakingConfig.address === "0x0000000000000000000000000000000000000000") {
+    if (!_optionalChain([stakingConfig, 'optionalAccess', _63 => _63.address]) || stakingConfig.address === "0x0000000000000000000000000000000000000000") {
       throw new Error("Staking is not supported on studio-based networks. Use testnet-asimov for staking operations.");
     }
     return stakingConfig.address;
@@ -1456,10 +1537,10 @@ var stakingActions = (client, publicClient) => {
       return executeWrite({ to: getStakingAddress(), data });
     },
     validatorClaim: async (options) => {
-      if (!_optionalChain([options, 'optionalAccess', _60 => _60.validator]) && !client.account) {
+      if (!_optionalChain([options, 'optionalAccess', _64 => _64.validator]) && !client.account) {
         throw new Error("Either provide validator address or initialize client with an account");
       }
-      const validatorAddress = _optionalChain([options, 'optionalAccess', _61 => _61.validator]) || client.account.address;
+      const validatorAddress = _optionalChain([options, 'optionalAccess', _65 => _65.validator]) || client.account.address;
       const data = _viem.encodeFunctionData.call(void 0, {
         abi: _chunk5TKVNHAOcjs.STAKING_ABI,
         functionName: "validatorClaim",
@@ -1800,29 +1881,43 @@ var stakingActions = (client, publicClient) => {
 function chainActions(client) {
   return {
     initializeConsensusSmartContract: async (forceReset = false) => {
-      if (_optionalChain([client, 'access', _62 => _62.chain, 'optionalAccess', _63 => _63.id]) === _chunk5TKVNHAOcjs.testnetAsimov.id) {
+      if (_optionalChain([client, 'access', _66 => _66.chain, 'optionalAccess', _67 => _67.id]) === _chunk5TKVNHAOcjs.testnetAsimov.id) {
         return;
       }
-      if (!forceReset && _optionalChain([client, 'access', _64 => _64.chain, 'access', _65 => _65.consensusMainContract, 'optionalAccess', _66 => _66.address]) && _optionalChain([client, 'access', _67 => _67.chain, 'access', _68 => _68.consensusMainContract, 'optionalAccess', _69 => _69.abi])) {
+      const hasStaticConsensusContract = !!_optionalChain([client, 'access', _68 => _68.chain, 'access', _69 => _69.consensusMainContract, 'optionalAccess', _70 => _70.address]) && !!_optionalChain([client, 'access', _71 => _71.chain, 'access', _72 => _72.consensusMainContract, 'optionalAccess', _73 => _73.abi]);
+      const isLocalOrStudioChain = _optionalChain([client, 'access', _74 => _74.chain, 'optionalAccess', _75 => _75.id]) === _chunk5TKVNHAOcjs.localnet.id || _optionalChain([client, 'access', _76 => _76.chain, 'optionalAccess', _77 => _77.id]) === _chunk5TKVNHAOcjs.studionet.id;
+      if (!forceReset && hasStaticConsensusContract && !isLocalOrStudioChain) {
         return;
       }
-      const contractsResponse = await fetch(client.chain.rpcUrls.default.http[0], {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: Date.now(),
-          method: "sim_getConsensusContract",
-          params: ["ConsensusMain"]
-        })
-      });
-      if (!contractsResponse.ok) {
-        throw new Error("Failed to fetch ConsensusMain contract");
+      try {
+        const contractsResponse = await fetch(client.chain.rpcUrls.default.http[0], {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method: "sim_getConsensusContract",
+            params: ["ConsensusMain"]
+          })
+        });
+        if (!contractsResponse.ok) {
+          throw new Error("Failed to fetch ConsensusMain contract");
+        }
+        const consensusMainContract = await contractsResponse.json();
+        if (_optionalChain([consensusMainContract, 'optionalAccess', _78 => _78.error]) || !_optionalChain([consensusMainContract, 'optionalAccess', _79 => _79.result, 'optionalAccess', _80 => _80.address]) || !_optionalChain([consensusMainContract, 'optionalAccess', _81 => _81.result, 'optionalAccess', _82 => _82.abi])) {
+          throw new Error("ConsensusMain response did not include a valid contract");
+        }
+        client.chain.consensusMainContract = consensusMainContract.result;
+        client.chain.__consensusAbiFetchedFromRpc = true;
+      } catch (error) {
+        if (hasStaticConsensusContract) {
+          client.chain.__consensusAbiFetchedFromRpc = false;
+          return;
+        }
+        throw error;
       }
-      const consensusMainContract = await contractsResponse.json();
-      client.chain.consensusMainContract = consensusMainContract.result;
     }
   };
 }

package/dist/index.js

@@ -624,10 +624,11 @@ var contractActions = (client, publicClient) => {
         leaderOnly = false,
         consensusMaxRotations = client.chain.defaultConsensusMaxRotations
       } = args;
+      await client.initializeConsensusSmartContract();
       const data = [encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
       const serializedData = serialize(data);
       const senderAccount = account || client.account;
-      const encodedData = _encodeAddTransactionData({
+      const { primaryEncodedData, fallbackEncodedData } = _encodeAddTransactionData({
         client,
         senderAccount,
         recipient: address,
@@ -637,7 +638,8 @@ var contractActions = (client, publicClient) => {
       return _sendTransaction({
         client,
         publicClient,
-        encodedData,
+        encodedData: primaryEncodedData,
+        fallbackEncodedData,
         senderAccount,
         value
       });
@@ -651,6 +653,7 @@ var contractActions = (client, publicClient) => {
         leaderOnly = false,
         consensusMaxRotations = client.chain.defaultConsensusMaxRotations
       } = args;
+      await client.initializeConsensusSmartContract();
       const data = [
         code,
         encode(makeCalldataObject(void 0, constructorArgs, kwargs)),
@@ -658,7 +661,7 @@ var contractActions = (client, publicClient) => {
       ];
       const serializedData = serialize(data);
       const senderAccount = account || client.account;
-      const encodedData = _encodeAddTransactionData({
+      const { primaryEncodedData, fallbackEncodedData } = _encodeAddTransactionData({
         client,
         senderAccount,
         recipient: zeroAddress,
@@ -668,7 +671,8 @@ var contractActions = (client, publicClient) => {
       return _sendTransaction({
         client,
         publicClient,
-        encodedData,
+        encodedData: primaryEncodedData,
+        fallbackEncodedData,
         senderAccount
       });
     },
@@ -693,6 +697,50 @@ var validateAccount = (Account4) => {
   }
   return Account4;
 };
+var ADD_TRANSACTION_ABI_V5 = [
+  {
+    type: "function",
+    name: "addTransaction",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "_sender", type: "address" },
+      { name: "_recipient", type: "address" },
+      { name: "_numOfInitialValidators", type: "uint256" },
+      { name: "_maxRotations", type: "uint256" },
+      { name: "_txData", type: "bytes" }
+    ],
+    outputs: []
+  }
+];
+var ADD_TRANSACTION_ABI_V6 = [
+  {
+    type: "function",
+    name: "addTransaction",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "_sender", type: "address" },
+      { name: "_recipient", type: "address" },
+      { name: "_numOfInitialValidators", type: "uint256" },
+      { name: "_maxRotations", type: "uint256" },
+      { name: "_txData", type: "bytes" },
+      { name: "_validUntil", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+var getAddTransactionInputCount = (abi) => {
+  if (!abi || !Array.isArray(abi)) {
+    return 0;
+  }
+  const addTransactionFunction = abi.find((item) => {
+    if (!item || typeof item !== "object") {
+      return false;
+    }
+    const candidate = item;
+    return candidate.type === "function" && candidate.name === "addTransaction";
+  });
+  return Array.isArray(addTransactionFunction?.inputs) ? addTransactionFunction.inputs.length : 0;
+};
 var _encodeAddTransactionData = ({
   client,
   senderAccount,
@@ -701,17 +749,33 @@ var _encodeAddTransactionData = ({
   consensusMaxRotations = client.chain.defaultConsensusMaxRotations
 }) => {
   const validatedSenderAccount = validateAccount(senderAccount);
-  return encodeFunctionData({
-    abi: client.chain.consensusMainContract?.abi,
+  const addTransactionArgs = [
+    validatedSenderAccount.address,
+    recipient,
+    client.chain.defaultNumberOfInitialValidators,
+    consensusMaxRotations,
+    data
+  ];
+  const encodedDataV5 = encodeFunctionData({
+    abi: ADD_TRANSACTION_ABI_V5,
     functionName: "addTransaction",
-    args: [
-      validatedSenderAccount.address,
-      recipient,
-      client.chain.defaultNumberOfInitialValidators,
-      consensusMaxRotations,
-      data
-    ]
+    args: addTransactionArgs
+  });
+  const encodedDataV6 = encodeFunctionData({
+    abi: ADD_TRANSACTION_ABI_V6,
+    functionName: "addTransaction",
+    args: [...addTransactionArgs, 0n]
   });
+  if (getAddTransactionInputCount(client.chain.consensusMainContract?.abi) >= 6) {
+    return {
+      primaryEncodedData: encodedDataV6,
+      fallbackEncodedData: encodedDataV5
+    };
+  }
+  return {
+    primaryEncodedData: encodedDataV5,
+    fallbackEncodedData: encodedDataV6
+  };
 };
 var _encodeSubmitAppealData = ({
   client,
@@ -723,10 +787,17 @@ var _encodeSubmitAppealData = ({
     args: [txId]
   });
 };
+var isAddTransactionAbiMismatchError = (error) => {
+  const errorMessage = String(
+    error?.shortMessage || error?.details || error?.message || error || ""
+  ).toLowerCase();
+  return errorMessage.includes("invalid pointer in tuple") || errorMessage.includes("could not decode") || errorMessage.includes("invalid arrayify value") || errorMessage.includes("types/value length mismatch");
+};
 var _sendTransaction = async ({
   client,
   publicClient,
   encodedData,
+  fallbackEncodedData,
   senderAccount,
   value = 0n
 }) => {
@@ -735,72 +806,82 @@ var _sendTransaction = async ({
   }
   const validatedSenderAccount = validateAccount(senderAccount);
   const nonce = await client.getCurrentNonce({ address: validatedSenderAccount.address });
-  let estimatedGas;
-  try {
-    estimatedGas = await client.estimateTransactionGas({
-      from: validatedSenderAccount.address,
-      to: client.chain.consensusMainContract?.address,
-      data: encodedData,
-      value
-    });
-  } catch (err) {
-    console.error("Gas estimation failed, using default 200_000:", err);
-    estimatedGas = 200000n;
-  }
-  if (validatedSenderAccount?.type === "local") {
-    if (!validatedSenderAccount?.signTransaction) {
-      throw new Error("Account does not support signTransaction");
+  const sendWithEncodedData = async (encodedDataForSend) => {
+    let estimatedGas;
+    try {
+      estimatedGas = await client.estimateTransactionGas({
+        from: validatedSenderAccount.address,
+        to: client.chain.consensusMainContract?.address,
+        data: encodedDataForSend,
+        value
+      });
+    } catch (err) {
+      console.error("Gas estimation failed, using default 200_000:", err);
+      estimatedGas = 200000n;
     }
-    const gasPriceHex = await client.request({
-      method: "eth_gasPrice"
-    });
-    const transactionRequest2 = {
+    if (validatedSenderAccount?.type === "local") {
+      if (!validatedSenderAccount?.signTransaction) {
+        throw new Error("Account does not support signTransaction");
+      }
+      const gasPriceHex = await client.request({
+        method: "eth_gasPrice"
+      });
+      const transactionRequest2 = {
+        account: validatedSenderAccount,
+        to: client.chain.consensusMainContract?.address,
+        data: encodedDataForSend,
+        type: "legacy",
+        nonce: Number(nonce),
+        value,
+        gas: estimatedGas,
+        gasPrice: BigInt(gasPriceHex),
+        chainId: client.chain.id
+      };
+      const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest2);
+      const txHash = await client.sendRawTransaction({ serializedTransaction });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      if (receipt.status === "reverted") {
+        throw new Error("Transaction reverted");
+      }
+      const newTxEvents = parseEventLogs({
+        abi: client.chain.consensusMainContract?.abi,
+        eventName: "NewTransaction",
+        logs: receipt.logs
+      });
+      if (newTxEvents.length === 0) {
+        throw new Error("Transaction not processed by consensus");
+      }
+      return newTxEvents[0].args["txId"];
+    }
+    const transactionRequest = await client.prepareTransactionRequest({
       account: validatedSenderAccount,
       to: client.chain.consensusMainContract?.address,
-      data: encodedData,
+      data: encodedDataForSend,
       type: "legacy",
       nonce: Number(nonce),
       value,
-      gas: estimatedGas,
-      gasPrice: BigInt(gasPriceHex),
-      chainId: client.chain.id
+      gas: estimatedGas
+    });
+    const formattedRequest = {
+      from: transactionRequest.from,
+      to: transactionRequest.to,
+      data: encodedDataForSend,
+      value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0",
+      gas: transactionRequest.gas ? `0x${transactionRequest.gas.toString(16)}` : "0x5208"
     };
-    const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest2);
-    const txHash = await client.sendRawTransaction({ serializedTransaction });
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-    if (receipt.status === "reverted") {
-      throw new Error("Transaction reverted");
-    }
-    const newTxEvents = parseEventLogs({
-      abi: client.chain.consensusMainContract?.abi,
-      eventName: "NewTransaction",
-      logs: receipt.logs
+    return await client.request({
+      method: "eth_sendTransaction",
+      params: [formattedRequest]
     });
-    if (newTxEvents.length === 0) {
-      throw new Error("Transaction not processed by consensus");
+  };
+  try {
+    return await sendWithEncodedData(encodedData);
+  } catch (error) {
+    if (!fallbackEncodedData || !isAddTransactionAbiMismatchError(error)) {
+      throw error;
     }
-    return newTxEvents[0].args["txId"];
+    return await sendWithEncodedData(fallbackEncodedData);
   }
-  const transactionRequest = await client.prepareTransactionRequest({
-    account: validatedSenderAccount,
-    to: client.chain.consensusMainContract?.address,
-    data: encodedData,
-    type: "legacy",
-    nonce: Number(nonce),
-    value,
-    gas: estimatedGas
-  });
-  const formattedRequest = {
-    from: transactionRequest.from,
-    to: transactionRequest.to,
-    data: encodedData,
-    value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0",
-    gas: transactionRequest.gas ? `0x${transactionRequest.gas.toString(16)}` : "0x5208"
-  };
-  return await client.request({
-    method: "eth_sendTransaction",
-    params: [formattedRequest]
-  });
 };
 
 // src/config/transactions.ts
@@ -1803,26 +1884,40 @@ function chainActions(client) {
       if (client.chain?.id === testnetAsimov.id) {
         return;
       }
-      if (!forceReset && client.chain.consensusMainContract?.address && client.chain.consensusMainContract?.abi) {
+      const hasStaticConsensusContract = !!client.chain.consensusMainContract?.address && !!client.chain.consensusMainContract?.abi;
+      const isLocalOrStudioChain = client.chain?.id === localnet.id || client.chain?.id === studionet.id;
+      if (!forceReset && hasStaticConsensusContract && !isLocalOrStudioChain) {
         return;
       }
-      const contractsResponse = await fetch(client.chain.rpcUrls.default.http[0], {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: Date.now(),
-          method: "sim_getConsensusContract",
-          params: ["ConsensusMain"]
-        })
-      });
-      if (!contractsResponse.ok) {
-        throw new Error("Failed to fetch ConsensusMain contract");
+      try {
+        const contractsResponse = await fetch(client.chain.rpcUrls.default.http[0], {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method: "sim_getConsensusContract",
+            params: ["ConsensusMain"]
+          })
+        });
+        if (!contractsResponse.ok) {
+          throw new Error("Failed to fetch ConsensusMain contract");
+        }
+        const consensusMainContract = await contractsResponse.json();
+        if (consensusMainContract?.error || !consensusMainContract?.result?.address || !consensusMainContract?.result?.abi) {
+          throw new Error("ConsensusMain response did not include a valid contract");
+        }
+        client.chain.consensusMainContract = consensusMainContract.result;
+        client.chain.__consensusAbiFetchedFromRpc = true;
+      } catch (error) {
+        if (hasStaticConsensusContract) {
+          client.chain.__consensusAbiFetchedFromRpc = false;
+          return;
+        }
+        throw error;
       }
-      const consensusMainContract = await contractsResponse.json();
-      client.chain.consensusMainContract = consensusMainContract.result;
     }
   };
 }

package/package.json

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