@fuel-ts/account 0.101.0 → 0.101.2

package/dist/index.mjs

@@ -710,7 +710,7 @@ import { randomBytes as randomBytes2 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode19, FuelError as FuelError21 } from "@fuel-ts/errors";
 import { bn as bn21 } from "@fuel-ts/math";
 import { InputType as InputType8, OutputType as OutputType9 } from "@fuel-ts/transactions";
-import { arrayify as arrayify16, hexlify as hexlify18, isDefined as isDefined4 } from "@fuel-ts/utils";
+import { arrayify as arrayify17, hexlify as hexlify18, isDefined as isDefined4 } from "@fuel-ts/utils";
 import { clone as clone9 } from "ramda";
 
 // src/providers/coin-quantity.ts
@@ -751,8 +751,8 @@ var addAmountToCoinQuantities = /* @__PURE__ */ __name((params) => {
 import { Address as Address2, isB256 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode17, FuelError as FuelError19 } from "@fuel-ts/errors";
 import { bn as bn18 } from "@fuel-ts/math";
-import { InputMessageCoder as InputMessageCoder2, TransactionCoder as TransactionCoder6, TransactionType as TransactionType11 } from "@fuel-ts/transactions";
-import { arrayify as arrayify12, hexlify as hexlify17, DateTime as DateTime2, isDefined as isDefined3, sleep as sleep2 } from "@fuel-ts/utils";
+import { InputMessageCoder as InputMessageCoder2, TransactionCoder as TransactionCoder7, TransactionType as TransactionType11 } from "@fuel-ts/transactions";
+import { arrayify as arrayify13, hexlify as hexlify17, DateTime as DateTime2, isDefined as isDefined3, sleep as sleep2 } from "@fuel-ts/utils";
 import { checkFuelCoreVersionCompatibility, versions } from "@fuel-ts/versions";
 import { GraphQLClient } from "graphql-request";
 import gql2 from "graphql-tag";
@@ -3262,7 +3262,8 @@ import {
   FAILED_ASSERT_SIGNAL,
   FAILED_TRANSFER_TO_ADDRESS_SIGNAL as FAILED_TRANSFER_TO_ADDRESS_SIGNAL2,
   PANIC_REASONS,
-  PANIC_DOC_URL
+  PANIC_DOC_URL,
+  SwaySignalErrors
 } from "@fuel-ts/transactions/configs";
 var assemblePanicError = /* @__PURE__ */ __name((statusReason, metadata) => {
   let errorMessage = `The transaction reverted with reason: "${statusReason}".`;
@@ -3279,58 +3280,97 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   });
 }, "assemblePanicError");
 var stringify = /* @__PURE__ */ __name((obj) => JSON.stringify(obj, null, 2), "stringify");
-var assembleRevertError = /* @__PURE__ */ __name((receipts, logs, metadata) => {
+var assembleSignalErrorMessage = /* @__PURE__ */ __name((reasonHex, logs, metadata) => {
   let errorMessage = "The transaction reverted with an unknown reason.";
-  const revertReceipt = receipts.find(({ type }) => type === ReceiptType4.Revert);
   let reason = "";
-  if (revertReceipt) {
-    const reasonHex = bn7(revertReceipt.val).toHex();
-    const lastLog = logs[logs.length - 1];
-    const lastButOneLog = logs[logs.length - 2];
-    switch (reasonHex) {
-      case FAILED_REQUIRE_SIGNAL: {
-        reason = "require";
-        errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify(lastLog) : "an error."}.`;
-        break;
-      }
-      case FAILED_ASSERT_EQ_SIGNAL: {
-        const suffix = logs.length >= 2 ? ` comparing ${stringify(lastLog)} and ${stringify(lastButOneLog)}.` : ".";
-        reason = "assert_eq";
-        errorMessage = `The transaction reverted because of an "assert_eq" statement${suffix}`;
-        break;
-      }
-      case FAILED_ASSERT_NE_SIGNAL: {
-        const suffix = logs.length >= 2 ? ` comparing ${stringify(lastButOneLog)} and ${stringify(lastLog)}.` : ".";
-        reason = "assert_ne";
-        errorMessage = `The transaction reverted because of an "assert_ne" statement${suffix}`;
-        break;
-      }
-      case FAILED_ASSERT_SIGNAL:
-        reason = "assert";
-        errorMessage = `The transaction reverted because an "assert" statement failed to evaluate to true.`;
-        break;
-      case FAILED_TRANSFER_TO_ADDRESS_SIGNAL2:
-        reason = "MissingOutputVariable";
-        errorMessage = `The transaction reverted because it's missing an "OutputVariable".`;
-        break;
-      default:
-        throw new FuelError8(
-          ErrorCode8.UNKNOWN,
-          `The transaction reverted with an unknown reason: ${revertReceipt.val}`,
-          {
-            ...metadata,
-            reason: "unknown"
-          }
-        );
+  const lastLog = logs[logs.length - 1];
+  const lastButOneLog = logs[logs.length - 2];
+  switch (reasonHex) {
+    case FAILED_REQUIRE_SIGNAL: {
+      reason = "require";
+      errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify(lastLog) : "an error."}.`;
+      break;
+    }
+    case FAILED_ASSERT_EQ_SIGNAL: {
+      const suffix = logs.length >= 2 ? ` comparing ${stringify(lastLog)} and ${stringify(lastButOneLog)}.` : ".";
+      reason = "assert_eq";
+      errorMessage = `The transaction reverted because of an "assert_eq" statement${suffix}`;
+      break;
+    }
+    case FAILED_ASSERT_NE_SIGNAL: {
+      const suffix = logs.length >= 2 ? ` comparing ${stringify(lastButOneLog)} and ${stringify(lastLog)}.` : ".";
+      reason = "assert_ne";
+      errorMessage = `The transaction reverted because of an "assert_ne" statement${suffix}`;
+      break;
+    }
+    case FAILED_ASSERT_SIGNAL:
+      reason = "assert";
+      errorMessage = `The transaction reverted because an "assert" statement failed to evaluate to true.`;
+      break;
+    case FAILED_TRANSFER_TO_ADDRESS_SIGNAL2:
+      reason = "MissingOutputVariable";
+      errorMessage = `The transaction reverted because it's missing an "OutputVariable".`;
+      break;
+    default:
+      reason = `revert_with_log`;
+      errorMessage = `The transaction reverted because a "revert_with_log" statement has thrown ${logs.length ? stringify(lastLog) : "an error."}.`;
+      break;
+  }
+  return new FuelError8(ErrorCode8.SCRIPT_REVERTED, errorMessage, {
+    ...metadata,
+    reason
+  });
+}, "assembleSignalErrorMessage");
+function buildAbiErrorMessage(abiError, logs, metadata, reason) {
+  const { pos, msg } = abiError;
+  let errorMessage = "";
+  const positionMessage = pos ? `
+
+This error originated at ${JSON.stringify(pos, null, 2)}` : "";
+  if (msg) {
+    errorMessage = `A sway "panic" expression was invoked with the message: "${msg}".${positionMessage}`;
+  } else {
+    const value = logs[logs.length - 1];
+    errorMessage = `A sway "panic" expression was invoked with the value: ${JSON.stringify(value)}.${positionMessage}`;
+  }
+  return new FuelError8(ErrorCode8.SCRIPT_REVERTED, errorMessage, {
+    ...metadata,
+    reason
+  });
+}
+__name(buildAbiErrorMessage, "buildAbiErrorMessage");
+function findErrorInAbis(statusReason, abis = []) {
+  for (const abi of abis) {
+    if (abi.errorCodes?.[statusReason]) {
+      return abi.errorCodes[statusReason];
     }
   }
+  return void 0;
+}
+__name(findErrorInAbis, "findErrorInAbis");
+var assembleRevertError = /* @__PURE__ */ __name((_receipts, logs, metadata, statusReason, abis) => {
+  const match = statusReason.match(/Revert\((\d+)\)/);
+  const reason = match?.[1] ?? statusReason;
+  const reasonHex = bn7(reason).toHex();
+  if (Object.values(SwaySignalErrors).includes(reasonHex)) {
+    return assembleSignalErrorMessage(reasonHex, logs, metadata);
+  }
+  let abiError;
+  if (abis) {
+    const abisArr = [abis.main, ...Object.values(abis.otherContractsAbis)];
+    abiError = findErrorInAbis(reason, abisArr);
+  }
+  if (abiError) {
+    return buildAbiErrorMessage(abiError, logs, metadata, reason);
+  }
+  const errorMessage = `The transaction reverted with reason: ${reason}.`;
   return new FuelError8(ErrorCode8.SCRIPT_REVERTED, errorMessage, {
     ...metadata,
     reason
   });
 }, "assembleRevertError");
 var extractTxError = /* @__PURE__ */ __name((params) => {
-  const { receipts, statusReason, logs, groupedLogs } = params;
+  const { receipts, statusReason, logs, groupedLogs, abis } = params;
   const isPanic = receipts.some(({ type }) => type === ReceiptType4.Panic);
   const isRevert = receipts.some(({ type }) => type === ReceiptType4.Revert);
   const metadata = {
@@ -3344,7 +3384,7 @@ var extractTxError = /* @__PURE__ */ __name((params) => {
   if (isPanic) {
     return assemblePanicError(statusReason, metadata);
   }
-  return assembleRevertError(receipts, logs, metadata);
+  return assembleRevertError(receipts, logs, metadata, statusReason, abis);
 }, "extractTxError");
 
 // src/providers/utils/merge-quantities.ts
@@ -4932,12 +4972,12 @@ var ResourceCache = class {
 // src/providers/transaction-response/transaction-response.ts
 import { ErrorCode as ErrorCode15, FuelError as FuelError17 } from "@fuel-ts/errors";
 import { bn as bn17 } from "@fuel-ts/math";
-import { TransactionCoder as TransactionCoder5, TxPointerCoder } from "@fuel-ts/transactions";
-import { arrayify as arrayify11 } from "@fuel-ts/utils";
+import { TransactionCoder as TransactionCoder6, TxPointerCoder } from "@fuel-ts/transactions";
+import { arrayify as arrayify12 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/assemble-transaction-summary.ts
 import { bn as bn16 } from "@fuel-ts/math";
-import { PolicyType as PolicyType3, TransactionCoder as TransactionCoder4 } from "@fuel-ts/transactions";
+import { PolicyType as PolicyType3, TransactionCoder as TransactionCoder5 } from "@fuel-ts/transactions";
 import { DateTime, hexlify as hexlify16 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/calculate-tx-fee-for-summary.ts
@@ -5009,8 +5049,47 @@ var calculateTXFeeForSummary = /* @__PURE__ */ __name((params) => {
 // src/providers/transaction-summary/operations.ts
 import { ZeroBytes32 as ZeroBytes329 } from "@fuel-ts/address/configs";
 import { ErrorCode as ErrorCode13, FuelError as FuelError15 } from "@fuel-ts/errors";
-import { bn as bn14 } from "@fuel-ts/math";
-import { ReceiptType as ReceiptType5, TransactionType as TransactionType10 } from "@fuel-ts/transactions";
+import { bn as bn14, toBytes } from "@fuel-ts/math";
+import { ReceiptType as ReceiptType5, TransactionCoder as TransactionCoder4, TransactionType as TransactionType10 } from "@fuel-ts/transactions";
+import { arrayify as arrayify11, concat as concat3 } from "@fuel-ts/utils";
+
+// src/providers/transaction-summary/call.ts
+import { StdStringCoder } from "@fuel-ts/abi-coder";
+import { Interface as Interface2 } from "@fuel-ts/abi-coder";
+var getFunctionCall = /* @__PURE__ */ __name(({
+  abi,
+  receipt,
+  offset,
+  scriptData
+}) => {
+  const [functionSelector, argumentsOffset] = new StdStringCoder().decode(scriptData, offset);
+  const abiInterface = new Interface2(abi);
+  const functionFragment = abiInterface.getFunction(functionSelector);
+  const inputs = functionFragment.jsonFn.inputs;
+  let argumentsProvided;
+  if (inputs.length) {
+    const functionArgsBytes = scriptData.slice(argumentsOffset);
+    const decodedArguments = functionFragment.decodeArguments(functionArgsBytes);
+    argumentsProvided = inputs.reduce((prev, input, index) => {
+      const value = decodedArguments?.[index];
+      const name = input.name;
+      if (name) {
+        return {
+          ...prev,
+          // reparse to remove bn
+          [name]: JSON.parse(JSON.stringify(value))
+        };
+      }
+      return prev;
+    }, {});
+  }
+  return {
+    functionSignature: functionFragment.signature,
+    functionName: functionFragment.name,
+    argumentsProvided,
+    ...receipt.amount?.isZero() ? {} : { amount: receipt.amount, assetId: receipt.assetId }
+  };
+}, "getFunctionCall");
 
 // src/providers/transaction-summary/input.ts
 import { ErrorCode as ErrorCode12, FuelError as FuelError14 } from "@fuel-ts/errors";
@@ -5345,12 +5424,45 @@ function getWithdrawFromFuelOperations({
   return withdrawFromFuelOperations;
 }
 __name(getWithdrawFromFuelOperations, "getWithdrawFromFuelOperations");
-function getContractCalls(contractInput, abiMap, _receipt, _rawPayload, _maxInputs) {
-  const abi = abiMap?.[contractInput.contractID];
-  if (!abi) {
-    return [];
+function findBytesSegmentIndex(whole, segment) {
+  for (let i = 0; i <= whole.length - segment.length; i++) {
+    let match = true;
+    for (let j = 0; j < segment.length; j++) {
+      if (whole[i + j] !== segment[j]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      return i;
+    }
   }
-  return [];
+  return -1;
+}
+__name(findBytesSegmentIndex, "findBytesSegmentIndex");
+function getContractCalls(contractInput, abiMap, receipt, scriptData) {
+  const calls = [];
+  const abi = abiMap?.[contractInput.contractID];
+  if (!abi || !scriptData) {
+    return calls;
+  }
+  const bytesSegment = concat3([
+    arrayify11(receipt.to),
+    // Contract ID (32 bytes)
+    toBytes(receipt.param1.toHex(), 8),
+    // Function selector offset (8 bytes)
+    toBytes(receipt.param2.toHex(), 8)
+    // Function args offset (8 bytes)
+  ]);
+  const segmentIndex = findBytesSegmentIndex(scriptData, bytesSegment);
+  const canDecodeFunctionCall = segmentIndex !== -1;
+  if (!canDecodeFunctionCall) {
+    return calls;
+  }
+  const offset = segmentIndex + bytesSegment.length;
+  const call = getFunctionCall({ abi, receipt, offset, scriptData });
+  calls.push(call);
+  return calls;
 }
 __name(getContractCalls, "getContractCalls");
 function getAssetsSent(receipt) {
@@ -5362,14 +5474,14 @@ function getAssetsSent(receipt) {
   ];
 }
 __name(getAssetsSent, "getAssetsSent");
-function processCallReceipt(receipt, contractInput, inputs, abiMap, rawPayload, maxInputs, baseAssetId) {
+function processCallReceipt(receipt, contractInput, inputs, abiMap, scriptData, baseAssetId) {
   const assetId = receipt.assetId === ZeroBytes329 ? baseAssetId : receipt.assetId;
   const input = getInputFromAssetId(inputs, assetId, assetId === baseAssetId);
   if (!input) {
     return [];
   }
   const inputAddress = getInputAccountAddress(input);
-  const calls = getContractCalls(contractInput, abiMap, receipt, rawPayload, maxInputs);
+  const calls = getContractCalls(contractInput, abiMap, receipt, scriptData);
   return [
     {
       name: "Contract call" /* contractCall */,
@@ -5394,7 +5506,6 @@ function getContractCallOperations({
   receipts,
   abiMap,
   rawPayload,
-  maxInputs,
   baseAssetId
 }) {
   const contractCallReceipts = getReceiptsCall(receipts);
@@ -5404,16 +5515,15 @@ function getContractCallOperations({
     if (!contractInput) {
       return [];
     }
+    let scriptData;
+    if (rawPayload) {
+      const [transaction] = new TransactionCoder4().decode(arrayify11(rawPayload), 0);
+      if (transaction.type === TransactionType10.Script) {
+        scriptData = arrayify11(transaction.scriptData);
+      }
+    }
     return contractCallReceipts.filter((receipt) => receipt.to === contractInput.contractID).flatMap(
-      (receipt) => processCallReceipt(
-        receipt,
-        contractInput,
-        inputs,
-        abiMap,
-        rawPayload,
-        maxInputs,
-        baseAssetId
-      )
+      (receipt) => processCallReceipt(receipt, contractInput, inputs, abiMap, scriptData, baseAssetId)
     );
   });
 }
@@ -5830,7 +5940,7 @@ function assemblePreConfirmationTransactionSummary(params) {
     type = getTransactionTypeName(transaction.type);
     tip = bn16(transaction.policies?.find((policy) => policy.type === PolicyType3.Tip)?.data);
     if (receipts) {
-      const rawPayload = hexlify16(new TransactionCoder4().encode(transaction));
+      const rawPayload = hexlify16(new TransactionCoder5().encode(transaction));
       operations = getOperations({
         transactionType: transaction.type,
         inputs: transaction.inputs || [],
@@ -5876,7 +5986,7 @@ function assemblePreConfirmationTransactionSummary(params) {
 __name(assemblePreConfirmationTransactionSummary, "assemblePreConfirmationTransactionSummary");
 
 // src/providers/transaction-response/getAllDecodedLogs.ts
-import { Interface as Interface2, BigNumberCoder } from "@fuel-ts/abi-coder";
+import { Interface as Interface3, BigNumberCoder } from "@fuel-ts/abi-coder";
 import { ZeroBytes32 as ZeroBytes3210 } from "@fuel-ts/address/configs";
 import { ReceiptType as ReceiptType7 } from "@fuel-ts/transactions";
 function getAllDecodedLogs(opts) {
@@ -5896,7 +6006,7 @@ function getAllDecodedLogs(opts) {
         const isLogFromMainAbi = receipt.id === ZeroBytes3210 || mainContract === receipt.id;
         const isDecodable = isLogFromMainAbi || externalAbis[receipt.id];
         if (isDecodable) {
-          const interfaceToUse = isLogFromMainAbi ? new Interface2(mainAbi) : new Interface2(externalAbis[receipt.id]);
+          const interfaceToUse = isLogFromMainAbi ? new Interface3(mainAbi) : new Interface3(externalAbis[receipt.id]);
           const data = receipt.type === ReceiptType7.Log ? new BigNumberCoder("u64").encode(receipt.ra) : receipt.data;
           const [decodedLog] = interfaceToUse.decodeLog(data, receipt.rb.toString());
           logs.push(decodedLog);
@@ -5996,8 +6106,8 @@ var TransactionResponse = class _TransactionResponse {
     }
     const gqlTransaction = this.gqlTransaction ?? await this.fetch();
     const { rawPayload } = gqlTransaction;
-    const bytes = arrayify11(rawPayload);
-    const [tx] = new TransactionCoder5().decode(bytes, 0);
+    const bytes = arrayify12(rawPayload);
+    const [tx] = new TransactionCoder6().decode(bytes, 0);
     return {
       tx,
       bytes
@@ -6184,6 +6294,7 @@ var TransactionResponse = class _TransactionResponse {
       ...transactionSummary
     };
     let { logs, groupedLogs } = { logs: [], groupedLogs: {} };
+    let abis;
     if (this.abis) {
       ({ logs, groupedLogs } = getAllDecodedLogs({
         receipts: transactionSummary.receipts,
@@ -6192,6 +6303,7 @@ var TransactionResponse = class _TransactionResponse {
       }));
       transactionResult.logs = logs;
       transactionResult.groupedLogs = groupedLogs;
+      abis = this.abis;
     }
     const { receipts } = transactionResult;
     const status = this.getTransactionStatus();
@@ -6201,7 +6313,8 @@ var TransactionResponse = class _TransactionResponse {
         receipts,
         statusReason: reason,
         logs,
-        groupedLogs
+        groupedLogs,
+        abis
       });
     }
     return transactionResult;
@@ -6263,7 +6376,7 @@ var TransactionResponse = class _TransactionResponse {
 };
 
 // src/providers/transaction-response/getDecodedLogs.ts
-import { Interface as Interface3, BigNumberCoder as BigNumberCoder2 } from "@fuel-ts/abi-coder";
+import { Interface as Interface4, BigNumberCoder as BigNumberCoder2 } from "@fuel-ts/abi-coder";
 import { ZeroBytes32 as ZeroBytes3211 } from "@fuel-ts/address/configs";
 import { ReceiptType as ReceiptType8 } from "@fuel-ts/transactions";
 function getDecodedLogs(receipts, mainAbi, externalAbis = {}) {
@@ -6279,7 +6392,7 @@ function getDecodedLogs(receipts, mainAbi, externalAbis = {}) {
       const isLogFromMainAbi = receipt.id === ZeroBytes3211 || mainContract === receipt.id;
       const isDecodable = isLogFromMainAbi || externalAbis[receipt.id];
       if (isDecodable) {
-        const interfaceToUse = isLogFromMainAbi ? new Interface3(mainAbi) : new Interface3(externalAbis[receipt.id]);
+        const interfaceToUse = isLogFromMainAbi ? new Interface4(mainAbi) : new Interface4(externalAbis[receipt.id]);
         const data = receipt.type === ReceiptType8.Log ? new BigNumberCoder2("u64").encode(receipt.ra) : receipt.data;
         const [decodedLog] = interfaceToUse.decodeLog(data, receipt.rb.toString());
         logs.push(decodedLog);
@@ -7666,7 +7779,7 @@ var Provider = class _Provider {
       },
       transactionIds: block.transactions.map((tx) => tx.id),
       transactions: block.transactions.map(
-        (tx) => new TransactionCoder6().decode(arrayify12(tx.rawPayload), 0)?.[0]
+        (tx) => new TransactionCoder7().decode(arrayify13(tx.rawPayload), 0)?.[0]
       )
     };
   }
@@ -7682,8 +7795,8 @@ var Provider = class _Provider {
       return null;
     }
     try {
-      return new TransactionCoder6().decode(
-        arrayify12(transaction.rawPayload),
+      return new TransactionCoder7().decode(
+        arrayify13(transaction.rawPayload),
         0
       )?.[0];
     } catch (error) {
@@ -7708,10 +7821,10 @@ var Provider = class _Provider {
         paginationLimit: TRANSACTIONS_PAGE_SIZE_LIMIT
       })
     });
-    const coder = new TransactionCoder6();
+    const coder = new TransactionCoder7();
     const transactions = edges.map(({ node: { rawPayload } }) => {
       try {
-        return coder.decode(arrayify12(rawPayload), 0)[0];
+        return coder.decode(arrayify13(rawPayload), 0)[0];
       } catch (error) {
         if (error instanceof FuelError19 && error.code === ErrorCode17.UNSUPPORTED_TRANSACTION_TYPE) {
           console.warn("Unsupported transaction type encountered");
@@ -8082,18 +8195,21 @@ var Provider = class _Provider {
   extractDryRunError(transactionRequest, receipts, reason) {
     let logs = [];
     let groupedLogs = {};
+    let abis;
     if (transactionRequest.type === TransactionType11.Script && transactionRequest.abis) {
       ({ logs, groupedLogs } = getAllDecodedLogs({
         receipts,
         mainAbi: transactionRequest.abis.main,
         externalAbis: transactionRequest.abis.otherContractsAbis
       }));
+      abis = transactionRequest.abis;
     }
     return extractTxError({
       logs,
       groupedLogs,
       receipts,
-      statusReason: reason
+      statusReason: reason,
+      abis
     });
   }
   /**
@@ -8164,8 +8280,8 @@ var Provider = class _Provider {
 // src/providers/transaction-summary/get-transaction-summary.ts
 import { ErrorCode as ErrorCode18, FuelError as FuelError20 } from "@fuel-ts/errors";
 import { bn as bn19 } from "@fuel-ts/math";
-import { TransactionCoder as TransactionCoder7 } from "@fuel-ts/transactions";
-import { arrayify as arrayify13 } from "@fuel-ts/utils";
+import { TransactionCoder as TransactionCoder8 } from "@fuel-ts/transactions";
+import { arrayify as arrayify14 } from "@fuel-ts/utils";
 async function getTransactionSummary(params) {
   const { id, provider, abiMap } = params;
   const { transaction: gqlTransaction } = await provider.operations.getTransactionWithReceipts({
@@ -8177,8 +8293,8 @@ async function getTransactionSummary(params) {
       `Transaction not found for given id: ${id}.`
     );
   }
-  const [decodedTransaction] = new TransactionCoder7().decode(
-    arrayify13(gqlTransaction.rawPayload),
+  const [decodedTransaction] = new TransactionCoder8().decode(
+    arrayify14(gqlTransaction.rawPayload),
     0
   );
   let txReceipts = [];
@@ -8200,7 +8316,7 @@ async function getTransactionSummary(params) {
     id: gqlTransaction.id,
     receipts,
     transaction: decodedTransaction,
-    transactionBytes: arrayify13(gqlTransaction.rawPayload),
+    transactionBytes: arrayify14(gqlTransaction.rawPayload),
     gqlTransactionStatus: gqlTransaction.status,
     gasPerByte: bn19(gasPerByte),
     gasPriceFactor: bn19(gasPriceFactor),
@@ -8266,7 +8382,7 @@ async function getTransactionsSummaries(params) {
   const transactions = edges.map((edge) => {
     const { node: gqlTransaction } = edge;
     const { id, rawPayload, status } = gqlTransaction;
-    const [decodedTransaction] = new TransactionCoder7().decode(arrayify13(rawPayload), 0);
+    const [decodedTransaction] = new TransactionCoder8().decode(arrayify14(rawPayload), 0);
     let txReceipts = [];
     if (gqlTransaction?.status && "receipts" in gqlTransaction.status) {
       txReceipts = gqlTransaction.status.receipts;
@@ -8276,7 +8392,7 @@ async function getTransactionsSummaries(params) {
       id,
       receipts,
       transaction: decodedTransaction,
-      transactionBytes: arrayify13(rawPayload),
+      transactionBytes: arrayify14(rawPayload),
       gqlTransactionStatus: status,
       abiMap,
       gasPerByte,
@@ -8301,8 +8417,8 @@ __name(getTransactionsSummaries, "getTransactionsSummaries");
 
 // src/providers/transaction-summary/assemble-transaction-summary-from-serialized.ts
 import { bn as bn20 } from "@fuel-ts/math";
-import { TransactionCoder as TransactionCoder8 } from "@fuel-ts/transactions";
-import { arrayify as arrayify14 } from "@fuel-ts/utils";
+import { TransactionCoder as TransactionCoder9 } from "@fuel-ts/transactions";
+import { arrayify as arrayify15 } from "@fuel-ts/utils";
 var assembleTransactionSummaryFromJson = /* @__PURE__ */ __name(async (opts) => {
   const { provider, transactionSummary } = opts;
   const { id, transactionBytes, gasPrice, receipts } = transactionSummary;
@@ -8314,8 +8430,8 @@ var assembleTransactionSummaryFromJson = /* @__PURE__ */ __name(async (opts) =>
       gasCosts
     }
   } = await provider.getChain();
-  const deserializedTransactionBytes = arrayify14(transactionBytes);
-  const [transaction] = new TransactionCoder8().decode(deserializedTransactionBytes, 0);
+  const deserializedTransactionBytes = arrayify15(transactionBytes);
+  const [transaction] = new TransactionCoder9().decode(deserializedTransactionBytes, 0);
   return assembleTransactionSummary({
     id,
     transaction,
@@ -8379,15 +8495,15 @@ var AbstractAccount = class {
 // src/utils/formatTransferToContractScriptData.ts
 import { ASSET_ID_LEN, BigNumberCoder as BigNumberCoder3, CONTRACT_ID_LEN, WORD_SIZE } from "@fuel-ts/abi-coder";
 import { Address as Address3 } from "@fuel-ts/address";
-import { arrayify as arrayify15, concat as concat3 } from "@fuel-ts/utils";
+import { arrayify as arrayify16, concat as concat4 } from "@fuel-ts/utils";
 import * as asm from "@fuels/vm-asm";
 var formatTransferToContractScriptData = /* @__PURE__ */ __name((transferParams) => {
   const numberCoder = new BigNumberCoder3("u64");
   return transferParams.reduce((acc, transferParam) => {
     const { assetId, amount, contractId } = transferParam;
     const encoded = numberCoder.encode(amount);
-    const scriptData = concat3([new Address3(contractId).toBytes(), encoded, arrayify15(assetId)]);
-    return concat3([acc, scriptData]);
+    const scriptData = concat4([new Address3(contractId).toBytes(), encoded, arrayify16(assetId)]);
+    return concat4([acc, scriptData]);
   }, new Uint8Array());
 }, "formatTransferToContractScriptData");
 var assembleTransferToContractScript = /* @__PURE__ */ __name(async (transferParams) => {
@@ -8396,7 +8512,7 @@ var assembleTransferToContractScript = /* @__PURE__ */ __name(async (transferPar
   let script = new Uint8Array();
   transferParams.forEach((_, i) => {
     const offset = (CONTRACT_ID_LEN + WORD_SIZE + ASSET_ID_LEN) * i;
-    script = concat3([
+    script = concat4([
       script,
       // Load ScriptData into register 0x10.
       asm.gtf(16, 0, asm.GTFArgs.ScriptData).to_bytes(),
@@ -8412,7 +8528,7 @@ var assembleTransferToContractScript = /* @__PURE__ */ __name(async (transferPar
       asm.tr(17, 19, 20).to_bytes()
     ]);
   });
-  script = concat3([script, asm.ret(1).to_bytes()]);
+  script = concat4([script, asm.ret(1).to_bytes()]);
   return { script, scriptData };
 }, "assembleTransferToContractScript");
 
@@ -8800,14 +8916,14 @@ var Account = class extends AbstractAccount {
    */
   async withdrawToBaseLayer(recipient, amount, txParams = {}) {
     const recipientAddress = new Address4(recipient);
-    const recipientDataArray = arrayify16(
+    const recipientDataArray = arrayify17(
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
-    const amountDataArray = arrayify16(
+    const amountDataArray = arrayify17(
       "0x".concat(bn21(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
-      ...arrayify16(withdrawScript.bytes),
+      ...arrayify17(withdrawScript.bytes),
       ...recipientDataArray,
       ...amountDataArray
     ]);
@@ -9029,14 +9145,23 @@ var Account = class extends AbstractAccount {
    * @param transactionRequestLike - The transaction request to sign.
    * @returns A promise that resolves to the signature of the transaction.
    */
-  async signTransaction(transactionRequestLike) {
+  async signTransaction(transactionRequestLike, connectorOptions = {}) {
     if (!this._connector) {
       throw new FuelError21(
         ErrorCode19.MISSING_CONNECTOR,
         "A connector is required to sign transactions."
       );
     }
-    return this._connector.signTransaction(this.address.toString(), transactionRequestLike);
+    const transactionRequest = transactionRequestify(transactionRequestLike);
+    const { transactionRequest: requestToSign, connectorsSendTxParams } = await this.setTransactionStateForConnectors({
+      transactionRequest,
+      connectorOptions
+    });
+    return this._connector.signTransaction(
+      this.address.toString(),
+      requestToSign,
+      connectorsSendTxParams
+    );
   }
   /**
    * Sends a transaction to the network.
@@ -9046,24 +9171,16 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async sendTransaction(transactionRequestLike, { estimateTxDependencies = true, ...connectorOptions } = {}) {
-    let transactionRequest = transactionRequestify(transactionRequestLike);
+    const transactionRequest = transactionRequestify(transactionRequestLike);
     if (this._connector) {
-      const { onBeforeSend, skipCustomFee = false } = connectorOptions;
-      transactionRequest = await this.prepareTransactionForSend(transactionRequest);
-      const params = {
-        onBeforeSend,
-        skipCustomFee,
-        provider: {
-          url: this.provider.url,
-          cache: await serializeProviderCache(this.provider)
-        },
-        transactionState: transactionRequest.flag.state,
-        transactionSummary: await this.prepareTransactionSummary(transactionRequest)
-      };
+      const response = await this.setTransactionStateForConnectors({
+        transactionRequest,
+        connectorOptions
+      });
       const transaction = await this._connector.sendTransaction(
         this.address.toString(),
-        transactionRequest,
-        params
+        response.transactionRequest,
+        response.connectorsSendTxParams
       );
       return typeof transaction === "string" ? this.provider.getTransactionResponse(transaction) : transaction;
     }
@@ -9197,6 +9314,23 @@ var Account = class extends AbstractAccount {
       );
     }
   }
+  /** @hidden * */
+  async setTransactionStateForConnectors(params) {
+    const { transactionRequest: requestToPrepare, connectorOptions } = params;
+    const { onBeforeSend, skipCustomFee = false } = connectorOptions;
+    const transactionRequest = await this.prepareTransactionForSend(requestToPrepare);
+    const connectorsSendTxParams = {
+      onBeforeSend,
+      skipCustomFee,
+      provider: {
+        url: this.provider.url,
+        cache: await serializeProviderCache(this.provider)
+      },
+      transactionState: requestToPrepare.flag.state,
+      transactionSummary: await this.prepareTransactionSummary(requestToPrepare)
+    };
+    return { transactionRequest, connectorsSendTxParams };
+  }
 };
 
 // src/wallet/base-wallet-unlocked.ts
@@ -9207,8 +9341,8 @@ import { hexlify as hexlify21 } from "@fuel-ts/utils";
 import { Address as Address5 } from "@fuel-ts/address";
 import { randomBytes as randomBytes3 } from "@fuel-ts/crypto";
 import { hash as hash2 } from "@fuel-ts/hasher";
-import { toBytes } from "@fuel-ts/math";
-import { hexlify as hexlify19, concat as concat4, arrayify as arrayify17 } from "@fuel-ts/utils";
+import { toBytes as toBytes2 } from "@fuel-ts/math";
+import { hexlify as hexlify19, concat as concat5, arrayify as arrayify18 } from "@fuel-ts/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
 var Signer = class _Signer {
   static {
@@ -9230,7 +9364,7 @@ var Signer = class _Signer {
         privateKey = `0x${privateKey}`;
       }
     }
-    const privateKeyBytes = toBytes(privateKey, 32);
+    const privateKeyBytes = toBytes2(privateKey, 32);
     this.privateKey = hexlify19(privateKeyBytes);
     this.publicKey = hexlify19(secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
     this.compressedPublicKey = hexlify19(secp256k1.getPublicKey(privateKeyBytes, true));
@@ -9247,11 +9381,11 @@ var Signer = class _Signer {
    * @returns hashed signature
    */
   sign(data) {
-    const signature = secp256k1.sign(arrayify17(data), arrayify17(this.privateKey));
-    const r = toBytes(`0x${signature.r.toString(16)}`, 32);
-    const s = toBytes(`0x${signature.s.toString(16)}`, 32);
+    const signature = secp256k1.sign(arrayify18(data), arrayify18(this.privateKey));
+    const r = toBytes2(`0x${signature.r.toString(16)}`, 32);
+    const s = toBytes2(`0x${signature.s.toString(16)}`, 32);
     s[0] |= (signature.recovery || 0) << 7;
-    return hexlify19(concat4([r, s]));
+    return hexlify19(concat5([r, s]));
   }
   /**
    * Add point on the current elliptic curve
@@ -9260,8 +9394,8 @@ var Signer = class _Signer {
    * @returns compressed point on the curve
    */
   addPoint(point) {
-    const p0 = secp256k1.ProjectivePoint.fromHex(arrayify17(this.compressedPublicKey));
-    const p1 = secp256k1.ProjectivePoint.fromHex(arrayify17(point));
+    const p0 = secp256k1.ProjectivePoint.fromHex(arrayify18(this.compressedPublicKey));
+    const p1 = secp256k1.ProjectivePoint.fromHex(arrayify18(point));
     const result = p0.add(p1);
     return `0x${result.toHex(true)}`;
   }
@@ -9273,7 +9407,7 @@ var Signer = class _Signer {
    * @returns public key from signature from the
    */
   static recoverPublicKey(data, signature) {
-    const signedMessageBytes = arrayify17(signature);
+    const signedMessageBytes = arrayify18(signature);
     const r = signedMessageBytes.slice(0, 32);
     const s = signedMessageBytes.slice(32, 64);
     const recoveryParam = (s[0] & 128) >> 7;
@@ -9281,7 +9415,7 @@ var Signer = class _Signer {
     const sig = new secp256k1.Signature(BigInt(hexlify19(r)), BigInt(hexlify19(s))).addRecoveryBit(
       recoveryParam
     );
-    const publicKey = sig.recoverPublicKey(arrayify17(data)).toRawBytes(false).slice(1);
+    const publicKey = sig.recoverPublicKey(arrayify18(data)).toRawBytes(false).slice(1);
     return hexlify19(publicKey);
   }
   /**
@@ -9301,7 +9435,7 @@ var Signer = class _Signer {
    * @returns random 32-byte hashed
    */
   static generatePrivateKey(entropy) {
-    return entropy ? hash2(concat4([randomBytes3(32), arrayify17(entropy)])) : randomBytes3(32);
+    return entropy ? hash2(concat5([randomBytes3(32), arrayify18(entropy)])) : randomBytes3(32);
   }
   /**
    * Extended publicKey from a compact publicKey
@@ -9310,7 +9444,7 @@ var Signer = class _Signer {
    * @returns extended publicKey
    */
   static extendPublicKey(publicKey) {
-    const point = secp256k1.ProjectivePoint.fromHex(arrayify17(publicKey));
+    const point = secp256k1.ProjectivePoint.fromHex(arrayify18(publicKey));
     return hexlify19(point.toRawBytes(false).slice(1));
   }
 };
@@ -9547,14 +9681,14 @@ var BaseWalletUnlocked = class extends Account {
 import { computeHmac as computeHmac2, ripemd160 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode23, FuelError as FuelError25 } from "@fuel-ts/errors";
 import { sha256 as sha2564 } from "@fuel-ts/hasher";
-import { bn as bn22, toBytes as toBytes2, toHex } from "@fuel-ts/math";
-import { arrayify as arrayify20, hexlify as hexlify23, concat as concat6, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
+import { bn as bn22, toBytes as toBytes3, toHex } from "@fuel-ts/math";
+import { arrayify as arrayify21, hexlify as hexlify23, concat as concat7, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
 
 // src/mnemonic/mnemonic.ts
 import { randomBytes as randomBytes5, pbkdf2, computeHmac } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode22, FuelError as FuelError24 } from "@fuel-ts/errors";
 import { sha256 as sha2563 } from "@fuel-ts/hasher";
-import { arrayify as arrayify19, hexlify as hexlify22, concat as concat5, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
+import { arrayify as arrayify20, hexlify as hexlify22, concat as concat6, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
 
 // src/wordlists/words/english.ts
 var english = [
@@ -11617,7 +11751,7 @@ var Language = /* @__PURE__ */ ((Language2) => {
 // src/mnemonic/utils.ts
 import { ErrorCode as ErrorCode21, FuelError as FuelError23 } from "@fuel-ts/errors";
 import { sha256 as sha2562 } from "@fuel-ts/hasher";
-import { arrayify as arrayify18 } from "@fuel-ts/utils";
+import { arrayify as arrayify19 } from "@fuel-ts/utils";
 function getLowerMask(bits) {
   return (1 << bits) - 1;
 }
@@ -11656,7 +11790,7 @@ function entropyToMnemonicIndices(entropy) {
     }
   }
   const checksumBits = entropy.length / 4;
-  const checksum = arrayify18(sha2562(entropy))[0] & getUpperMask(checksumBits);
+  const checksum = arrayify19(sha2562(entropy))[0] & getUpperMask(checksumBits);
   indices[indices.length - 1] <<= checksumBits;
   indices[indices.length - 1] |= checksum >> 8 - checksumBits;
   return indices;
@@ -11664,7 +11798,7 @@ function entropyToMnemonicIndices(entropy) {
 __name(entropyToMnemonicIndices, "entropyToMnemonicIndices");
 function mnemonicWordsToEntropy(words, wordlist) {
   const size = Math.ceil(11 * words.length / 8);
-  const entropy = arrayify18(new Uint8Array(size));
+  const entropy = arrayify19(new Uint8Array(size));
   let offset = 0;
   for (let i = 0; i < words.length; i += 1) {
     const index = wordlist.indexOf(words[i].normalize("NFKD"));
@@ -11684,7 +11818,7 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const entropyBits = 32 * words.length / 3;
   const checksumBits = words.length / 3;
   const checksumMask = getUpperMask(checksumBits);
-  const checksum = arrayify18(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
+  const checksum = arrayify19(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
     throw new FuelError23(
       ErrorCode21.INVALID_CHECKSUM,
@@ -11774,7 +11908,7 @@ var Mnemonic = class _Mnemonic {
    * @returns 64-byte array contains privateKey and chainCode as described on BIP39
    */
   static entropyToMnemonic(entropy, wordlist = english) {
-    const entropyBytes = arrayify19(entropy);
+    const entropyBytes = arrayify20(entropy);
     assertWordList(wordlist);
     assertEntropy(entropyBytes);
     return entropyToMnemonicIndices(entropyBytes).map((i) => wordlist[i]).join(" ");
@@ -11843,14 +11977,14 @@ var Mnemonic = class _Mnemonic {
    * @returns 64-byte array contains privateKey and chainCode as described on BIP39
    */
   static masterKeysFromSeed(seed) {
-    const seedArray = arrayify19(seed);
+    const seedArray = arrayify20(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
       throw new FuelError24(
         ErrorCode22.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
-    return arrayify19(computeHmac("sha512", MasterSecret, seedArray));
+    return arrayify20(computeHmac("sha512", MasterSecret, seedArray));
   }
   /**
    * Get the extendKey as defined on BIP-32 from the provided seed
@@ -11861,22 +11995,22 @@ var Mnemonic = class _Mnemonic {
    */
   static seedToExtendedKey(seed, testnet = false) {
     const masterKey = _Mnemonic.masterKeysFromSeed(seed);
-    const prefix = arrayify19(testnet ? TestnetPRV : MainnetPRV);
+    const prefix = arrayify20(testnet ? TestnetPRV : MainnetPRV);
     const depth = "0x00";
     const fingerprint = "0x00000000";
     const index = "0x00000000";
     const chainCode = masterKey.slice(32);
     const privateKey = masterKey.slice(0, 32);
-    const extendedKey = concat5([
+    const extendedKey = concat6([
       prefix,
       depth,
       fingerprint,
       index,
       chainCode,
-      concat5(["0x00", privateKey])
+      concat6(["0x00", privateKey])
     ]);
     const checksum = dataSlice(sha2563(sha2563(extendedKey)), 0, 4);
-    return encodeBase58(concat5([extendedKey, checksum]));
+    return encodeBase58(concat6([extendedKey, checksum]));
   }
   /**
    *  Create a new mnemonic using a randomly generated number as entropy.
@@ -11891,7 +12025,7 @@ var Mnemonic = class _Mnemonic {
    * @returns A randomly generated mnemonic
    */
   static generate(size = 32, extraEntropy = "") {
-    const entropy = extraEntropy ? sha2563(concat5([randomBytes5(size), arrayify19(extraEntropy)])) : randomBytes5(size);
+    const entropy = extraEntropy ? sha2563(concat6([randomBytes5(size), arrayify20(extraEntropy)])) : randomBytes5(size);
     return _Mnemonic.entropyToMnemonic(entropy);
   }
 };
@@ -11904,7 +12038,7 @@ var MainnetPUB = hexlify23("0x0488b21e");
 var TestnetPRV2 = hexlify23("0x04358394");
 var TestnetPUB = hexlify23("0x043587cf");
 function base58check(data) {
-  return encodeBase582(concat6([data, dataSlice2(sha2564(sha2564(data)), 0, 4)]));
+  return encodeBase582(concat7([data, dataSlice2(sha2564(sha2564(data)), 0, 4)]));
 }
 __name(base58check, "base58check");
 function getExtendedKeyPrefix(isPublic = false, testnet = false) {
@@ -11984,9 +12118,9 @@ var HDWallet = class _HDWallet {
    * @returns A new instance of HDWallet on the derived index
    */
   deriveIndex(index) {
-    const privateKey = this.privateKey && arrayify20(this.privateKey);
-    const publicKey = arrayify20(this.publicKey);
-    const chainCode = arrayify20(this.chainCode);
+    const privateKey = this.privateKey && arrayify21(this.privateKey);
+    const publicKey = arrayify21(this.publicKey);
+    const chainCode = arrayify21(this.chainCode);
     const data = new Uint8Array(37);
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
@@ -11997,10 +12131,10 @@ var HDWallet = class _HDWallet {
       }
       data.set(privateKey, 1);
     } else {
-      data.set(arrayify20(this.publicKey));
+      data.set(arrayify21(this.publicKey));
     }
-    data.set(toBytes2(index, 4), 33);
-    const bytes = arrayify20(computeHmac2("sha512", chainCode, data));
+    data.set(toBytes3(index, 4), 33);
+    const bytes = arrayify21(computeHmac2("sha512", chainCode, data));
     const IL = bytes.slice(0, 32);
     const IR = bytes.slice(32);
     if (privateKey) {
@@ -12053,8 +12187,8 @@ var HDWallet = class _HDWallet {
     const parentFingerprint = this.parentFingerprint;
     const index = toHex(this.index, 4);
     const chainCode = this.chainCode;
-    const key = this.privateKey != null && !isPublic ? concat6(["0x00", this.privateKey]) : this.publicKey;
-    const extendedKey = arrayify20(concat6([prefix, depth, parentFingerprint, index, chainCode, key]));
+    const key = this.privateKey != null && !isPublic ? concat7(["0x00", this.privateKey]) : this.publicKey;
+    const extendedKey = arrayify21(concat7([prefix, depth, parentFingerprint, index, chainCode, key]));
     return base58check(extendedKey);
   }
   /**
@@ -12066,13 +12200,13 @@ var HDWallet = class _HDWallet {
   static fromSeed(seed) {
     const masterKey = mnemonic_default.masterKeysFromSeed(seed);
     return new _HDWallet({
-      chainCode: arrayify20(masterKey.slice(32)),
-      privateKey: arrayify20(masterKey.slice(0, 32))
+      chainCode: arrayify21(masterKey.slice(32)),
+      privateKey: arrayify21(masterKey.slice(0, 32))
     });
   }
   static fromExtendedKey(extendedKey) {
-    const decoded = hexlify23(toBytes2(decodeBase58(extendedKey)));
-    const bytes = arrayify20(decoded);
+    const decoded = hexlify23(toBytes3(decodeBase58(extendedKey)));
+    const bytes = arrayify21(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
       throw new FuelError25(ErrorCode23.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
@@ -12699,19 +12833,19 @@ var StorageAbstract = class {
 };
 
 // src/predicate/predicate.ts
-import { Interface as Interface4 } from "@fuel-ts/abi-coder";
+import { Interface as Interface5 } from "@fuel-ts/abi-coder";
 import { Address as Address10 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode29, FuelError as FuelError31 } from "@fuel-ts/errors";
-import { arrayify as arrayify23, hexlify as hexlify25 } from "@fuel-ts/utils";
+import { arrayify as arrayify24, hexlify as hexlify25 } from "@fuel-ts/utils";
 
 // src/utils/deployScriptOrPredicate.ts
 import { FuelError as FuelError30, ErrorCode as ErrorCode28 } from "@fuel-ts/errors";
-import { arrayify as arrayify21 } from "@fuel-ts/utils";
+import { arrayify as arrayify22 } from "@fuel-ts/utils";
 
 // src/utils/predicate-script-loader-instructions.ts
 import { BigNumberCoder as BigNumberCoder4 } from "@fuel-ts/abi-coder";
 import { sha256 as sha2565 } from "@fuel-ts/hasher";
-import { concat as concat7 } from "@fuel-ts/utils";
+import { concat as concat8 } from "@fuel-ts/utils";
 import * as asm2 from "@fuels/vm-asm";
 var BLOB_ID_SIZE = 32;
 var REG_ADDRESS_OF_DATA_AFTER_CODE = 16;
@@ -12837,7 +12971,7 @@ function getPredicateScriptLoaderInstructions(originalBinary, blobId) {
       ...dataSectionLenBytes
     ]);
     return {
-      loaderBytecode: concat7([loaderBytecode2, configurableSection]),
+      loaderBytecode: concat8([loaderBytecode2, configurableSection]),
       blobOffset: loaderBytecode2.length
     };
   }
@@ -12881,8 +13015,8 @@ async function deployScriptOrPredicate({
   abi,
   loaderInstanceCallback
 }) {
-  const blobId = getBytecodeId(arrayify21(bytecode));
-  const configurableOffset = getBytecodeConfigurableOffset(arrayify21(bytecode));
+  const blobId = getBytecodeId(arrayify22(bytecode));
+  const configurableOffset = getBytecodeConfigurableOffset(arrayify22(bytecode));
   const byteCodeWithoutConfigurableSection = bytecode.slice(0, configurableOffset);
   const blobTxRequest = new BlobTransactionRequest({
     blobId,
@@ -12890,8 +13024,8 @@ async function deployScriptOrPredicate({
     witnesses: [byteCodeWithoutConfigurableSection]
   });
   const { loaderBytecode, blobOffset } = getPredicateScriptLoaderInstructions(
-    arrayify21(bytecode),
-    arrayify21(blobId)
+    arrayify22(bytecode),
+    arrayify22(blobId)
   );
   const newConfigurableOffsetDiff = byteCodeWithoutConfigurableSection.length - (blobOffset || 0);
   const newAbi = adjustConfigurableOffsets(abi, newConfigurableOffsetDiff);
@@ -12926,13 +13060,13 @@ __name(deployScriptOrPredicate, "deployScriptOrPredicate");
 // src/predicate/utils/getPredicateRoot.ts
 import { hash as hash3 } from "@fuel-ts/hasher";
 import { calcRoot } from "@fuel-ts/merkle";
-import { chunkAndPadBytes, hexlify as hexlify24, concat as concat8, arrayify as arrayify22 } from "@fuel-ts/utils";
+import { chunkAndPadBytes, hexlify as hexlify24, concat as concat9, arrayify as arrayify23 } from "@fuel-ts/utils";
 var getPredicateRoot = /* @__PURE__ */ __name((bytecode) => {
   const chunkSize = 16 * 1024;
-  const bytes = arrayify22(bytecode);
+  const bytes = arrayify23(bytecode);
   const chunks = chunkAndPadBytes(bytes, chunkSize);
   const codeRoot = calcRoot(chunks.map((c) => hexlify24(c)));
-  const predicateRoot = hash3(concat8(["0x4655454C", codeRoot]));
+  const predicateRoot = hash3(concat9(["0x4655454C", codeRoot]));
   return predicateRoot;
 }, "getPredicateRoot");
 
@@ -12969,7 +13103,7 @@ var Predicate = class _Predicate extends Account {
     );
     const address = new Address10(getPredicateRoot(predicateBytes));
     super(address, provider);
-    this.initialBytecode = arrayify23(bytecode);
+    this.initialBytecode = arrayify24(bytecode);
     this.bytes = predicateBytes;
     this.interface = predicateInterface;
     this.configurableConstants = configurableConstants;
@@ -13061,8 +13195,8 @@ var Predicate = class _Predicate extends Account {
    * @returns An object containing the new predicate bytes and interface.
    */
   static processPredicateData(bytes, jsonAbi, configurableConstants) {
-    let predicateBytes = arrayify23(bytes);
-    const abiInterface = new Interface4(jsonAbi);
+    let predicateBytes = arrayify24(bytes);
+    const abiInterface = new Interface5(jsonAbi);
     if (abiInterface.functions.main === void 0) {
       throw new FuelError31(
         ErrorCode29.ABI_MAIN_METHOD_MISSING,
@@ -13211,6 +13345,7 @@ var FuelConnectorMethods = /* @__PURE__ */ ((FuelConnectorMethods2) => {
   FuelConnectorMethods2["isConnected"] = "isConnected";
   FuelConnectorMethods2["accounts"] = "accounts";
   FuelConnectorMethods2["currentAccount"] = "currentAccount";
+  FuelConnectorMethods2["signTransaction"] = "signTransaction";
   FuelConnectorMethods2["signMessage"] = "signMessage";
   FuelConnectorMethods2["sendTransaction"] = "sendTransaction";
   FuelConnectorMethods2["assets"] = "assets";
@@ -13352,7 +13487,7 @@ var FuelConnector = class extends EventEmitter2 {
    *
    * @returns Transaction signature
    */
-  async signTransaction(_address, _transaction) {
+  async signTransaction(_address, _transaction, _params) {
     throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
@@ -13955,6 +14090,7 @@ export {
   assemblePreConfirmationTransactionSummary,
   assembleReceiptByType,
   assembleRevertError,
+  assembleSignalErrorMessage,
   assembleTransactionSummary,
   assembleTransactionSummaryFromJson,
   assets,