@fuel-ts/account 0.96.1 → 0.97.1

package/dist/index.js

@@ -125,6 +125,7 @@ __export(src_exports, {
   calculateTXFeeForSummary: () => calculateTXFeeForSummary,
   coinQuantityfy: () => coinQuantityfy,
   deferPromise: () => deferPromise,
+  deployScriptOrPredicate: () => deployScriptOrPredicate,
   dispatchFuelConnectorEvent: () => dispatchFuelConnectorEvent,
   english: () => english,
   extractBurnedAssetsFromReceipts: () => extractBurnedAssetsFromReceipts,
@@ -218,11 +219,11 @@ module.exports = __toCommonJS(src_exports);
 
 // src/account.ts
 var import_abi_coder7 = require("@fuel-ts/abi-coder");
-var import_address4 = require("@fuel-ts/address");
+var import_address5 = require("@fuel-ts/address");
 var import_crypto2 = require("@fuel-ts/crypto");
-var import_errors19 = require("@fuel-ts/errors");
+var import_errors20 = require("@fuel-ts/errors");
 var import_interfaces = require("@fuel-ts/interfaces");
-var import_math21 = require("@fuel-ts/math");
+var import_math20 = require("@fuel-ts/math");
 var import_transactions24 = require("@fuel-ts/transactions");
 var import_utils34 = require("@fuel-ts/utils");
 var import_ramda9 = require("ramda");
@@ -264,7 +265,7 @@ var addAmountToCoinQuantities = (params) => {
 
 // src/providers/provider.ts
 var import_address3 = require("@fuel-ts/address");
-var import_errors17 = require("@fuel-ts/errors");
+var import_errors18 = require("@fuel-ts/errors");
 var import_math18 = require("@fuel-ts/math");
 var import_transactions22 = require("@fuel-ts/transactions");
 var import_utils28 = require("@fuel-ts/utils");
@@ -317,9 +318,6 @@ var ReceiptFragmentDoc = import_graphql_tag.default`
 var SuccessStatusFragmentDoc = import_graphql_tag.default`
     fragment SuccessStatusFragment on SuccessStatus {
   type: __typename
-  block {
-    id
-  }
   time
   programState {
     returnType
@@ -332,6 +330,14 @@ var SuccessStatusFragmentDoc = import_graphql_tag.default`
   totalFee
 }
     ${ReceiptFragmentDoc}`;
+var SuccessStatusWithBlockIdFragmentDoc = import_graphql_tag.default`
+    fragment SuccessStatusWithBlockIdFragment on SuccessStatus {
+  ...SuccessStatusFragment
+  block {
+    id
+  }
+}
+    ${SuccessStatusFragmentDoc}`;
 var MalleableTransactionFieldsFragmentDoc = import_graphql_tag.default`
     fragment malleableTransactionFieldsFragment on Transaction {
   receiptsRoot
@@ -376,9 +382,6 @@ var MalleableTransactionFieldsFragmentDoc = import_graphql_tag.default`
 var FailureStatusFragmentDoc = import_graphql_tag.default`
     fragment FailureStatusFragment on FailureStatus {
   type: __typename
-  block {
-    id
-  }
   totalGas
   totalFee
   time
@@ -388,6 +391,14 @@ var FailureStatusFragmentDoc = import_graphql_tag.default`
   }
 }
     ${ReceiptFragmentDoc}`;
+var FailureStatusWithBlockIdFragmentDoc = import_graphql_tag.default`
+    fragment FailureStatusWithBlockIdFragment on FailureStatus {
+  ...FailureStatusFragment
+  block {
+    id
+  }
+}
+    ${FailureStatusFragmentDoc}`;
 var SqueezedOutStatusFragmentDoc = import_graphql_tag.default`
     fragment SqueezedOutStatusFragment on SqueezedOutStatus {
   type: __typename
@@ -400,13 +411,13 @@ var TransactionStatusSubscriptionFragmentDoc = import_graphql_tag.default`
     ...SubmittedStatusFragment
   }
   ... on SuccessStatus {
-    ...SuccessStatusFragment
+    ...SuccessStatusWithBlockIdFragment
     transaction {
       ...malleableTransactionFieldsFragment
     }
   }
   ... on FailureStatus {
-    ...FailureStatusFragment
+    ...FailureStatusWithBlockIdFragment
     transaction {
       ...malleableTransactionFieldsFragment
     }
@@ -416,9 +427,9 @@ var TransactionStatusSubscriptionFragmentDoc = import_graphql_tag.default`
   }
 }
     ${SubmittedStatusFragmentDoc}
-${SuccessStatusFragmentDoc}
+${SuccessStatusWithBlockIdFragmentDoc}
 ${MalleableTransactionFieldsFragmentDoc}
-${FailureStatusFragmentDoc}
+${FailureStatusWithBlockIdFragmentDoc}
 ${SqueezedOutStatusFragmentDoc}`;
 var TransactionStatusFragmentDoc = import_graphql_tag.default`
     fragment transactionStatusFragment on TransactionStatus {
@@ -448,6 +459,12 @@ var TransactionFragmentDoc = import_graphql_tag.default`
   }
 }
     ${TransactionStatusFragmentDoc}`;
+var TransactionRawPayloadFragmentDoc = import_graphql_tag.default`
+    fragment transactionRawPayloadFragment on Transaction {
+  id
+  rawPayload
+}
+    `;
 var InputEstimatePredicatesFragmentDoc = import_graphql_tag.default`
     fragment inputEstimatePredicatesFragment on Input {
   ... on InputCoin {
@@ -535,7 +552,6 @@ var CoinFragmentDoc = import_graphql_tag.default`
     fragment coinFragment on Coin {
   type: __typename
   utxoId
-  owner
   amount
   assetId
   blockCreated
@@ -559,10 +575,15 @@ var MessageFragmentDoc = import_graphql_tag.default`
   sender
   recipient
   data
-  nonce
   daHeight
 }
     `;
+var GetMessageFragmentDoc = import_graphql_tag.default`
+    fragment getMessageFragment on Message {
+  ...messageFragment
+  nonce
+}
+    ${MessageFragmentDoc}`;
 var MessageProofFragmentDoc = import_graphql_tag.default`
     fragment messageProofFragment on MessageProof {
   messageProof {
@@ -607,7 +628,6 @@ var MessageProofFragmentDoc = import_graphql_tag.default`
   }
   sender
   recipient
-  nonce
   amount
   data
 }
@@ -756,12 +776,6 @@ var RelayedTransactionStatusFragmentDoc = import_graphql_tag.default`
   }
 }
     `;
-var TransactionRawPayloadFragmentDoc = import_graphql_tag.default`
-    fragment transactionRawPayload on Transaction {
-  id
-  rawPayload
-}
-    `;
 var GetVersionDocument = import_graphql_tag.default`
     query getVersion {
   nodeInfo {
@@ -804,16 +818,34 @@ var GetTransactionDocument = import_graphql_tag.default`
 var GetTransactionWithReceiptsDocument = import_graphql_tag.default`
     query getTransactionWithReceipts($transactionId: TransactionId!) {
   transaction(id: $transactionId) {
-    ...transactionFragment
+    id
+    rawPayload
+    status {
+      ... on SubmittedStatus {
+        ...SubmittedStatusFragment
+      }
+      ... on SuccessStatus {
+        ...SuccessStatusWithBlockIdFragment
+      }
+      ... on FailureStatus {
+        ...FailureStatusWithBlockIdFragment
+      }
+      ... on SqueezedOutStatus {
+        ...SqueezedOutStatusFragment
+      }
+    }
   }
 }
-    ${TransactionFragmentDoc}`;
+    ${SubmittedStatusFragmentDoc}
+${SuccessStatusWithBlockIdFragmentDoc}
+${FailureStatusWithBlockIdFragmentDoc}
+${SqueezedOutStatusFragmentDoc}`;
 var GetTransactionsDocument = import_graphql_tag.default`
     query getTransactions($after: String, $before: String, $first: Int, $last: Int) {
   transactions(after: $after, before: $before, first: $first, last: $last) {
     edges {
       node {
-        ...transactionFragment
+        rawPayload
       }
     }
     pageInfo {
@@ -821,8 +853,7 @@ var GetTransactionsDocument = import_graphql_tag.default`
     }
   }
 }
-    ${TransactionFragmentDoc}
-${PageInfoFragmentDoc}`;
+    ${PageInfoFragmentDoc}`;
 var GetTransactionsByOwnerDocument = import_graphql_tag.default`
     query getTransactionsByOwner($owner: Address!, $after: String, $before: String, $first: Int, $last: Int) {
   transactionsByOwner(
@@ -881,7 +912,7 @@ var GetBlockWithTransactionsDocument = import_graphql_tag.default`
   block(id: $blockId, height: $blockHeight) {
     ...blockFragment
     transactions {
-      ...transactionRawPayload
+      ...transactionRawPayloadFragment
     }
   }
 }
@@ -906,6 +937,7 @@ var GetCoinDocument = import_graphql_tag.default`
     query getCoin($coinId: UtxoId!) {
   coin(utxoId: $coinId) {
     ...coinFragment
+    owner
   }
 }
     ${CoinFragmentDoc}`;
@@ -1014,13 +1046,13 @@ var GetMessagesDocument = import_graphql_tag.default`
     }
     edges {
       node {
-        ...messageFragment
+        ...getMessageFragment
       }
     }
   }
 }
     ${PageInfoFragmentDoc}
-${MessageFragmentDoc}`;
+${GetMessageFragmentDoc}`;
 var GetMessageProofDocument = import_graphql_tag.default`
     query getMessageProof($transactionId: TransactionId!, $nonce: Nonce!, $commitBlockId: BlockId, $commitBlockHeight: U32) {
   messageProof(
@@ -1555,9 +1587,11 @@ function assembleReceiptByType(receipt) {
   const { receiptType } = receipt;
   switch (receiptType) {
     case "CALL" /* Call */: {
+      const id = hexOrZero(receipt.id || receipt.contractId);
       const callReceipt = {
         type: import_transactions3.ReceiptType.Call,
-        from: hexOrZero(receipt.id || receipt.contractId),
+        id,
+        from: id,
         to: hexOrZero(receipt?.to),
         amount: (0, import_math4.bn)(receipt.amount),
         assetId: hexOrZero(receipt.assetId),
@@ -1614,24 +1648,36 @@ function assembleReceiptByType(receipt) {
       return revertReceipt;
     }
     case "LOG" /* Log */: {
+      const ra = (0, import_math4.bn)(receipt.ra);
+      const rb = (0, import_math4.bn)(receipt.rb);
+      const rc = (0, import_math4.bn)(receipt.rc);
+      const rd = (0, import_math4.bn)(receipt.rd);
       const logReceipt = {
         type: import_transactions3.ReceiptType.Log,
         id: hexOrZero(receipt.id || receipt.contractId),
-        val0: (0, import_math4.bn)(receipt.ra),
-        val1: (0, import_math4.bn)(receipt.rb),
-        val2: (0, import_math4.bn)(receipt.rc),
-        val3: (0, import_math4.bn)(receipt.rd),
+        ra,
+        rb,
+        rc,
+        rd,
+        val0: ra,
+        val1: rb,
+        val2: rc,
+        val3: rd,
         pc: (0, import_math4.bn)(receipt.pc),
         is: (0, import_math4.bn)(receipt.is)
       };
       return logReceipt;
     }
     case "LOG_DATA" /* LogData */: {
+      const ra = (0, import_math4.bn)(receipt.ra);
+      const rb = (0, import_math4.bn)(receipt.rb);
       const logDataReceipt = {
         type: import_transactions3.ReceiptType.LogData,
         id: hexOrZero(receipt.id || receipt.contractId),
-        val0: (0, import_math4.bn)(receipt.ra),
-        val1: (0, import_math4.bn)(receipt.rb),
+        ra,
+        rb,
+        val0: ra,
+        val1: rb,
         ptr: (0, import_math4.bn)(receipt.ptr),
         len: (0, import_math4.bn)(receipt.len),
         digest: hexOrZero(receipt.digest),
@@ -1642,9 +1688,11 @@ function assembleReceiptByType(receipt) {
       return logDataReceipt;
     }
     case "TRANSFER" /* Transfer */: {
+      const id = hexOrZero(receipt.id || receipt.contractId);
       const transferReceipt = {
         type: import_transactions3.ReceiptType.Transfer,
-        from: hexOrZero(receipt.id || receipt.contractId),
+        id,
+        from: id,
         to: hexOrZero(receipt.toAddress || receipt?.to),
         amount: (0, import_math4.bn)(receipt.amount),
         assetId: hexOrZero(receipt.assetId),
@@ -1654,9 +1702,11 @@ function assembleReceiptByType(receipt) {
       return transferReceipt;
     }
     case "TRANSFER_OUT" /* TransferOut */: {
+      const id = hexOrZero(receipt.id || receipt.contractId);
       const transferOutReceipt = {
         type: import_transactions3.ReceiptType.TransferOut,
-        from: hexOrZero(receipt.id || receipt.contractId),
+        id,
+        from: id,
         to: hexOrZero(receipt.toAddress || receipt.to),
         amount: (0, import_math4.bn)(receipt.amount),
         assetId: hexOrZero(receipt.assetId),
@@ -2718,7 +2768,7 @@ var BlobTransactionRequest = class extends BaseTransactionRequest {
   type = import_transactions7.TransactionType.Blob;
   /** Blob ID */
   blobId;
-  /** Witness index of contract bytecode to create */
+  /** Witness index of the bytecode to create */
   witnessIndex;
   /**
    * Creates an instance `BlobTransactionRequest`.
@@ -4102,14 +4152,14 @@ var processGraphqlStatus = (gqlTransactionStatus) => {
     switch (gqlTransactionStatus.type) {
       case "SuccessStatus":
         time = gqlTransactionStatus.time;
-        blockId = gqlTransactionStatus.block.id;
+        blockId = gqlTransactionStatus.block?.id;
         isStatusSuccess = true;
         totalFee = (0, import_math15.bn)(gqlTransactionStatus.totalFee);
         totalGas = (0, import_math15.bn)(gqlTransactionStatus.totalGas);
         break;
       case "FailureStatus":
         time = gqlTransactionStatus.time;
-        blockId = gqlTransactionStatus.block.id;
+        blockId = gqlTransactionStatus.block?.id;
         isStatusFailure = true;
         totalFee = (0, import_math15.bn)(gqlTransactionStatus.totalFee);
         totalGas = (0, import_math15.bn)(gqlTransactionStatus.totalGas);
@@ -4420,8 +4470,8 @@ var TransactionResponse = class {
     const subscription = this.submitTxSubscription ?? await this.provider.operations.statusChange({
       transactionId: this.id
     });
-    for await (const sub of subscription) {
-      const statusChange = "statusChange" in sub ? sub.statusChange : sub.submitAndAwaitStatus;
+    for await (const sub2 of subscription) {
+      const statusChange = "statusChange" in sub2 ? sub2.statusChange : sub2.submitAndAwaitStatus;
       this.status = statusChange;
       if (statusChange.type === "SqueezedOutStatus") {
         this.unsetResourceCache();
@@ -4544,11 +4594,53 @@ var handleGqlErrorMessage = (errorMessage, rawError) => {
         {},
         rawError
       );
+    case "max number of coins is reached while trying to fit the target" /* MAX_COINS_REACHED */:
+      throw new import_errors16.FuelError(
+        import_errors16.ErrorCode.MAX_COINS_REACHED,
+        "The account retrieving coins has exceeded the maximum number of coins per asset. Please consider combining your coins into a single UTXO.",
+        {},
+        rawError
+      );
     default:
       throw new import_errors16.FuelError(import_errors16.ErrorCode.INVALID_REQUEST, errorMessage);
   }
 };
 
+// src/providers/utils/validate-pagination-args.ts
+var import_errors17 = require("@fuel-ts/errors");
+var validatePaginationArgs = (params) => {
+  const { paginationLimit, inputArgs = {} } = params;
+  const { first, last, after, before } = inputArgs;
+  if (after && before) {
+    throw new import_errors17.FuelError(
+      import_errors17.ErrorCode.INVALID_INPUT_PARAMETERS,
+      'Pagination arguments "after" and "before" cannot be used together'
+    );
+  }
+  if ((first || 0) > paginationLimit || (last || 0) > paginationLimit) {
+    throw new import_errors17.FuelError(
+      import_errors17.ErrorCode.INVALID_INPUT_PARAMETERS,
+      `Pagination limit for this query cannot exceed ${paginationLimit} items`
+    );
+  }
+  if (first && before) {
+    throw new import_errors17.FuelError(
+      import_errors17.ErrorCode.INVALID_INPUT_PARAMETERS,
+      'The use of pagination argument "first" with "before" is not supported'
+    );
+  }
+  if (last && after) {
+    throw new import_errors17.FuelError(
+      import_errors17.ErrorCode.INVALID_INPUT_PARAMETERS,
+      'The use of pagination argument "last" with "after" is not supported'
+    );
+  }
+  if (!first && !last) {
+    inputArgs.first = paginationLimit;
+  }
+  return inputArgs;
+};
+
 // src/providers/provider.ts
 var MAX_RETRIES = 10;
 var RESOURCES_PAGE_SIZE_LIMIT = 512;
@@ -4693,7 +4785,7 @@ var _Provider = class {
     try {
       parsedUrl = new URL(url);
     } catch (error) {
-      throw new import_errors17.FuelError(import_errors17.FuelError.CODES.INVALID_URL, "Invalid URL provided.", { url }, error);
+      throw new import_errors18.FuelError(import_errors18.FuelError.CODES.INVALID_URL, "Invalid URL provided.", { url }, error);
     }
     const username = parsedUrl.username;
     const password = parsedUrl.password;
@@ -4728,8 +4820,8 @@ var _Provider = class {
   getChain() {
     const chain = _Provider.chainInfoCache[this.urlWithoutAuth];
     if (!chain) {
-      throw new import_errors17.FuelError(
-        import_errors17.ErrorCode.CHAIN_INFO_CACHE_EMPTY,
+      throw new import_errors18.FuelError(
+        import_errors18.ErrorCode.CHAIN_INFO_CACHE_EMPTY,
         "Chain info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -4743,8 +4835,8 @@ var _Provider = class {
   getNode() {
     const node = _Provider.nodeInfoCache[this.urlWithoutAuth];
     if (!node) {
-      throw new import_errors17.FuelError(
-        import_errors17.ErrorCode.NODE_INFO_CACHE_EMPTY,
+      throw new import_errors18.FuelError(
+        import_errors18.ErrorCode.NODE_INFO_CACHE_EMPTY,
         "Node info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -4840,7 +4932,7 @@ Supported fuel-core version: ${supportedVersion}.`
   createOperations() {
     const fetchFn = _Provider.getFetchFn(this.options);
     const gqlClient = new import_graphql_request.GraphQLClient(this.urlWithoutAuth, {
-      fetch: (url, requestInit) => fetchFn(url, requestInit, this.options),
+      fetch: (input, requestInit) => fetchFn(input.toString(), requestInit || {}, this.options),
       responseMiddleware: (response) => {
         if ("response" in response) {
           const graphQlResponse = response.response;
@@ -4970,14 +5062,14 @@ Supported fuel-core version: ${supportedVersion}.`
       }
     } = this.getChain();
     if ((0, import_math18.bn)(tx.inputs.length).gt(maxInputs)) {
-      throw new import_errors17.FuelError(
-        import_errors17.ErrorCode.MAX_INPUTS_EXCEEDED,
+      throw new import_errors18.FuelError(
+        import_errors18.ErrorCode.MAX_INPUTS_EXCEEDED,
         `The transaction exceeds the maximum allowed number of inputs. Tx inputs: ${tx.inputs.length}, max inputs: ${maxInputs}`
       );
     }
     if ((0, import_math18.bn)(tx.outputs.length).gt(maxOutputs)) {
-      throw new import_errors17.FuelError(
-        import_errors17.ErrorCode.MAX_OUTPUTS_EXCEEDED,
+      throw new import_errors18.FuelError(
+        import_errors18.ErrorCode.MAX_OUTPUTS_EXCEEDED,
         `The transaction exceeds the maximum allowed number of outputs. Tx outputs: ${tx.outputs.length}, max outputs: ${maxOutputs}`
       );
     }
@@ -5091,7 +5183,8 @@ Supported fuel-core version: ${supportedVersion}.`
         dryRun: [{ receipts: rawReceipts, status }]
       } = await this.operations.dryRun({
         encodedTransactions: [(0, import_utils28.hexlify)(transactionRequest.toTransactionBytes())],
-        utxoValidation: false
+        utxoValidation: false,
+        gasPrice: "0"
       });
       receipts = rawReceipts.map(processGqlReceipt);
       dryRunStatus = status;
@@ -5105,7 +5198,8 @@ Supported fuel-core version: ${supportedVersion}.`
           missingContractIds.push(contractId);
         });
         const { maxFee } = await this.estimateTxGasAndFee({
-          transactionRequest
+          transactionRequest,
+          gasPrice: (0, import_math18.bn)(0)
         });
         transactionRequest.maxFee = maxFee;
       } else {
@@ -5241,7 +5335,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const chainInfo = this.getChain();
     const { gasPriceFactor, maxGasPerTx } = this.getGasConfig();
     const minGas = transactionRequest.calculateMinGas(chainInfo);
-    if (!gasPrice) {
+    if (!(0, import_utils28.isDefined)(gasPrice)) {
       gasPrice = await this.estimateGasPrice(10);
     }
     const minFee = calculateGasFee({
@@ -5390,7 +5484,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const {
       coins: { edges, pageInfo }
     } = await this.operations.getCoins({
-      ...this.validatePaginationArgs({
+      ...validatePaginationArgs({
         paginationLimit: RESOURCES_PAGE_SIZE_LIMIT,
         inputArgs: paginationArgs
       }),
@@ -5400,7 +5494,7 @@ Supported fuel-core version: ${supportedVersion}.`
       id: node.utxoId,
       assetId: node.assetId,
       amount: (0, import_math18.bn)(node.amount),
-      owner: import_address3.Address.fromAddressOrString(node.owner),
+      owner: ownerAddress,
       blockCreated: (0, import_math18.bn)(node.blockCreated),
       txCreatedIdx: (0, import_math18.bn)(node.txCreatedIdx)
     }));
@@ -5454,7 +5548,7 @@ Supported fuel-core version: ${supportedVersion}.`
             id: coin.utxoId,
             amount: (0, import_math18.bn)(coin.amount),
             assetId: coin.assetId,
-            owner: import_address3.Address.fromAddressOrString(coin.owner),
+            owner: ownerAddress,
             blockCreated: (0, import_math18.bn)(coin.blockCreated),
             txCreatedIdx: (0, import_math18.bn)(coin.txCreatedIdx)
           };
@@ -5529,7 +5623,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const {
       blocks: { edges, pageInfo }
     } = await this.operations.getBlocks({
-      ...this.validatePaginationArgs({
+      ...validatePaginationArgs({
         paginationLimit: BLOCKS_PAGE_SIZE_LIMIT,
         inputArgs: params
       })
@@ -5608,7 +5702,7 @@ Supported fuel-core version: ${supportedVersion}.`
         0
       )?.[0];
     } catch (error) {
-      if (error instanceof import_errors17.FuelError && error.code === import_errors17.ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
+      if (error instanceof import_errors18.FuelError && error.code === import_errors18.ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
         console.warn("Unsupported transaction type encountered");
         return null;
       }
@@ -5624,7 +5718,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const {
       transactions: { edges, pageInfo }
     } = await this.operations.getTransactions({
-      ...this.validatePaginationArgs({
+      ...validatePaginationArgs({
         inputArgs: paginationArgs,
         paginationLimit: TRANSACTIONS_PAGE_SIZE_LIMIT
       })
@@ -5634,7 +5728,7 @@ Supported fuel-core version: ${supportedVersion}.`
       try {
         return coder.decode((0, import_utils28.arrayify)(rawPayload), 0)[0];
       } catch (error) {
-        if (error instanceof import_errors17.FuelError && error.code === import_errors17.ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
+        if (error instanceof import_errors18.FuelError && error.code === import_errors18.ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
           console.warn("Unsupported transaction type encountered");
           return null;
         }
@@ -5719,7 +5813,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const {
       messages: { edges, pageInfo }
     } = await this.operations.getMessages({
-      ...this.validatePaginationArgs({
+      ...validatePaginationArgs({
         inputArgs: paginationArgs,
         paginationLimit: RESOURCES_PAGE_SIZE_LIMIT
       }),
@@ -5760,8 +5854,8 @@ Supported fuel-core version: ${supportedVersion}.`
       nonce
     };
     if (commitBlockId && commitBlockHeight) {
-      throw new import_errors17.FuelError(
-        import_errors17.ErrorCode.INVALID_INPUT_PARAMETERS,
+      throw new import_errors18.FuelError(
+        import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
         "commitBlockId and commitBlockHeight cannot be used together"
       );
     }
@@ -5943,13 +6037,13 @@ Supported fuel-core version: ${supportedVersion}.`
       messageId: import_transactions22.InputMessageCoder.getMessageId({
         sender: rawMessage.sender,
         recipient: rawMessage.recipient,
-        nonce: rawMessage.nonce,
+        nonce,
         amount: (0, import_math18.bn)(rawMessage.amount),
         data: rawMessage.data
       }),
       sender: import_address3.Address.fromAddressOrString(rawMessage.sender),
       recipient: import_address3.Address.fromAddressOrString(rawMessage.recipient),
-      nonce: rawMessage.nonce,
+      nonce,
       amount: (0, import_math18.bn)(rawMessage.amount),
       data: import_transactions22.InputMessageCoder.decodeData(rawMessage.data),
       daHeight: (0, import_math18.bn)(rawMessage.daHeight)
@@ -5971,41 +6065,6 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     return relayedTransactionStatus;
   }
-  /**
-   * @hidden
-   */
-  validatePaginationArgs(params) {
-    const { paginationLimit, inputArgs = {} } = params;
-    const { first, last, after, before } = inputArgs;
-    if (after && before) {
-      throw new import_errors17.FuelError(
-        import_errors17.ErrorCode.INVALID_INPUT_PARAMETERS,
-        'Pagination arguments "after" and "before" cannot be used together'
-      );
-    }
-    if ((first || 0) > paginationLimit || (last || 0) > paginationLimit) {
-      throw new import_errors17.FuelError(
-        import_errors17.ErrorCode.INVALID_INPUT_PARAMETERS,
-        `Pagination limit for this query cannot exceed ${paginationLimit} items`
-      );
-    }
-    if (first && before) {
-      throw new import_errors17.FuelError(
-        import_errors17.ErrorCode.INVALID_INPUT_PARAMETERS,
-        'The use of pagination argument "first" with "before" is not supported'
-      );
-    }
-    if (last && after) {
-      throw new import_errors17.FuelError(
-        import_errors17.ErrorCode.INVALID_INPUT_PARAMETERS,
-        'The use of pagination argument "last" with "after" is not supported'
-      );
-    }
-    if (!first && !last) {
-      inputArgs.first = paginationLimit;
-    }
-    return inputArgs;
-  }
   /**
    * @hidden
    */
@@ -6051,7 +6110,7 @@ __publicField(Provider, "chainInfoCache", {});
 __publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
-var import_errors18 = require("@fuel-ts/errors");
+var import_errors19 = require("@fuel-ts/errors");
 var import_math19 = require("@fuel-ts/math");
 var import_transactions23 = require("@fuel-ts/transactions");
 var import_utils31 = require("@fuel-ts/utils");
@@ -6061,8 +6120,8 @@ async function getTransactionSummary(params) {
     transactionId: id
   });
   if (!gqlTransaction) {
-    throw new import_errors18.FuelError(
-      import_errors18.ErrorCode.TRANSACTION_NOT_FOUND,
+    throw new import_errors19.FuelError(
+      import_errors19.ErrorCode.TRANSACTION_NOT_FOUND,
       `Transaction not found for given id: ${id}.`
     );
   }
@@ -6130,7 +6189,15 @@ async function getTransactionSummaryFromRequest(params) {
 }
 async function getTransactionsSummaries(params) {
   const { filters, provider, abiMap } = params;
-  const { transactionsByOwner } = await provider.operations.getTransactionsByOwner(filters);
+  const { owner, ...inputArgs } = filters;
+  const validPaginationParams = validatePaginationArgs({
+    inputArgs,
+    paginationLimit: TRANSACTIONS_PAGE_SIZE_LIMIT
+  });
+  const { transactionsByOwner } = await provider.operations.getTransactionsByOwner({
+    ...validPaginationParams,
+    owner
+  });
   const { edges, pageInfo } = transactionsByOwner;
   const {
     consensusParameters: {
@@ -6850,37 +6917,45 @@ var mergeQuantities = (...coinQuantities) => {
 
 // src/utils/formatTransferToContractScriptData.ts
 var import_abi_coder6 = require("@fuel-ts/abi-coder");
-var import_math20 = require("@fuel-ts/math");
+var import_address4 = require("@fuel-ts/address");
 var import_utils33 = require("@fuel-ts/utils");
 var asm = __toESM(require("@fuels/vm-asm"));
-var formatTransferToContractScriptData = (params) => {
-  const { assetId, amountToTransfer, hexlifiedContractId } = params;
+var formatTransferToContractScriptData = (transferParams) => {
   const numberCoder = new import_abi_coder6.BigNumberCoder("u64");
-  const encoded = numberCoder.encode(new import_math20.BN(amountToTransfer).toNumber());
-  const scriptData = Uint8Array.from([
-    ...(0, import_utils33.arrayify)(hexlifiedContractId),
-    ...encoded,
-    ...(0, import_utils33.arrayify)(assetId)
-  ]);
-  return scriptData;
+  return transferParams.reduce((acc, transferParam) => {
+    const { assetId, amount, contractId } = transferParam;
+    const encoded = numberCoder.encode(amount);
+    const scriptData = (0, import_utils33.concat)([
+      import_address4.Address.fromAddressOrString(contractId).toBytes(),
+      encoded,
+      (0, import_utils33.arrayify)(assetId)
+    ]);
+    return (0, import_utils33.concat)([acc, scriptData]);
+  }, new Uint8Array());
 };
-var assembleTransferToContractScript = async (params) => {
-  const scriptData = formatTransferToContractScriptData(params);
+var assembleTransferToContractScript = async (transferParams) => {
+  const scriptData = formatTransferToContractScriptData(transferParams);
   await asm.initWasm();
-  const gtf2 = asm.gtf(16, 0, asm.GTFArgs.ScriptData);
-  const addi2 = asm.addi(17, 16, 32);
-  const lw2 = asm.lw(18, 17, 0);
-  const addi22 = asm.addi(19, 17, 8);
-  const tr2 = asm.tr(16, 18, 19);
-  const ret2 = asm.ret(1);
-  const script = Uint8Array.from([
-    ...gtf2.to_bytes(),
-    ...addi2.to_bytes(),
-    ...lw2.to_bytes(),
-    ...addi22.to_bytes(),
-    ...tr2.to_bytes(),
-    ...ret2.to_bytes()
-  ]);
+  let script = new Uint8Array();
+  transferParams.forEach((_, i) => {
+    const offset = (import_abi_coder6.CONTRACT_ID_LEN + import_abi_coder6.WORD_SIZE + import_abi_coder6.ASSET_ID_LEN) * i;
+    script = (0, import_utils33.concat)([
+      script,
+      // Load ScriptData into register 0x10.
+      asm.gtf(16, 0, asm.GTFArgs.ScriptData).to_bytes(),
+      // Add the offset to 0x10 so it will point to the current contract ID, store in 0x11.
+      asm.addi(17, 16, offset).to_bytes(),
+      // Add CONTRACT_ID_LEN to 0x11 to point to the amount in the ScriptData, store in 0x12.
+      asm.addi(18, 17, import_abi_coder6.CONTRACT_ID_LEN).to_bytes(),
+      // Load word to the amount at 0x12 into register 0x13.
+      asm.lw(19, 18, 0).to_bytes(),
+      // Add WORD_SIZE to 0x12 to point to the asset ID in the ScriptData, store in 0x14.
+      asm.addi(20, 18, import_abi_coder6.WORD_SIZE).to_bytes(),
+      // Perform the transfer using contract ID in 0x11, amount in 0x13, and asset ID in 0x14.
+      asm.tr(17, 19, 20).to_bytes()
+    ]);
+  });
+  script = (0, import_utils33.concat)([script, asm.ret(1).to_bytes()]);
   return { script, scriptData };
 };
 
@@ -6910,7 +6985,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     super();
     this._provider = provider;
     this._connector = connector;
-    this.address = import_address4.Address.fromDynamicInput(address);
+    this.address = import_address5.Address.fromDynamicInput(address);
   }
   /**
    * The provider used to interact with the network.
@@ -6921,7 +6996,7 @@ var Account = class extends import_interfaces.AbstractAccount {
    */
   get provider() {
     if (!this._provider) {
-      throw new import_errors19.FuelError(import_errors19.ErrorCode.MISSING_PROVIDER, "Provider not set");
+      throw new import_errors20.FuelError(import_errors20.ErrorCode.MISSING_PROVIDER, "Provider not set");
     }
     return this._provider;
   }
@@ -7001,9 +7076,9 @@ var Account = class extends import_interfaces.AbstractAccount {
     const { addedSignatures, estimatedPredicates, requiredQuantities, updateMaxFee, gasPrice } = params;
     const fee = request.maxFee;
     const baseAssetId = this.provider.getBaseAssetId();
-    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || (0, import_math21.bn)(0);
+    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || (0, import_math20.bn)(0);
     const requiredQuantitiesWithFee = addAmountToCoinQuantities({
-      amount: (0, import_math21.bn)(fee),
+      amount: (0, import_math20.bn)(fee),
       assetId: baseAssetId,
       coinQuantities: requiredQuantities
     });
@@ -7011,7 +7086,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     requiredQuantitiesWithFee.forEach(({ amount, assetId }) => {
       quantitiesDict[assetId] = {
         required: amount,
-        owned: (0, import_math21.bn)(0)
+        owned: (0, import_math20.bn)(0)
       };
     });
     request.inputs.filter(isRequestInputResource).forEach((input) => {
@@ -7072,8 +7147,8 @@ var Account = class extends import_interfaces.AbstractAccount {
       fundingAttempts += 1;
     }
     if (needsToBeFunded) {
-      throw new import_errors19.FuelError(
-        import_errors19.ErrorCode.NOT_ENOUGH_FUNDS,
+      throw new import_errors20.FuelError(
+        import_errors20.ErrorCode.NOT_ENOUGH_FUNDS,
         `The account ${this.address} does not have enough base asset funds to cover the transaction execution.`
       );
     }
@@ -7087,7 +7162,8 @@ var Account = class extends import_interfaces.AbstractAccount {
       return request;
     }
     const { maxFee } = await this.provider.estimateTxGasAndFee({
-      transactionRequest: requestToReestimate
+      transactionRequest: requestToReestimate,
+      gasPrice
     });
     request.maxFee = maxFee;
     return request;
@@ -7144,7 +7220,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     const { destination, amount, assetId } = transferParams;
     this.validateTransferAmount(amount);
     request.addCoinOutput(
-      import_address4.Address.fromAddressOrString(destination),
+      import_address5.Address.fromAddressOrString(destination),
       amount,
       assetId ?? this.provider.getBaseAssetId()
     );
@@ -7178,35 +7254,35 @@ var Account = class extends import_interfaces.AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transferToContract(contractId, amount, assetId, txParams = {}) {
-    if ((0, import_math21.bn)(amount).lte(0)) {
-      throw new import_errors19.FuelError(
-        import_errors19.ErrorCode.INVALID_TRANSFER_AMOUNT,
-        "Transfer amount must be a positive number."
-      );
-    }
-    const contractAddress = import_address4.Address.fromAddressOrString(contractId);
-    const assetIdToTransfer = assetId ?? this.provider.getBaseAssetId();
-    const { script, scriptData } = await assembleTransferToContractScript({
-      hexlifiedContractId: contractAddress.toB256(),
-      amountToTransfer: (0, import_math21.bn)(amount),
-      assetId: assetIdToTransfer
-    });
+    return this.batchTransferToContracts([{ amount, assetId, contractId }], txParams);
+  }
+  async batchTransferToContracts(contractTransferParams, txParams = {}) {
     let request = new ScriptTransactionRequest({
-      ...txParams,
-      script,
-      scriptData
-    });
-    request.addContractInputAndOutput(contractAddress);
-    const txCost = await this.getTransactionCost(request, {
-      quantities: [{ amount: (0, import_math21.bn)(amount), assetId: String(assetIdToTransfer) }]
+      ...txParams
     });
-    request = this.validateGasLimitAndMaxFee({
-      transactionRequest: request,
-      gasUsed: txCost.gasUsed,
-      maxFee: txCost.maxFee,
-      txParams
+    const quantities = [];
+    const transferParams = contractTransferParams.map((transferParam) => {
+      const amount = (0, import_math20.bn)(transferParam.amount);
+      const contractAddress = import_address5.Address.fromAddressOrString(transferParam.contractId);
+      const assetId = transferParam.assetId ? (0, import_utils34.hexlify)(transferParam.assetId) : this.provider.getBaseAssetId();
+      if (amount.lte(0)) {
+        throw new import_errors20.FuelError(
+          import_errors20.ErrorCode.INVALID_TRANSFER_AMOUNT,
+          "Transfer amount must be a positive number."
+        );
+      }
+      request.addContractInputAndOutput(contractAddress);
+      quantities.push({ amount, assetId });
+      return {
+        amount,
+        contractId: contractAddress.toB256(),
+        assetId
+      };
     });
-    await this.fund(request, txCost);
+    const { script, scriptData } = await assembleTransferToContractScript(transferParams);
+    request.script = script;
+    request.scriptData = scriptData;
+    request = await this.estimateAndFundTransaction(request, txParams, { quantities });
     return this.sendTransaction(request);
   }
   /**
@@ -7218,12 +7294,12 @@ var Account = class extends import_interfaces.AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async withdrawToBaseLayer(recipient, amount, txParams = {}) {
-    const recipientAddress = import_address4.Address.fromAddressOrString(recipient);
+    const recipientAddress = import_address5.Address.fromAddressOrString(recipient);
     const recipientDataArray = (0, import_utils34.arrayify)(
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
     const amountDataArray = (0, import_utils34.arrayify)(
-      "0x".concat((0, import_math21.bn)(amount).toHex().substring(2).padStart(16, "0"))
+      "0x".concat((0, import_math20.bn)(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
       ...(0, import_utils34.arrayify)(withdrawScript.bytes),
@@ -7233,7 +7309,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     const params = { script, ...txParams };
     const baseAssetId = this.provider.getBaseAssetId();
     let request = new ScriptTransactionRequest(params);
-    const quantities = [{ amount: (0, import_math21.bn)(amount), assetId: baseAssetId }];
+    const quantities = [{ amount: (0, import_math20.bn)(amount), assetId: baseAssetId }];
     const txCost = await this.getTransactionCost(request, { quantities });
     request = this.validateGasLimitAndMaxFee({
       transactionRequest: request,
@@ -7259,7 +7335,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     const baseAssetId = this.provider.getBaseAssetId();
     const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
     const requiredQuantities = mergeQuantities(coinOutputsQuantities, quantities);
-    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: (0, import_math21.bn)("100000000000000000") }];
+    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: (0, import_math20.bn)("100000000000000000") }];
     const findAssetInput = (assetId) => txRequestClone.inputs.find((input) => {
       if (input.type === import_transactions24.InputType.Coin) {
         return input.assetId === assetId;
@@ -7306,7 +7382,7 @@ var Account = class extends import_interfaces.AbstractAccount {
    */
   async signMessage(message) {
     if (!this._connector) {
-      throw new import_errors19.FuelError(import_errors19.ErrorCode.MISSING_CONNECTOR, "A connector is required to sign messages.");
+      throw new import_errors20.FuelError(import_errors20.ErrorCode.MISSING_CONNECTOR, "A connector is required to sign messages.");
     }
     return this._connector.signMessage(this.address.toString(), message);
   }
@@ -7318,8 +7394,8 @@ var Account = class extends import_interfaces.AbstractAccount {
    */
   async signTransaction(transactionRequestLike) {
     if (!this._connector) {
-      throw new import_errors19.FuelError(
-        import_errors19.ErrorCode.MISSING_CONNECTOR,
+      throw new import_errors20.FuelError(
+        import_errors20.ErrorCode.MISSING_CONNECTOR,
         "A connector is required to sign transactions."
       );
     }
@@ -7370,24 +7446,24 @@ var Account = class extends import_interfaces.AbstractAccount {
     return coins.map((coin) => ({
       id: (0, import_utils34.hexlify)((0, import_crypto2.randomBytes)(import_abi_coder7.UTXO_ID_LEN)),
       owner: this.address,
-      blockCreated: (0, import_math21.bn)(1),
-      txCreatedIdx: (0, import_math21.bn)(1),
+      blockCreated: (0, import_math20.bn)(1),
+      txCreatedIdx: (0, import_math20.bn)(1),
       ...coin
     }));
   }
   /** @hidden * */
   validateTransferAmount(amount) {
-    if ((0, import_math21.bn)(amount).lte(0)) {
-      throw new import_errors19.FuelError(
-        import_errors19.ErrorCode.INVALID_TRANSFER_AMOUNT,
+    if ((0, import_math20.bn)(amount).lte(0)) {
+      throw new import_errors20.FuelError(
+        import_errors20.ErrorCode.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
       );
     }
   }
   /** @hidden * */
-  async estimateAndFundTransaction(transactionRequest, txParams) {
+  async estimateAndFundTransaction(transactionRequest, txParams, costParams) {
     let request = transactionRequest;
-    const txCost = await this.getTransactionCost(request);
+    const txCost = await this.getTransactionCost(request, costParams);
     request = this.validateGasLimitAndMaxFee({
       transactionRequest: request,
       gasUsed: txCost.gasUsed,
@@ -7408,16 +7484,16 @@ var Account = class extends import_interfaces.AbstractAccount {
     if (!(0, import_utils34.isDefined)(setGasLimit)) {
       request.gasLimit = gasUsed;
     } else if (gasUsed.gt(setGasLimit)) {
-      throw new import_errors19.FuelError(
-        import_errors19.ErrorCode.GAS_LIMIT_TOO_LOW,
+      throw new import_errors20.FuelError(
+        import_errors20.ErrorCode.GAS_LIMIT_TOO_LOW,
         `Gas limit '${setGasLimit}' is lower than the required: '${gasUsed}'.`
       );
     }
     if (!(0, import_utils34.isDefined)(setMaxFee)) {
       request.maxFee = maxFee;
     } else if (maxFee.gt(setMaxFee)) {
-      throw new import_errors19.FuelError(
-        import_errors19.ErrorCode.MAX_FEE_TOO_LOW,
+      throw new import_errors20.FuelError(
+        import_errors20.ErrorCode.MAX_FEE_TOO_LOW,
         `Max fee '${setMaxFee}' is lower than the required: '${maxFee}'.`
       );
     }
@@ -7430,10 +7506,10 @@ var import_hasher4 = require("@fuel-ts/hasher");
 var import_utils37 = require("@fuel-ts/utils");
 
 // src/signer/signer.ts
-var import_address5 = require("@fuel-ts/address");
+var import_address6 = require("@fuel-ts/address");
 var import_crypto3 = require("@fuel-ts/crypto");
 var import_hasher3 = require("@fuel-ts/hasher");
-var import_math22 = require("@fuel-ts/math");
+var import_math21 = require("@fuel-ts/math");
 var import_utils35 = require("@fuel-ts/utils");
 var import_secp256k1 = require("@noble/curves/secp256k1");
 var Signer = class {
@@ -7453,11 +7529,11 @@ var Signer = class {
         privateKey = `0x${privateKey}`;
       }
     }
-    const privateKeyBytes = (0, import_math22.toBytes)(privateKey, 32);
+    const privateKeyBytes = (0, import_math21.toBytes)(privateKey, 32);
     this.privateKey = (0, import_utils35.hexlify)(privateKeyBytes);
     this.publicKey = (0, import_utils35.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
     this.compressedPublicKey = (0, import_utils35.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, true));
-    this.address = import_address5.Address.fromPublicKey(this.publicKey);
+    this.address = import_address6.Address.fromPublicKey(this.publicKey);
   }
   /**
    * Sign data using the Signer instance
@@ -7471,8 +7547,8 @@ var Signer = class {
    */
   sign(data) {
     const signature = import_secp256k1.secp256k1.sign((0, import_utils35.arrayify)(data), (0, import_utils35.arrayify)(this.privateKey));
-    const r = (0, import_math22.toBytes)(`0x${signature.r.toString(16)}`, 32);
-    const s = (0, import_math22.toBytes)(`0x${signature.s.toString(16)}`, 32);
+    const r = (0, import_math21.toBytes)(`0x${signature.r.toString(16)}`, 32);
+    const s = (0, import_math21.toBytes)(`0x${signature.s.toString(16)}`, 32);
     s[0] |= (signature.recovery || 0) << 7;
     return (0, import_utils35.hexlify)((0, import_utils35.concat)([r, s]));
   }
@@ -7515,7 +7591,7 @@ var Signer = class {
    * @returns Address from signature
    */
   static recoverAddress(data, signature) {
-    return import_address5.Address.fromPublicKey(Signer.recoverPublicKey(data, signature));
+    return import_address6.Address.fromPublicKey(Signer.recoverPublicKey(data, signature));
   }
   /**
    * Generate a random privateKey
@@ -7539,9 +7615,9 @@ var Signer = class {
 };
 
 // src/wallet/keystore-wallet.ts
-var import_address6 = require("@fuel-ts/address");
+var import_address7 = require("@fuel-ts/address");
 var import_crypto4 = require("@fuel-ts/crypto");
-var import_errors20 = require("@fuel-ts/errors");
+var import_errors21 = require("@fuel-ts/errors");
 var import_utils36 = require("@fuel-ts/utils");
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
 var DEFAULT_KDF_PARAMS_R = 8;
@@ -7556,7 +7632,7 @@ var removeHexPrefix = (hexString) => {
 };
 async function encryptKeystoreWallet(privateKey, address, password) {
   const privateKeyBuffer = (0, import_crypto4.bufferFromString)(removeHexPrefix(privateKey), "hex");
-  const ownerAddress = import_address6.Address.fromAddressOrString(address);
+  const ownerAddress = import_address7.Address.fromAddressOrString(address);
   const salt = (0, import_crypto4.randomBytes)(DEFAULT_KEY_SIZE);
   const key = (0, import_crypto4.scrypt)({
     password: (0, import_crypto4.bufferFromString)(password),
@@ -7618,8 +7694,8 @@ async function decryptKeystoreWallet(jsonWallet, password) {
   const macHashUint8Array = (0, import_crypto4.keccak256)(data);
   const macHash = (0, import_crypto4.stringFromBuffer)(macHashUint8Array, "hex");
   if (mac !== macHash) {
-    throw new import_errors20.FuelError(
-      import_errors20.ErrorCode.INVALID_PASSWORD,
+    throw new import_errors21.FuelError(
+      import_errors21.ErrorCode.INVALID_PASSWORD,
       "Failed to decrypt the keystore wallet, the provided password is incorrect."
     );
   }
@@ -7749,14 +7825,14 @@ __publicField(BaseWalletUnlocked, "defaultPath", "m/44'/1179993420'/0'/0/0");
 
 // src/hdwallet/hdwallet.ts
 var import_crypto6 = require("@fuel-ts/crypto");
-var import_errors23 = require("@fuel-ts/errors");
+var import_errors24 = require("@fuel-ts/errors");
 var import_hasher7 = require("@fuel-ts/hasher");
-var import_math23 = require("@fuel-ts/math");
+var import_math22 = require("@fuel-ts/math");
 var import_utils41 = require("@fuel-ts/utils");
 
 // src/mnemonic/mnemonic.ts
 var import_crypto5 = require("@fuel-ts/crypto");
-var import_errors22 = require("@fuel-ts/errors");
+var import_errors23 = require("@fuel-ts/errors");
 var import_hasher6 = require("@fuel-ts/hasher");
 var import_utils39 = require("@fuel-ts/utils");
 
@@ -9819,7 +9895,7 @@ var Language = /* @__PURE__ */ ((Language2) => {
 })(Language || {});
 
 // src/mnemonic/utils.ts
-var import_errors21 = require("@fuel-ts/errors");
+var import_errors22 = require("@fuel-ts/errors");
 var import_hasher5 = require("@fuel-ts/hasher");
 var import_utils38 = require("@fuel-ts/utils");
 function getLowerMask(bits) {
@@ -9868,8 +9944,8 @@ function mnemonicWordsToEntropy(words, wordlist) {
   for (let i = 0; i < words.length; i += 1) {
     const index = wordlist.indexOf(words[i].normalize("NFKD"));
     if (index === -1) {
-      throw new import_errors21.FuelError(
-        import_errors21.ErrorCode.INVALID_MNEMONIC,
+      throw new import_errors22.FuelError(
+        import_errors22.ErrorCode.INVALID_MNEMONIC,
         `Invalid mnemonic: the word '${words[i]}' is not found in the provided wordlist.`
       );
     }
@@ -9885,8 +9961,8 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const checksumMask = getUpperMask(checksumBits);
   const checksum = (0, import_utils38.arrayify)((0, import_hasher5.sha256)(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
-    throw new import_errors21.FuelError(
-      import_errors21.ErrorCode.INVALID_CHECKSUM,
+    throw new import_errors22.FuelError(
+      import_errors22.ErrorCode.INVALID_CHECKSUM,
       "Checksum validation failed for the provided mnemonic."
     );
   }
@@ -9900,16 +9976,16 @@ var TestnetPRV = "0x04358394";
 var MNEMONIC_SIZES = [12, 15, 18, 21, 24];
 function assertWordList(wordlist) {
   if (wordlist.length !== 2048) {
-    throw new import_errors22.FuelError(
-      import_errors22.ErrorCode.INVALID_WORD_LIST,
+    throw new import_errors23.FuelError(
+      import_errors23.ErrorCode.INVALID_WORD_LIST,
       `Expected word list length of 2048, but got ${wordlist.length}.`
     );
   }
 }
 function assertEntropy(entropy) {
   if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
-    throw new import_errors22.FuelError(
-      import_errors22.ErrorCode.INVALID_ENTROPY,
+    throw new import_errors23.FuelError(
+      import_errors23.ErrorCode.INVALID_ENTROPY,
       `Entropy should be between 16 and 32 bytes and a multiple of 4, but got ${entropy.length} bytes.`
     );
   }
@@ -9919,7 +9995,7 @@ function assertMnemonic(words) {
     const errorMsg = `Invalid mnemonic size. Expected one of [${MNEMONIC_SIZES.join(
       ", "
     )}] words, but got ${words.length}.`;
-    throw new import_errors22.FuelError(import_errors22.ErrorCode.INVALID_MNEMONIC, errorMsg);
+    throw new import_errors23.FuelError(import_errors23.ErrorCode.INVALID_MNEMONIC, errorMsg);
   }
 }
 var Mnemonic = class {
@@ -10037,8 +10113,8 @@ var Mnemonic = class {
   static masterKeysFromSeed(seed) {
     const seedArray = (0, import_utils39.arrayify)(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
-      throw new import_errors22.FuelError(
-        import_errors22.ErrorCode.INVALID_SEED,
+      throw new import_errors23.FuelError(
+        import_errors23.ErrorCode.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
@@ -10115,7 +10191,7 @@ function isValidExtendedKey(extendedKey) {
 function parsePath(path, depth = 0) {
   const components = path.split("/");
   if (components.length === 0 || components[0] === "m" && depth !== 0) {
-    throw new import_errors23.FuelError(import_errors23.ErrorCode.HD_WALLET_ERROR, `invalid path - ${path}`);
+    throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, `invalid path - ${path}`);
   }
   if (components[0] === "m") {
     components.shift();
@@ -10144,8 +10220,8 @@ var HDWallet = class {
       this.privateKey = (0, import_utils41.hexlify)(config.privateKey);
     } else {
       if (!config.publicKey) {
-        throw new import_errors23.FuelError(
-          import_errors23.ErrorCode.HD_WALLET_ERROR,
+        throw new import_errors24.FuelError(
+          import_errors24.ErrorCode.HD_WALLET_ERROR,
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
@@ -10174,8 +10250,8 @@ var HDWallet = class {
     const data = new Uint8Array(37);
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
-        throw new import_errors23.FuelError(
-          import_errors23.ErrorCode.HD_WALLET_ERROR,
+        throw new import_errors24.FuelError(
+          import_errors24.ErrorCode.HD_WALLET_ERROR,
           "Cannot derive a hardened index without a private Key."
         );
       }
@@ -10183,13 +10259,13 @@ var HDWallet = class {
     } else {
       data.set((0, import_utils41.arrayify)(this.publicKey));
     }
-    data.set((0, import_math23.toBytes)(index, 4), 33);
+    data.set((0, import_math22.toBytes)(index, 4), 33);
     const bytes = (0, import_utils41.arrayify)((0, import_crypto6.computeHmac)("sha512", chainCode, data));
     const IL = bytes.slice(0, 32);
     const IR = bytes.slice(32);
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
-      const ki = (0, import_math23.bn)(IL).add(privateKey).mod(N).toBytes(32);
+      const ki = (0, import_math22.bn)(IL).add(privateKey).mod(N).toBytes(32);
       return new HDWallet({
         privateKey: ki,
         chainCode: IR,
@@ -10227,15 +10303,15 @@ var HDWallet = class {
    */
   toExtendedKey(isPublic = false, testnet = false) {
     if (this.depth >= 256) {
-      throw new import_errors23.FuelError(
-        import_errors23.ErrorCode.HD_WALLET_ERROR,
+      throw new import_errors24.FuelError(
+        import_errors24.ErrorCode.HD_WALLET_ERROR,
         `Exceeded max depth of 255. Current depth: ${this.depth}.`
       );
     }
     const prefix = getExtendedKeyPrefix(this.privateKey == null || isPublic, testnet);
     const depth = (0, import_utils41.hexlify)(Uint8Array.from([this.depth]));
     const parentFingerprint = this.parentFingerprint;
-    const index = (0, import_math23.toHex)(this.index, 4);
+    const index = (0, import_math22.toHex)(this.index, 4);
     const chainCode = this.chainCode;
     const key = this.privateKey != null && !isPublic ? (0, import_utils41.concat)(["0x00", this.privateKey]) : this.publicKey;
     const extendedKey = (0, import_utils41.arrayify)((0, import_utils41.concat)([prefix, depth, parentFingerprint, index, chainCode, key]));
@@ -10255,14 +10331,14 @@ var HDWallet = class {
     });
   }
   static fromExtendedKey(extendedKey) {
-    const decoded = (0, import_utils41.hexlify)((0, import_math23.toBytes)((0, import_utils41.decodeBase58)(extendedKey)));
+    const decoded = (0, import_utils41.hexlify)((0, import_math22.toBytes)((0, import_utils41.decodeBase58)(extendedKey)));
     const bytes = (0, import_utils41.arrayify)(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
-      throw new import_errors23.FuelError(import_errors23.ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
+      throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
     }
     if (!validChecksum) {
-      throw new import_errors23.FuelError(import_errors23.ErrorCode.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
+      throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
     const parentFingerprint = (0, import_utils41.hexlify)(bytes.slice(5, 9));
@@ -10270,14 +10346,14 @@ var HDWallet = class {
     const chainCode = (0, import_utils41.hexlify)(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
-      throw new import_errors23.FuelError(
-        import_errors23.ErrorCode.HD_WALLET_ERROR,
+      throw new import_errors24.FuelError(
+        import_errors24.ErrorCode.HD_WALLET_ERROR,
         "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
       );
     }
     if (isPublicExtendedKey(bytes)) {
       if (key[0] !== 3) {
-        throw new import_errors23.FuelError(import_errors23.ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
+        throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
       }
       return new HDWallet({
         publicKey: key,
@@ -10288,7 +10364,7 @@ var HDWallet = class {
       });
     }
     if (key[0] !== 0) {
-      throw new import_errors23.FuelError(import_errors23.ErrorCode.HD_WALLET_ERROR, "Invalid private extended key.");
+      throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, "Invalid private extended key.");
     }
     return new HDWallet({
       privateKey: key.slice(1),
@@ -10454,9 +10530,9 @@ __publicField(Wallet, "fromExtendedKey", WalletUnlocked.fromExtendedKey);
 __publicField(Wallet, "fromEncryptedJson", WalletUnlocked.fromEncryptedJson);
 
 // src/wallet-manager/wallet-manager.ts
-var import_address9 = require("@fuel-ts/address");
+var import_address10 = require("@fuel-ts/address");
 var import_crypto7 = require("@fuel-ts/crypto");
-var import_errors26 = require("@fuel-ts/errors");
+var import_errors27 = require("@fuel-ts/errors");
 var import_events = require("events");
 
 // src/wallet-manager/storages/memory-storage.ts
@@ -10478,8 +10554,8 @@ var MemoryStorage = class {
 };
 
 // src/wallet-manager/vaults/mnemonic-vault.ts
-var import_address7 = require("@fuel-ts/address");
-var import_errors24 = require("@fuel-ts/errors");
+var import_address8 = require("@fuel-ts/address");
+var import_errors25 = require("@fuel-ts/errors");
 var _secret;
 var MnemonicVault = class {
   constructor(options) {
@@ -10527,7 +10603,7 @@ var MnemonicVault = class {
   }
   exportAccount(address) {
     let numberOfAccounts = 0;
-    const ownerAddress = import_address7.Address.fromAddressOrString(address);
+    const ownerAddress = import_address8.Address.fromAddressOrString(address);
     do {
       const wallet = Wallet.fromMnemonic(__privateGet(this, _secret), this.getDerivePath(numberOfAccounts));
       if (wallet.address.equals(ownerAddress)) {
@@ -10535,8 +10611,8 @@ var MnemonicVault = class {
       }
       numberOfAccounts += 1;
     } while (numberOfAccounts < this.numberOfAccounts);
-    throw new import_errors24.FuelError(
-      import_errors24.ErrorCode.WALLET_MANAGER_ERROR,
+    throw new import_errors25.FuelError(
+      import_errors25.ErrorCode.WALLET_MANAGER_ERROR,
       `Account with address '${address}' not found in derived wallets.`
     );
   }
@@ -10549,8 +10625,8 @@ _secret = new WeakMap();
 __publicField(MnemonicVault, "type", "mnemonic");
 
 // src/wallet-manager/vaults/privatekey-vault.ts
-var import_address8 = require("@fuel-ts/address");
-var import_errors25 = require("@fuel-ts/errors");
+var import_address9 = require("@fuel-ts/address");
+var import_errors26 = require("@fuel-ts/errors");
 var _privateKeys;
 var PrivateKeyVault = class {
   /**
@@ -10586,13 +10662,13 @@ var PrivateKeyVault = class {
     return this.getPublicAccount(wallet.privateKey);
   }
   exportAccount(address) {
-    const ownerAddress = import_address8.Address.fromAddressOrString(address);
+    const ownerAddress = import_address9.Address.fromAddressOrString(address);
     const privateKey = __privateGet(this, _privateKeys).find(
       (pk) => Wallet.fromPrivateKey(pk).address.equals(ownerAddress)
     );
     if (!privateKey) {
-      throw new import_errors25.FuelError(
-        import_errors25.ErrorCode.WALLET_MANAGER_ERROR,
+      throw new import_errors26.FuelError(
+        import_errors26.ErrorCode.WALLET_MANAGER_ERROR,
         `No private key found for address '${address}'.`
       );
     }
@@ -10616,7 +10692,7 @@ var ERROR_MESSAGES = {
 };
 function assert(condition, message) {
   if (!condition) {
-    throw new import_errors26.FuelError(import_errors26.ErrorCode.WALLET_MANAGER_ERROR, message);
+    throw new import_errors27.FuelError(import_errors27.ErrorCode.WALLET_MANAGER_ERROR, message);
   }
 }
 var _vaults, _passphrase, _isLocked, _serializeVaults, serializeVaults_fn, _deserializeVaults, deserializeVaults_fn;
@@ -10684,7 +10760,7 @@ var _WalletManager = class extends import_events.EventEmitter {
    * Create a Wallet instance for the specific account
    */
   getWallet(address) {
-    const ownerAddress = import_address9.Address.fromAddressOrString(address);
+    const ownerAddress = import_address10.Address.fromAddressOrString(address);
     const vaultState = __privateGet(this, _vaults).find(
       (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
     );
@@ -10695,7 +10771,7 @@ var _WalletManager = class extends import_events.EventEmitter {
    * Export specific account privateKey
    */
   exportPrivateKey(address) {
-    const ownerAddress = import_address9.Address.fromAddressOrString(address);
+    const ownerAddress = import_address10.Address.fromAddressOrString(address);
     assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
     const vaultState = __privateGet(this, _vaults).find(
       (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
@@ -10842,25 +10918,25 @@ deserializeVaults_fn = function(vaults) {
 __publicField(WalletManager, "Vaults", [MnemonicVault, PrivateKeyVault]);
 
 // src/wallet-manager/types.ts
-var import_errors27 = require("@fuel-ts/errors");
+var import_errors28 = require("@fuel-ts/errors");
 var Vault = class {
   constructor(_options) {
-    throw new import_errors27.FuelError(import_errors27.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors28.FuelError(import_errors28.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   serialize() {
-    throw new import_errors27.FuelError(import_errors27.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors28.FuelError(import_errors28.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   getAccounts() {
-    throw new import_errors27.FuelError(import_errors27.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors28.FuelError(import_errors28.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   addAccount() {
-    throw new import_errors27.FuelError(import_errors27.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors28.FuelError(import_errors28.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   exportAccount(_address) {
-    throw new import_errors27.FuelError(import_errors27.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors28.FuelError(import_errors28.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   getWallet(_address) {
-    throw new import_errors27.FuelError(import_errors27.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors28.FuelError(import_errors28.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
 };
 __publicField(Vault, "type");
@@ -10869,35 +10945,237 @@ var StorageAbstract = class {
 
 // src/predicate/predicate.ts
 var import_abi_coder8 = require("@fuel-ts/abi-coder");
-var import_address10 = require("@fuel-ts/address");
-var import_errors28 = require("@fuel-ts/errors");
+var import_address11 = require("@fuel-ts/address");
+var import_errors30 = require("@fuel-ts/errors");
+var import_utils45 = require("@fuel-ts/utils");
+
+// src/utils/deployScriptOrPredicate.ts
+var import_errors29 = require("@fuel-ts/errors");
+var import_hasher8 = require("@fuel-ts/hasher");
+var import_math23 = require("@fuel-ts/math");
 var import_utils43 = require("@fuel-ts/utils");
 
+// src/utils/predicate-script-loader-instructions.ts
+var import_utils42 = require("@fuel-ts/utils");
+var asm2 = __toESM(require("@fuels/vm-asm"));
+var BLOB_ID_SIZE = 32;
+var REG_ADDRESS_OF_DATA_AFTER_CODE = 16;
+var REG_START_OF_LOADED_CODE = 17;
+var REG_GENERAL_USE = 18;
+var WORD_SIZE2 = 8;
+function getDataOffset(binary) {
+  const OFFSET_INDEX = 8;
+  const dataView = new DataView(binary.buffer, OFFSET_INDEX, 8);
+  const dataOffset = dataView.getBigUint64(0, false);
+  return Number(dataOffset);
+}
+function getPredicateScriptLoaderInstructions(originalBinary, blobId) {
+  const { RegId, Instruction } = asm2;
+  const REG_PC = RegId.pc().to_u8();
+  const REG_SP = RegId.sp().to_u8();
+  const REG_IS = RegId.is().to_u8();
+  const getInstructions = (numOfInstructions2) => [
+    // 1. Load the blob content into memory
+    // Find the start of the hardcoded blob ID, which is located after the loader code ends.
+    asm2.move_(REG_ADDRESS_OF_DATA_AFTER_CODE, REG_PC),
+    // hold the address of the blob ID.
+    asm2.addi(
+      REG_ADDRESS_OF_DATA_AFTER_CODE,
+      REG_ADDRESS_OF_DATA_AFTER_CODE,
+      numOfInstructions2 * Instruction.size()
+    ),
+    // The code is going to be loaded from the current value of SP onwards, save
+    // the location into REG_START_OF_LOADED_CODE so we can jump into it at the end.
+    asm2.move_(REG_START_OF_LOADED_CODE, REG_SP),
+    // REG_GENERAL_USE to hold the size of the blob.
+    asm2.bsiz(REG_GENERAL_USE, REG_ADDRESS_OF_DATA_AFTER_CODE),
+    // Push the blob contents onto the stack.
+    asm2.ldc(REG_ADDRESS_OF_DATA_AFTER_CODE, 0, REG_GENERAL_USE, 1),
+    // Move on to the data section length
+    asm2.addi(REG_ADDRESS_OF_DATA_AFTER_CODE, REG_ADDRESS_OF_DATA_AFTER_CODE, BLOB_ID_SIZE),
+    // load the size of the data section into REG_GENERAL_USE
+    asm2.lw(REG_GENERAL_USE, REG_ADDRESS_OF_DATA_AFTER_CODE, 0),
+    // after we have read the length of the data section, we move the pointer to the actual
+    // data by skipping WORD_SIZE bytes.
+    asm2.addi(REG_ADDRESS_OF_DATA_AFTER_CODE, REG_ADDRESS_OF_DATA_AFTER_CODE, WORD_SIZE2),
+    // load the data section of the executable
+    asm2.ldc(REG_ADDRESS_OF_DATA_AFTER_CODE, 0, REG_GENERAL_USE, 2),
+    // Jump into the memory where the contract is loaded.
+    // What follows is called _jmp_mem by the sway compiler.
+    // Subtract the address contained in IS because jmp will add it back.
+    asm2.sub(REG_START_OF_LOADED_CODE, REG_START_OF_LOADED_CODE, REG_IS),
+    // jmp will multiply by 4, so we need to divide to cancel that out.
+    asm2.divi(REG_START_OF_LOADED_CODE, REG_START_OF_LOADED_CODE, 4),
+    // Jump to the start of the contract we loaded.
+    asm2.jmp(REG_START_OF_LOADED_CODE)
+  ];
+  const getInstructionsNoDataSection = (numOfInstructions2) => [
+    // 1. Load the blob content into memory
+    // Find the start of the hardcoded blob ID, which is located after the loader code ends.
+    // 1. Load the blob content into memory
+    // Find the start of the hardcoded blob ID, which is located after the loader code ends.
+    asm2.move_(REG_ADDRESS_OF_DATA_AFTER_CODE, REG_PC),
+    // hold the address of the blob ID.
+    asm2.addi(
+      REG_ADDRESS_OF_DATA_AFTER_CODE,
+      REG_ADDRESS_OF_DATA_AFTER_CODE,
+      numOfInstructions2 * Instruction.size()
+    ),
+    // The code is going to be loaded from the current value of SP onwards, save
+    // the location into REG_START_OF_LOADED_CODE so we can jump into it at the end.
+    asm2.move_(REG_START_OF_LOADED_CODE, REG_SP),
+    // REG_GENERAL_USE to hold the size of the blob.
+    asm2.bsiz(REG_GENERAL_USE, REG_ADDRESS_OF_DATA_AFTER_CODE),
+    // Push the blob contents onto the stack.
+    asm2.ldc(REG_ADDRESS_OF_DATA_AFTER_CODE, 0, REG_GENERAL_USE, 1),
+    // Jump into the memory where the contract is loaded.
+    // What follows is called _jmp_mem by the sway compiler.
+    // Subtract the address contained in IS because jmp will add it back.
+    asm2.sub(REG_START_OF_LOADED_CODE, REG_START_OF_LOADED_CODE, REG_IS),
+    // jmp will multiply by 4, so we need to divide to cancel that out.
+    asm2.divi(REG_START_OF_LOADED_CODE, REG_START_OF_LOADED_CODE, 4),
+    // Jump to the start of the contract we loaded.
+    asm2.jmp(REG_START_OF_LOADED_CODE)
+  ];
+  const offset = getDataOffset(originalBinary);
+  if (originalBinary.length < offset) {
+    throw new Error(
+      `Data section offset is out of bounds, offset: ${offset}, binary length: ${originalBinary.length}`
+    );
+  }
+  const dataSection = originalBinary.slice(offset);
+  if (dataSection.length > 0) {
+    const numOfInstructions2 = getInstructions(0).length;
+    if (numOfInstructions2 > 65535) {
+      throw new Error("Too many instructions, exceeding u16::MAX.");
+    }
+    const instructionBytes2 = new Uint8Array(
+      getInstructions(numOfInstructions2).flatMap(
+        (instruction) => Array.from(instruction.to_bytes())
+      )
+    );
+    const blobBytes2 = new Uint8Array(blobId);
+    const dataSectionLenBytes = new Uint8Array(8);
+    const dataView = new DataView(dataSectionLenBytes.buffer);
+    dataView.setBigUint64(0, BigInt(dataSection.length), false);
+    const loaderBytecode2 = new Uint8Array([
+      ...instructionBytes2,
+      ...blobBytes2,
+      ...dataSectionLenBytes
+    ]);
+    return {
+      loaderBytecode: (0, import_utils42.concat)([loaderBytecode2, dataSection]),
+      blobOffset: loaderBytecode2.length
+    };
+  }
+  const numOfInstructions = getInstructionsNoDataSection(0).length;
+  if (numOfInstructions > 65535) {
+    throw new Error("Too many instructions, exceeding u16::MAX.");
+  }
+  const instructionBytes = new Uint8Array(
+    getInstructionsNoDataSection(numOfInstructions).flatMap(
+      (instruction) => Array.from(instruction.to_bytes())
+    )
+  );
+  const blobBytes = new Uint8Array(blobId);
+  const loaderBytecode = new Uint8Array([...instructionBytes, ...blobBytes]);
+  return { loaderBytecode };
+}
+
+// src/utils/deployScriptOrPredicate.ts
+async function fundBlobTx(deployer, blobTxRequest) {
+  let totalCost = (0, import_math23.bn)(0);
+  const chainInfo = deployer.provider.getChain();
+  const gasPrice = await deployer.provider.estimateGasPrice(10);
+  const priceFactor = chainInfo.consensusParameters.feeParameters.gasPriceFactor;
+  const minGas = blobTxRequest.calculateMinGas(chainInfo);
+  const minFee = calculateGasFee({
+    gasPrice,
+    gas: minGas,
+    priceFactor,
+    tip: blobTxRequest.tip
+  }).add(1);
+  totalCost = totalCost.add(minFee);
+  if (totalCost.gt(await deployer.getBalance())) {
+    throw new import_errors29.FuelError(import_errors29.ErrorCode.FUNDS_TOO_LOW, "Insufficient balance to deploy predicate.");
+  }
+  const txCost = await deployer.getTransactionCost(blobTxRequest);
+  blobTxRequest.maxFee = txCost.maxFee;
+  return deployer.fund(blobTxRequest, txCost);
+}
+function adjustConfigurableOffsets(jsonAbi, configurableOffsetDiff) {
+  const { configurables: readOnlyConfigurables } = jsonAbi;
+  const configurables = [];
+  readOnlyConfigurables.forEach((config) => {
+    configurables.push({ ...config, offset: config.offset - configurableOffsetDiff });
+  });
+  return { ...jsonAbi, configurables };
+}
+async function deployScriptOrPredicate({
+  deployer,
+  bytecode,
+  abi,
+  loaderInstanceCallback
+}) {
+  const dataSectionOffset = getDataOffset((0, import_utils43.arrayify)(bytecode));
+  const byteCodeWithoutDataSection = bytecode.slice(0, dataSectionOffset);
+  const blobId = (0, import_hasher8.hash)(byteCodeWithoutDataSection);
+  const blobTxRequest = new BlobTransactionRequest({
+    blobId,
+    witnessIndex: 0,
+    witnesses: [byteCodeWithoutDataSection]
+  });
+  const { loaderBytecode, blobOffset } = getPredicateScriptLoaderInstructions(
+    (0, import_utils43.arrayify)(bytecode),
+    (0, import_utils43.arrayify)(blobId)
+  );
+  const configurableOffsetDiff = byteCodeWithoutDataSection.length - (blobOffset || 0);
+  const newAbi = adjustConfigurableOffsets(abi, configurableOffsetDiff);
+  const blobExists = (await deployer.provider.getBlobs([blobId])).length > 0;
+  const loaderInstance = loaderInstanceCallback(loaderBytecode, newAbi);
+  if (blobExists) {
+    return {
+      waitForResult: () => Promise.resolve(loaderInstance),
+      blobId
+    };
+  }
+  const fundedBlobRequest = await fundBlobTx(deployer, blobTxRequest);
+  const waitForResult = async () => {
+    try {
+      const blobTx = await deployer.sendTransaction(fundedBlobRequest);
+      const result = await blobTx.waitForResult();
+      if (result.status !== "success" /* success */) {
+        throw new Error();
+      }
+    } catch (err) {
+      throw new import_errors29.FuelError(import_errors29.ErrorCode.TRANSACTION_FAILED, "Failed to deploy predicate chunk");
+    }
+    return loaderInstance;
+  };
+  return {
+    waitForResult,
+    blobId
+  };
+}
+
 // src/predicate/utils/getPredicateRoot.ts
-var import_hasher8 = require("@fuel-ts/hasher");
+var import_hasher9 = require("@fuel-ts/hasher");
 var import_merkle = require("@fuel-ts/merkle");
-var import_utils42 = require("@fuel-ts/utils");
+var import_utils44 = require("@fuel-ts/utils");
 var getPredicateRoot = (bytecode) => {
   const chunkSize = 16 * 1024;
-  const bytes = (0, import_utils42.arrayify)(bytecode);
-  const chunks = (0, import_utils42.chunkAndPadBytes)(bytes, chunkSize);
-  const codeRoot = (0, import_merkle.calcRoot)(chunks.map((c) => (0, import_utils42.hexlify)(c)));
-  const predicateRoot = (0, import_hasher8.hash)((0, import_utils42.concat)(["0x4655454C", codeRoot]));
+  const bytes = (0, import_utils44.arrayify)(bytecode);
+  const chunks = (0, import_utils44.chunkAndPadBytes)(bytes, chunkSize);
+  const codeRoot = (0, import_merkle.calcRoot)(chunks.map((c) => (0, import_utils44.hexlify)(c)));
+  const predicateRoot = (0, import_hasher9.hash)((0, import_utils44.concat)(["0x4655454C", codeRoot]));
   return predicateRoot;
 };
 
 // src/predicate/predicate.ts
-function getDataOffset(binary) {
-  const buffer = binary.buffer.slice(binary.byteOffset + 8, binary.byteOffset + 16);
-  const dataView = new DataView(buffer);
-  const dataOffset = dataView.getBigUint64(0, false);
-  return Number(dataOffset);
-}
 var Predicate = class extends Account {
   bytes;
   predicateData = [];
   interface;
-  loaderBytecode = "";
   /**
    * Creates an instance of the Predicate class.
    *
@@ -10912,24 +11190,17 @@ var Predicate = class extends Account {
     abi,
     provider,
     data,
-    configurableConstants,
-    /**
-     * TODO: Implement a getBytes method within the Predicate class. This method should return the loaderBytecode if it is set.
-     * The getBytes method should be used in all places where we use this.bytes.
-     * Note: Do not set loaderBytecode to a default string here; it should remain undefined when not provided.
-     */
-    loaderBytecode = ""
+    configurableConstants
   }) {
     const { predicateBytes, predicateInterface } = Predicate.processPredicateData(
       bytecode,
       abi,
       configurableConstants
     );
-    const address = import_address10.Address.fromB256(getPredicateRoot(predicateBytes));
+    const address = import_address11.Address.fromB256(getPredicateRoot(predicateBytes));
     super(address, provider);
     this.bytes = predicateBytes;
     this.interface = predicateInterface;
-    this.loaderBytecode = loaderBytecode;
     if (data !== void 0 && data.length > 0) {
       this.predicateData = data;
     }
@@ -10948,8 +11219,8 @@ var Predicate = class extends Account {
     }
     request.inputs.filter(isRequestInputCoinOrMessage).forEach((input) => {
       if (isRequestInputResourceFromOwner(input, this.address)) {
-        input.predicate = (0, import_utils43.hexlify)(this.bytes);
-        input.predicateData = (0, import_utils43.hexlify)(this.getPredicateData());
+        input.predicate = (0, import_utils45.hexlify)(this.bytes);
+        input.predicateData = (0, import_utils45.hexlify)(this.getPredicateData());
         input.witnessIndex = 0;
       }
     });
@@ -10991,16 +11262,13 @@ var Predicate = class extends Account {
    * @returns An object containing the new predicate bytes and interface.
    */
   static processPredicateData(bytes, jsonAbi, configurableConstants) {
-    let predicateBytes = (0, import_utils43.arrayify)(bytes);
-    let abiInterface;
-    if (jsonAbi) {
-      abiInterface = new import_abi_coder8.Interface(jsonAbi);
-      if (abiInterface.functions.main === void 0) {
-        throw new import_errors28.FuelError(
-          import_errors28.ErrorCode.ABI_MAIN_METHOD_MISSING,
-          'Cannot use ABI without "main" function.'
-        );
-      }
+    let predicateBytes = (0, import_utils45.arrayify)(bytes);
+    const abiInterface = new import_abi_coder8.Interface(jsonAbi);
+    if (abiInterface.functions.main === void 0) {
+      throw new import_errors30.FuelError(
+        import_errors30.ErrorCode.ABI_MAIN_METHOD_MISSING,
+        'Cannot use ABI without "main" function.'
+      );
     }
     if (configurableConstants && Object.keys(configurableConstants).length) {
       predicateBytes = Predicate.setConfigurableConstants(
@@ -11029,8 +11297,8 @@ var Predicate = class extends Account {
     );
     return resources.map((resource) => ({
       ...resource,
-      predicate: (0, import_utils43.hexlify)(this.bytes),
-      predicateData: (0, import_utils43.hexlify)(this.getPredicateData())
+      predicate: (0, import_utils45.hexlify)(this.bytes),
+      predicateData: (0, import_utils45.hexlify)(this.getPredicateData())
     }));
   }
   /**
@@ -11042,8 +11310,8 @@ var Predicate = class extends Account {
   generateFakeResources(coins) {
     return super.generateFakeResources(coins).map((coin) => ({
       ...coin,
-      predicate: (0, import_utils43.hexlify)(this.bytes),
-      predicateData: (0, import_utils43.hexlify)(this.getPredicateData())
+      predicate: (0, import_utils45.hexlify)(this.bytes),
+      predicateData: (0, import_utils45.hexlify)(this.getPredicateData())
     }));
   }
   /**
@@ -11054,25 +11322,19 @@ var Predicate = class extends Account {
    * @param abiInterface - The ABI interface of the predicate.
    * @returns The mutated bytes with the configurable constants set.
    */
-  static setConfigurableConstants(bytes, configurableConstants, abiInterface, loaderBytecode) {
+  static setConfigurableConstants(bytes, configurableConstants, abiInterface) {
     const mutatedBytes = bytes;
     try {
-      if (!abiInterface) {
-        throw new import_errors28.FuelError(
-          import_errors28.ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
-          "Cannot validate configurable constants because the Predicate was instantiated without a JSON ABI"
-        );
-      }
       if (Object.keys(abiInterface.configurables).length === 0) {
-        throw new import_errors28.FuelError(
-          import_errors28.ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
+        throw new import_errors30.FuelError(
+          import_errors30.ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
           "Predicate has no configurable constants to be set"
         );
       }
       Object.entries(configurableConstants).forEach(([key, value]) => {
         if (!abiInterface?.configurables[key]) {
-          throw new import_errors28.FuelError(
-            import_errors28.ErrorCode.CONFIGURABLE_NOT_FOUND,
+          throw new import_errors30.FuelError(
+            import_errors30.ErrorCode.CONFIGURABLE_NOT_FOUND,
             `No configurable constant named '${key}' found in the Predicate`
           );
         }
@@ -11080,18 +11342,9 @@ var Predicate = class extends Account {
         const encoded = abiInterface.encodeConfigurable(key, value);
         mutatedBytes.set(encoded, offset);
       });
-      if (loaderBytecode) {
-        const offset = getDataOffset(bytes);
-        const dataSection = mutatedBytes.slice(offset);
-        const dataSectionLen = dataSection.length;
-        const dataSectionLenBytes = new Uint8Array(8);
-        const dataSectionLenDataView = new DataView(dataSectionLenBytes.buffer);
-        dataSectionLenDataView.setBigUint64(0, BigInt(dataSectionLen), false);
-        mutatedBytes.set((0, import_utils43.concat)([loaderBytecode, dataSectionLenBytes, dataSection]));
-      }
     } catch (err) {
-      throw new import_errors28.FuelError(
-        import_errors28.ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
+      throw new import_errors30.FuelError(
+        import_errors30.ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
         `Error setting configurable constants: ${err.message}.`
       );
     }
@@ -11119,13 +11372,35 @@ var Predicate = class extends Account {
     }
     return index;
   }
+  /**
+   *
+   * @param account - The account used to pay the deployment costs.
+   * @returns The _blobId_ and a _waitForResult_ callback that returns the deployed predicate
+   * once the blob deployment transaction finishes.
+   *
+   * The returned loader predicate will have the same configurable constants
+   * as the original predicate which was used to generate the loader predicate.
+   */
+  async deploy(account) {
+    return deployScriptOrPredicate({
+      deployer: account,
+      abi: this.interface.jsonAbi,
+      bytecode: this.bytes,
+      loaderInstanceCallback: (loaderBytecode, newAbi) => new Predicate({
+        bytecode: loaderBytecode,
+        abi: newAbi,
+        provider: this.provider,
+        data: this.predicateData
+      })
+    });
+  }
 };
 
 // src/connectors/fuel.ts
-var import_errors31 = require("@fuel-ts/errors");
+var import_errors33 = require("@fuel-ts/errors");
 
 // src/connectors/fuel-connector.ts
-var import_errors29 = require("@fuel-ts/errors");
+var import_errors31 = require("@fuel-ts/errors");
 var import_events2 = require("events");
 
 // src/connectors/types/connector-types.ts
@@ -11200,7 +11475,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Always true.
    */
   async ping() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the current version of the connector
@@ -11209,7 +11484,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns boolean - connection status.
    */
   async version() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return true if the connector is connected
@@ -11218,7 +11493,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The connection status.
    */
   async isConnected() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return all the accounts authorized for the
@@ -11227,7 +11502,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The accounts addresses strings
    */
   async accounts() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the connection process and return
@@ -11239,7 +11514,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns boolean - connection status.
    */
   async connect() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should disconnect the current connection and
@@ -11249,7 +11524,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The connection status.
    */
   async disconnect() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the sign message process and return
@@ -11261,7 +11536,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Message signature
    */
   async signMessage(_address, _message) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the sign transaction process and return
@@ -11273,7 +11548,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Transaction signature
    */
   async signTransaction(_address, _transaction) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the send transaction process and return
@@ -11289,7 +11564,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The transaction id
    */
   async sendTransaction(_address, _transaction) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the current account selected inside the connector, if the account
@@ -11300,7 +11575,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The current account selected otherwise null.
    */
   async currentAccount() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should add the assets metadata to the connector and return true if the asset
@@ -11314,7 +11589,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns True if the asset was added successfully
    */
   async addAssets(_assets) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should add the asset metadata to the connector and return true if the asset
@@ -11328,7 +11603,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns True if the asset was added successfully
    */
   async addAsset(_asset) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return all the assets added to the connector. If a connection is already established.
@@ -11336,7 +11611,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Array of assets metadata from the connector vinculated to the all accounts from a specific Wallet.
    */
   async assets() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the add network process and return true if the network was added successfully.
@@ -11347,7 +11622,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return true if the network was added successfully
    */
   async addNetwork(_networkUrl) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the select network process and return true if the network has change successfully.
@@ -11358,7 +11633,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return true if the network was added successfully
    */
   async selectNetwork(_network) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return all the networks available from the connector. If the connection is already established.
@@ -11366,7 +11641,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return all the networks added to the connector.
    */
   async networks() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the current network selected inside the connector. Even if the connection is not established.
@@ -11374,7 +11649,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return the current network selected inside the connector.
    */
   async currentNetwork() {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should add the ABI to the connector and return true if the ABI was added successfully.
@@ -11384,7 +11659,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return true if the ABI was added successfully.
    */
   async addABI(_contractId, _abi) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the ABI from the connector vinculated to the all accounts from a specific Wallet.
@@ -11393,7 +11668,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The ABI if it exists, otherwise return null.
    */
   async getABI(_id) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return true if the abi exists in the connector vinculated to the all accounts from a specific Wallet.
@@ -11402,7 +11677,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Returns true if the abi exists or false if not.
    */
   async hasABI(_id) {
-    throw new import_errors29.FuelError(import_errors29.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors31.FuelError(import_errors31.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Event listener for the connector.
@@ -11446,7 +11721,7 @@ function dispatchFuelConnectorEvent(connector) {
 }
 
 // src/connectors/utils/promises.ts
-var import_errors30 = require("@fuel-ts/errors");
+var import_errors32 = require("@fuel-ts/errors");
 function deferPromise() {
   const defer = {};
   defer.promise = new Promise((resolve, reject) => {
@@ -11458,7 +11733,7 @@ function deferPromise() {
 async function withTimeout(promise, timeout = 1050) {
   const timeoutPromise = new Promise((resolve, reject) => {
     setTimeout(() => {
-      reject(new import_errors30.FuelError(import_errors30.FuelError.CODES.TIMEOUT_EXCEEDED, "Promise timed out"));
+      reject(new import_errors32.FuelError(import_errors32.FuelError.CODES.TIMEOUT_EXCEEDED, "Promise timed out"));
     }, timeout);
   });
   return Promise.race([timeoutPromise, promise]);
@@ -11493,7 +11768,7 @@ var _Fuel = class extends FuelConnector {
       this._targetUnsubscribe = this.setupConnectorListener();
       await connectResponse;
     } catch (error) {
-      throw new import_errors31.FuelError(import_errors31.ErrorCode.INVALID_PROVIDER, "Error initializing Fuel Connector");
+      throw new import_errors33.FuelError(import_errors33.ErrorCode.INVALID_PROVIDER, "Error initializing Fuel Connector");
     }
   }
   async init() {
@@ -11559,8 +11834,8 @@ var _Fuel = class extends FuelConnector {
     const hasConnector = await this.hasConnector();
     await this.pingConnector();
     if (!this._currentConnector || !hasConnector) {
-      throw new import_errors31.FuelError(
-        import_errors31.ErrorCode.MISSING_CONNECTOR,
+      throw new import_errors33.FuelError(
+        import_errors33.ErrorCode.MISSING_CONNECTOR,
         `No connector selected for calling ${method}. Use hasConnector before executing other methods.`
       );
     }
@@ -11624,7 +11899,7 @@ var _Fuel = class extends FuelConnector {
         cacheTime: PING_CACHE_TIME
       })();
     } catch {
-      throw new import_errors31.FuelError(import_errors31.ErrorCode.INVALID_PROVIDER, "Current connector is not available.");
+      throw new import_errors33.FuelError(import_errors33.ErrorCode.INVALID_PROVIDER, "Current connector is not available.");
     }
   }
   /**
@@ -11773,7 +12048,7 @@ var _Fuel = class extends FuelConnector {
       const currentNetwork = await this.currentNetwork();
       provider = await Provider.create(currentNetwork.url);
     } else {
-      throw new import_errors31.FuelError(import_errors31.ErrorCode.INVALID_PROVIDER, "Provider is not valid.");
+      throw new import_errors33.FuelError(import_errors33.ErrorCode.INVALID_PROVIDER, "Provider is not valid.");
     }
     return provider;
   }
@@ -11881,6 +12156,7 @@ __publicField(Fuel, "defaultConfig", {});
   calculateTXFeeForSummary,
   coinQuantityfy,
   deferPromise,
+  deployScriptOrPredicate,
   dispatchFuelConnectorEvent,
   english,
   extractBurnedAssetsFromReceipts,