genlayer-js 0.19.1 → 0.19.2

package/dist/index.cjs

@@ -628,7 +628,7 @@ var contractActions = (client, publicClient) => {
       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,
@@ -638,7 +638,8 @@ var contractActions = (client, publicClient) => {
       return _sendTransaction({
         client,
         publicClient,
-        encodedData,
+        encodedData: primaryEncodedData,
+        fallbackEncodedData,
         senderAccount,
         value
       });
@@ -660,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,
@@ -670,7 +671,8 @@ var contractActions = (client, publicClient) => {
       return _sendTransaction({
         client,
         publicClient,
-        encodedData,
+        encodedData: primaryEncodedData,
+        fallbackEncodedData,
         senderAccount
       });
     },
@@ -754,18 +756,26 @@ var _encodeAddTransactionData = ({
     consensusMaxRotations,
     data
   ];
-  if (getAddTransactionInputCount(_optionalChain([client, 'access', _12 => _12.chain, 'access', _13 => _13.consensusMainContract, 'optionalAccess', _14 => _14.abi])) >= 6) {
-    return _viem.encodeFunctionData.call(void 0, {
-      abi: ADD_TRANSACTION_ABI_V6,
-      functionName: "addTransaction",
-      args: [...addTransactionArgs, 0n]
-    });
-  }
-  return _viem.encodeFunctionData.call(void 0, {
+  const encodedDataV5 = _viem.encodeFunctionData.call(void 0, {
     abi: ADD_TRANSACTION_ABI_V5,
     functionName: "addTransaction",
     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,
@@ -777,84 +787,101 @@ var _encodeSubmitAppealData = ({
     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', _18 => _18.chain, 'access', _19 => _19.consensusMainContract, 'optionalAccess', _20 => _20.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', _21 => _21.chain, 'access', _22 => _22.consensusMainContract, 'optionalAccess', _23 => _23.address]),
-      data: encodedData,
-      value
-    });
-  } catch (err) {
-    console.error("Gas estimation failed, using default 200_000:", err);
-    estimatedGas = 200000n;
-  }
-  if (_optionalChain([validatedSenderAccount, 'optionalAccess', _24 => _24.type]) === "local") {
-    if (!_optionalChain([validatedSenderAccount, 'optionalAccess', _25 => _25.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', _26 => _26.chain, 'access', _27 => _27.consensusMainContract, 'optionalAccess', _28 => _28.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', _29 => _29.chain, 'access', _30 => _30.consensusMainContract, 'optionalAccess', _31 => _31.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', _32 => _32.chain, 'access', _33 => _33.consensusMainContract, 'optionalAccess', _34 => _34.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
@@ -1061,7 +1088,7 @@ var simplifyTransactionReceipt = (tx) => {
 var decodeLocalnetTransaction = (tx) => {
   if (!tx.data) return tx;
   try {
-    const leaderReceipt = _optionalChain([tx, 'access', _35 => _35.consensus_data, 'optionalAccess', _36 => _36.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) => {
@@ -1092,7 +1119,7 @@ var decodeLocalnetTransaction = (tx) => {
         }
       });
     }
-    if (_optionalChain([tx, 'access', _37 => _37.data, 'optionalAccess', _38 => _38.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))
@@ -1154,8 +1181,8 @@ var transactionActions = (client, publicClient) => ({
       return decodeLocalnetTransaction(transaction2);
     }
     const transaction = await publicClient.readContract({
-      address: _optionalChain([client, 'access', _39 => _39.chain, 'access', _40 => _40.consensusDataContract, 'optionalAccess', _41 => _41.address]),
-      abi: _optionalChain([client, 'access', _42 => _42.chain, 'access', _43 => _43.consensusDataContract, 'optionalAccess', _44 => _44.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,
@@ -1167,7 +1194,7 @@ var transactionActions = (client, publicClient) => ({
   },
   estimateTransactionGas: async (transactionParams) => {
     const formattedParams = {
-      from: transactionParams.from || _optionalChain([client, 'access', _45 => _45.account, 'optionalAccess', _46 => _46.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"
@@ -1209,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', _47 => _47.blockExplorers, 'optionalAccess', _48 => _48.default, 'access', _49 => _49.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) {
@@ -1243,10 +1270,10 @@ var metamaskClient = async (snapSource = "npm") => {
   }
   const isFlask = async () => {
     try {
-      const clientVersion = await _optionalChain([window, 'access', _50 => _50.ethereum, 'optionalAccess', _51 => _51.request, 'call', _52 => _52({
+      const clientVersion = await _optionalChain([window, 'access', _53 => _53.ethereum, 'optionalAccess', _54 => _54.request, 'call', _55 => _55({
         method: "web3_clientVersion"
       })]);
-      return _optionalChain([clientVersion, 'optionalAccess', _53 => _53.includes, 'call', _54 => _54("flask")]);
+      return _optionalChain([clientVersion, 'optionalAccess', _56 => _56.includes, 'call', _57 => _57("flask")]);
     } catch (error) {
       console.error("Error detecting Flask:", error);
       return false;
@@ -1254,7 +1281,7 @@ var metamaskClient = async (snapSource = "npm") => {
   };
   const installedSnaps = async () => {
     try {
-      return await _optionalChain([window, 'access', _55 => _55.ethereum, 'optionalAccess', _56 => _56.request, 'call', _57 => _57({
+      return await _optionalChain([window, 'access', _58 => _58.ethereum, 'optionalAccess', _59 => _59.request, 'call', _60 => _60({
         method: "wallet_getSnaps"
       })]);
     } catch (error) {
@@ -1341,7 +1368,7 @@ function extractRevertReason(err) {
     }
     const revertError = err.walk((e) => e instanceof _viem.ContractFunctionRevertedError);
     if (revertError instanceof _viem.ContractFunctionRevertedError) {
-      if (_optionalChain([revertError, 'access', _58 => _58.data, 'optionalAccess', _59 => _59.errorName])) {
+      if (_optionalChain([revertError, 'access', _61 => _61.data, 'optionalAccess', _62 => _62.errorName])) {
         return revertError.data.errorName;
       }
       return revertError.reason || "Unknown reason";
@@ -1429,7 +1456,7 @@ var stakingActions = (client, publicClient) => {
   };
   const getStakingAddress = () => {
     const stakingConfig = client.chain.stakingContract;
-    if (!_optionalChain([stakingConfig, 'optionalAccess', _60 => _60.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;
@@ -1510,10 +1537,10 @@ var stakingActions = (client, publicClient) => {
       return executeWrite({ to: getStakingAddress(), data });
     },
     validatorClaim: async (options) => {
-      if (!_optionalChain([options, 'optionalAccess', _61 => _61.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', _62 => _62.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",
@@ -1854,11 +1881,11 @@ var stakingActions = (client, publicClient) => {
 function chainActions(client) {
   return {
     initializeConsensusSmartContract: async (forceReset = false) => {
-      if (_optionalChain([client, 'access', _63 => _63.chain, 'optionalAccess', _64 => _64.id]) === _chunk5TKVNHAOcjs.testnetAsimov.id) {
+      if (_optionalChain([client, 'access', _66 => _66.chain, 'optionalAccess', _67 => _67.id]) === _chunk5TKVNHAOcjs.testnetAsimov.id) {
         return;
       }
-      const hasStaticConsensusContract = !!_optionalChain([client, 'access', _65 => _65.chain, 'access', _66 => _66.consensusMainContract, 'optionalAccess', _67 => _67.address]) && !!_optionalChain([client, 'access', _68 => _68.chain, 'access', _69 => _69.consensusMainContract, 'optionalAccess', _70 => _70.abi]);
-      const isLocalOrStudioChain = _optionalChain([client, 'access', _71 => _71.chain, 'optionalAccess', _72 => _72.id]) === _chunk5TKVNHAOcjs.localnet.id || _optionalChain([client, 'access', _73 => _73.chain, 'optionalAccess', _74 => _74.id]) === _chunk5TKVNHAOcjs.studionet.id;
+      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;
       }
@@ -1879,7 +1906,7 @@ function chainActions(client) {
           throw new Error("Failed to fetch ConsensusMain contract");
         }
         const consensusMainContract = await contractsResponse.json();
-        if (_optionalChain([consensusMainContract, 'optionalAccess', _75 => _75.error]) || !_optionalChain([consensusMainContract, 'optionalAccess', _76 => _76.result, 'optionalAccess', _77 => _77.address]) || !_optionalChain([consensusMainContract, 'optionalAccess', _78 => _78.result, 'optionalAccess', _79 => _79.abi])) {
+        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;

package/dist/index.js

@@ -628,7 +628,7 @@ var contractActions = (client, publicClient) => {
       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,
@@ -638,7 +638,8 @@ var contractActions = (client, publicClient) => {
       return _sendTransaction({
         client,
         publicClient,
-        encodedData,
+        encodedData: primaryEncodedData,
+        fallbackEncodedData,
         senderAccount,
         value
       });
@@ -660,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,
@@ -670,7 +671,8 @@ var contractActions = (client, publicClient) => {
       return _sendTransaction({
         client,
         publicClient,
-        encodedData,
+        encodedData: primaryEncodedData,
+        fallbackEncodedData,
         senderAccount
       });
     },
@@ -754,18 +756,26 @@ var _encodeAddTransactionData = ({
     consensusMaxRotations,
     data
   ];
-  if (getAddTransactionInputCount(client.chain.consensusMainContract?.abi) >= 6) {
-    return encodeFunctionData({
-      abi: ADD_TRANSACTION_ABI_V6,
-      functionName: "addTransaction",
-      args: [...addTransactionArgs, 0n]
-    });
-  }
-  return encodeFunctionData({
+  const encodedDataV5 = encodeFunctionData({
     abi: ADD_TRANSACTION_ABI_V5,
     functionName: "addTransaction",
     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,
@@ -777,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
 }) => {
@@ -789,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

package/package.json

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