@fuel-ts/account 0.0.0-rc-2037-20240430170043 → 0.0.0-rc-2037-20240501112942

package/dist/test-utils.mjs

@@ -26,8 +26,8 @@ import { hexlify as hexlify15 } from "@fuel-ts/utils";
 import { Address as Address3 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode15, FuelError as FuelError15 } from "@fuel-ts/errors";
 import { AbstractAccount } from "@fuel-ts/interfaces";
-import { bn as bn18 } from "@fuel-ts/math";
-import { arrayify as arrayify14, isDefined } from "@fuel-ts/utils";
+import { bn as bn19 } from "@fuel-ts/math";
+import { arrayify as arrayify14, isDefined as isDefined2 } from "@fuel-ts/utils";
 import { clone as clone4 } from "ramda";
 
 // src/providers/coin-quantity.ts
@@ -68,9 +68,9 @@ var addAmountToCoinQuantities = (params) => {
 // src/providers/provider.ts
 import { Address as Address2 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode13, FuelError as FuelError13 } from "@fuel-ts/errors";
-import { BN, bn as bn16 } from "@fuel-ts/math";
+import { BN, bn as bn17 } from "@fuel-ts/math";
 import {
-  InputType as InputType8,
+  InputType as InputType7,
   TransactionType as TransactionType8,
   InputMessageCoder,
   TransactionCoder as TransactionCoder5
@@ -1240,7 +1240,7 @@ import { UTXO_ID_LEN as UTXO_ID_LEN2 } from "@fuel-ts/abi-coder";
 import { Address, addressify } from "@fuel-ts/address";
 import { ZeroBytes32 as ZeroBytes324 } from "@fuel-ts/address/configs";
 import { randomBytes } from "@fuel-ts/crypto";
-import { bn as bn7 } from "@fuel-ts/math";
+import { bn as bn8 } from "@fuel-ts/math";
 import {
   PolicyType,
   TransactionCoder,
@@ -1248,7 +1248,7 @@ import {
   OutputType as OutputType2,
   TransactionType
 } from "@fuel-ts/transactions";
-import { concat, hexlify as hexlify7 } from "@fuel-ts/utils";
+import { concat, hexlify as hexlify7, isDefined } from "@fuel-ts/utils";
 
 // src/providers/resource.ts
 var isCoin = (resource) => "id" in resource;
@@ -1561,7 +1561,7 @@ function calculateMetadataGasForTxScript({
 }
 var calculateGasFee = (params) => {
   const { gas, gasPrice, priceFactor, tip } = params;
-  return gas.mul(gasPrice).div(priceFactor).add(tip);
+  return gas.mul(gasPrice).div(priceFactor).add(bn5(tip));
 };
 
 // src/providers/utils/json.ts
@@ -1695,10 +1695,34 @@ var NoWitnessAtIndexError = class extends Error {
 };
 
 // src/providers/transaction-request/helpers.ts
+import { bn as bn7 } from "@fuel-ts/math";
 import { InputType as InputType2 } from "@fuel-ts/transactions";
 var isRequestInputCoin = (input) => input.type === InputType2.Coin;
 var isRequestInputMessage = (input) => input.type === InputType2.Message;
 var isRequestInputResource = (input) => isRequestInputCoin(input) || isRequestInputMessage(input);
+var getAssetAmountInRequestInputs = (inputs, assetId, baseAsset) => inputs.filter(isRequestInputResource).reduce((acc, input) => {
+  if (isRequestInputCoin(input) && input.assetId === assetId) {
+    return acc.add(input.amount);
+  }
+  if (isRequestInputMessage(input) && assetId === baseAsset) {
+    return acc.add(input.amount);
+  }
+  return acc;
+}, bn7(0));
+var cacheRequestInputsResourcesFromOwner = (inputs, owner) => inputs.reduce(
+  (acc, input) => {
+    if (isRequestInputCoin(input) && input.owner === owner.toB256()) {
+      acc.utxos.push(input.id);
+    } else if (isRequestInputMessage(input) && input.recipient === owner.toB256()) {
+      acc.messages.push(input.nonce);
+    }
+    return acc;
+  },
+  {
+    utxos: [],
+    messages: []
+  }
+);
 
 // src/providers/transaction-request/witness.ts
 import { arrayify as arrayify4, hexlify as hexlify6 } from "@fuel-ts/utils";
@@ -1740,10 +1764,10 @@ var BaseTransactionRequest = class {
     outputs,
     witnesses
   } = {}) {
-    this.tip = bn7(tip);
-    this.maturity = maturity ?? 0;
-    this.witnessLimit = witnessLimit ? bn7(witnessLimit) : void 0;
-    this.maxFee = maxFee ? bn7(maxFee) : void 0;
+    this.tip = tip ? bn8(tip) : void 0;
+    this.maturity = maturity && maturity > 0 ? maturity : void 0;
+    this.witnessLimit = isDefined(witnessLimit) ? bn8(witnessLimit) : void 0;
+    this.maxFee = bn8(maxFee);
     this.inputs = inputs ?? [];
     this.outputs = outputs ?? [];
     this.witnesses = witnesses ?? [];
@@ -1751,22 +1775,21 @@ var BaseTransactionRequest = class {
   static getPolicyMeta(req) {
     let policyTypes = 0;
     const policies = [];
-    if (req.tip) {
+    const { tip, witnessLimit, maturity } = req;
+    if (bn8(tip).gt(0)) {
       policyTypes += PolicyType.Tip;
-      policies.push({ data: req.tip, type: PolicyType.Tip });
+      policies.push({ data: bn8(tip), type: PolicyType.Tip });
     }
-    if (req.witnessLimit) {
+    if (isDefined(witnessLimit) && bn8(witnessLimit).gte(0)) {
       policyTypes += PolicyType.WitnessLimit;
-      policies.push({ data: req.witnessLimit, type: PolicyType.WitnessLimit });
+      policies.push({ data: bn8(witnessLimit), type: PolicyType.WitnessLimit });
     }
-    if (req.maturity > 0) {
+    if (maturity && maturity > 0) {
       policyTypes += PolicyType.Maturity;
-      policies.push({ data: req.maturity, type: PolicyType.Maturity });
-    }
-    if (req.maxFee) {
-      policyTypes += PolicyType.MaxFee;
-      policies.push({ data: req.maxFee, type: PolicyType.MaxFee });
+      policies.push({ data: maturity, type: PolicyType.Maturity });
     }
+    policyTypes += PolicyType.MaxFee;
+    policies.push({ data: req.maxFee, type: PolicyType.MaxFee });
     return {
       policyTypes,
       policies
@@ -2127,7 +2150,7 @@ var BaseTransactionRequest = class {
       const assetInput = findAssetInput(assetId);
       let usedQuantity = quantity;
       if (assetId === baseAssetId) {
-        usedQuantity = bn7("1000000000000000000");
+        usedQuantity = bn8("1000000000000000000");
       }
       if (assetInput && "assetId" in assetInput) {
         assetInput.id = hexlify7(randomBytes(UTXO_ID_LEN2));
@@ -2139,13 +2162,13 @@ var BaseTransactionRequest = class {
             amount: usedQuantity,
             assetId,
             owner: resourcesOwner || Address.fromRandom(),
-            blockCreated: bn7(1),
-            txCreatedIdx: bn7(1)
+            blockCreated: bn8(1),
+            txCreatedIdx: bn8(1)
           }
         ]);
       }
     };
-    updateAssetInput(baseAssetId, bn7(1e11));
+    updateAssetInput(baseAssetId, bn8(1e11));
     quantities.forEach((q) => updateAssetInput(q.assetId, q.amount));
   }
   /**
@@ -2156,7 +2179,7 @@ var BaseTransactionRequest = class {
    */
   getCoinOutputsQuantities() {
     const coinsQuantities = this.getCoinOutputs().map(({ amount, assetId }) => ({
-      amount: bn7(amount),
+      amount: bn8(amount),
       assetId: assetId.toString()
     }));
     return coinsQuantities;
@@ -2196,7 +2219,7 @@ var BaseTransactionRequest = class {
         default:
           return;
       }
-      if (correspondingInput && "predicateGasUsed" in correspondingInput && bn7(correspondingInput.predicateGasUsed).gt(0)) {
+      if (correspondingInput && "predicateGasUsed" in correspondingInput && bn8(correspondingInput.predicateGasUsed).gt(0)) {
         i.predicate = correspondingInput.predicate;
         i.predicateData = correspondingInput.predicateData;
         i.predicateGasUsed = correspondingInput.predicateGasUsed;
@@ -2216,14 +2239,14 @@ var BaseTransactionRequest = class {
 
 // src/providers/transaction-request/create-transaction-request.ts
 import { ZeroBytes32 as ZeroBytes326 } from "@fuel-ts/address/configs";
-import { bn as bn9 } from "@fuel-ts/math";
+import { bn as bn10 } from "@fuel-ts/math";
 import { TransactionType as TransactionType3, OutputType as OutputType4 } from "@fuel-ts/transactions";
 import { arrayify as arrayify6, hexlify as hexlify9 } from "@fuel-ts/utils";
 
 // src/providers/transaction-request/hash-transaction.ts
 import { ZeroBytes32 as ZeroBytes325 } from "@fuel-ts/address/configs";
 import { uint64ToBytesBE, sha256 } from "@fuel-ts/hasher";
-import { bn as bn8 } from "@fuel-ts/math";
+import { bn as bn9 } from "@fuel-ts/math";
 import { TransactionType as TransactionType2, InputType as InputType4, OutputType as OutputType3, TransactionCoder as TransactionCoder2 } from "@fuel-ts/transactions";
 import { concat as concat2 } from "@fuel-ts/utils";
 import { clone as clone2 } from "ramda";
@@ -2240,11 +2263,11 @@ function hashTransaction(transactionRequest, chainId) {
           blockHeight: 0,
           txIndex: 0
         };
-        inputClone.predicateGasUsed = bn8(0);
+        inputClone.predicateGasUsed = bn9(0);
         return inputClone;
       }
       case InputType4.Message: {
-        inputClone.predicateGasUsed = bn8(0);
+        inputClone.predicateGasUsed = bn9(0);
         return inputClone;
       }
       case InputType4.Contract: {
@@ -2271,12 +2294,12 @@ function hashTransaction(transactionRequest, chainId) {
         return outputClone;
       }
       case OutputType3.Change: {
-        outputClone.amount = bn8(0);
+        outputClone.amount = bn9(0);
         return outputClone;
       }
       case OutputType3.Variable: {
         outputClone.to = ZeroBytes325;
-        outputClone.amount = bn8(0);
+        outputClone.amount = bn9(0);
         outputClone.assetId = ZeroBytes325;
         return outputClone;
       }
@@ -2354,7 +2377,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
       type: TransactionType3.Create,
       ...baseTransaction,
       bytecodeWitnessIndex,
-      storageSlotsCount: bn9(storageSlots.length),
+      storageSlotsCount: bn10(storageSlots.length),
       salt: this.salt ? hexlify9(this.salt) : ZeroBytes326,
       storageSlots
     };
@@ -2394,7 +2417,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
   }
   metadataGas(gasCosts) {
     return calculateMetadataGasForTxCreate({
-      contractBytesSize: bn9(arrayify6(this.witnesses[this.bytecodeWitnessIndex] || "0x").length),
+      contractBytesSize: bn10(arrayify6(this.witnesses[this.bytecodeWitnessIndex] || "0x").length),
       gasCosts,
       stateRootSize: this.storageSlots.length,
       txBytesSize: this.byteSize()
@@ -2406,7 +2429,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
 import { Interface } from "@fuel-ts/abi-coder";
 import { addressify as addressify2 } from "@fuel-ts/address";
 import { ZeroBytes32 as ZeroBytes327 } from "@fuel-ts/address/configs";
-import { bn as bn10 } from "@fuel-ts/math";
+import { bn as bn11 } from "@fuel-ts/math";
 import { InputType as InputType5, OutputType as OutputType5, TransactionType as TransactionType4 } from "@fuel-ts/transactions";
 import { arrayify as arrayify8, hexlify as hexlify10 } from "@fuel-ts/utils";
 
@@ -2460,7 +2483,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
    */
   constructor({ script, scriptData, gasLimit, ...rest } = {}) {
     super(rest);
-    this.gasLimit = bn10(gasLimit);
+    this.gasLimit = bn11(gasLimit);
     this.script = arrayify8(script ?? returnZeroScript.bytes);
     this.scriptData = arrayify8(scriptData ?? returnZeroScript.encodeScriptData());
     this.abis = rest.abis;
@@ -2477,8 +2500,8 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
       type: TransactionType4.Script,
       scriptGasLimit: this.gasLimit,
       ...super.getBaseTransaction(),
-      scriptLength: bn10(script.length),
-      scriptDataLength: bn10(scriptData.length),
+      scriptLength: bn11(script.length),
+      scriptDataLength: bn11(scriptData.length),
       receiptsRoot: ZeroBytes327,
       script: hexlify10(script),
       scriptData: hexlify10(scriptData)
@@ -2610,7 +2633,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
 
 // src/providers/transaction-request/utils.ts
 import { ErrorCode as ErrorCode8, FuelError as FuelError8 } from "@fuel-ts/errors";
-import { TransactionType as TransactionType5, InputType as InputType6 } from "@fuel-ts/transactions";
+import { TransactionType as TransactionType5 } from "@fuel-ts/transactions";
 var transactionRequestify = (obj) => {
   if (obj instanceof ScriptTransactionRequest || obj instanceof CreateTransactionRequest) {
     return obj;
@@ -2628,35 +2651,20 @@ var transactionRequestify = (obj) => {
     }
   }
 };
-var cacheTxInputsFromOwner = (inputs, owner) => inputs.reduce(
-  (acc, input) => {
-    if (input.type === InputType6.Coin && input.owner === owner) {
-      acc.utxos.push(input.id);
-    }
-    if (input.type === InputType6.Message && input.recipient === owner) {
-      acc.messages.push(input.nonce);
-    }
-    return acc;
-  },
-  {
-    utxos: [],
-    messages: []
-  }
-);
 
 // src/providers/transaction-response/transaction-response.ts
 import { ErrorCode as ErrorCode12, FuelError as FuelError12 } from "@fuel-ts/errors";
-import { bn as bn15 } from "@fuel-ts/math";
+import { bn as bn16 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder4 } from "@fuel-ts/transactions";
 import { arrayify as arrayify10 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/assemble-transaction-summary.ts
-import { bn as bn14 } from "@fuel-ts/math";
+import { bn as bn15 } from "@fuel-ts/math";
 import { PolicyType as PolicyType3 } from "@fuel-ts/transactions";
 import { DateTime, hexlify as hexlify11 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/calculate-transaction-fee.ts
-import { bn as bn11 } from "@fuel-ts/math";
+import { bn as bn12 } from "@fuel-ts/math";
 import { PolicyType as PolicyType2, TransactionCoder as TransactionCoder3, TransactionType as TransactionType6 } from "@fuel-ts/transactions";
 import { arrayify as arrayify9 } from "@fuel-ts/utils";
 var calculateTransactionFee = (params) => {
@@ -2666,23 +2674,23 @@ var calculateTransactionFee = (params) => {
     tip,
     consensusParameters: { gasCosts, feeParams, maxGasPerTx }
   } = params;
-  const gasPerByte = bn11(feeParams.gasPerByte);
-  const gasPriceFactor = bn11(feeParams.gasPriceFactor);
+  const gasPerByte = bn12(feeParams.gasPerByte);
+  const gasPriceFactor = bn12(feeParams.gasPriceFactor);
   const transactionBytes = arrayify9(rawPayload);
   const [transaction] = new TransactionCoder3().decode(transactionBytes, 0);
   if (transaction.type === TransactionType6.Mint) {
     return {
-      fee: bn11(0),
-      minFee: bn11(0),
-      maxFee: bn11(0)
+      fee: bn12(0),
+      minFee: bn12(0),
+      maxFee: bn12(0)
     };
   }
   const { type, witnesses, inputs, policies } = transaction;
-  let metadataGas = bn11(0);
-  let gasLimit = bn11(0);
+  let metadataGas = bn12(0);
+  let gasLimit = bn12(0);
   if (type === TransactionType6.Create) {
     const { bytecodeWitnessIndex, storageSlots } = transaction;
-    const contractBytesSize = bn11(arrayify9(witnesses[bytecodeWitnessIndex].data).length);
+    const contractBytesSize = bn12(arrayify9(witnesses[bytecodeWitnessIndex].data).length);
     metadataGas = calculateMetadataGasForTxCreate({
       contractBytesSize,
       gasCosts,
@@ -2701,7 +2709,7 @@ var calculateTransactionFee = (params) => {
   }
   const minGas = getMinGas({
     gasCosts,
-    gasPerByte: bn11(gasPerByte),
+    gasPerByte: bn12(gasPerByte),
     inputs,
     metadataGas,
     txBytesSize: transactionBytes.length
@@ -2738,12 +2746,12 @@ var calculateTransactionFee = (params) => {
 // src/providers/transaction-summary/operations.ts
 import { ZeroBytes32 as ZeroBytes328 } from "@fuel-ts/address/configs";
 import { ErrorCode as ErrorCode10, FuelError as FuelError10 } from "@fuel-ts/errors";
-import { bn as bn13 } from "@fuel-ts/math";
+import { bn as bn14 } from "@fuel-ts/math";
 import { ReceiptType as ReceiptType4, TransactionType as TransactionType7 } from "@fuel-ts/transactions";
 
 // src/providers/transaction-summary/call.ts
 import { Interface as Interface2, calculateVmTxMemory } from "@fuel-ts/abi-coder";
-import { bn as bn12 } from "@fuel-ts/math";
+import { bn as bn13 } from "@fuel-ts/math";
 var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
   const abiInterface = new Interface2(abi);
   const callFunctionSelector = receipt.param1.toHex(8);
@@ -2752,7 +2760,7 @@ var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
   let encodedArgs;
   if (functionFragment.isInputDataPointer) {
     if (rawPayload) {
-      const argsOffset = bn12(receipt.param2).sub(calculateVmTxMemory({ maxInputs: maxInputs.toNumber() })).toNumber();
+      const argsOffset = bn13(receipt.param2).sub(calculateVmTxMemory({ maxInputs: maxInputs.toNumber() })).toNumber();
       encodedArgs = `0x${rawPayload.slice(2).slice(argsOffset * 2)}`;
     }
   } else {
@@ -2787,7 +2795,7 @@ var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
 
 // src/providers/transaction-summary/input.ts
 import { ErrorCode as ErrorCode9, FuelError as FuelError9 } from "@fuel-ts/errors";
-import { InputType as InputType7 } from "@fuel-ts/transactions";
+import { InputType as InputType6 } from "@fuel-ts/transactions";
 function getInputsByTypes(inputs, types) {
   return inputs.filter((i) => types.includes(i.type));
 }
@@ -2795,16 +2803,16 @@ function getInputsByType(inputs, type) {
   return inputs.filter((i) => i.type === type);
 }
 function getInputsCoin(inputs) {
-  return getInputsByType(inputs, InputType7.Coin);
+  return getInputsByType(inputs, InputType6.Coin);
 }
 function getInputsMessage(inputs) {
-  return getInputsByType(inputs, InputType7.Message);
+  return getInputsByType(inputs, InputType6.Message);
 }
 function getInputsCoinAndMessage(inputs) {
-  return getInputsByTypes(inputs, [InputType7.Coin, InputType7.Message]);
+  return getInputsByTypes(inputs, [InputType6.Coin, InputType6.Message]);
 }
 function getInputsContract(inputs) {
-  return getInputsByType(inputs, InputType7.Contract);
+  return getInputsByType(inputs, InputType6.Contract);
 }
 function getInputFromAssetId(inputs, assetId) {
   const coinInputs = getInputsCoin(inputs);
@@ -2823,7 +2831,7 @@ function getInputContractFromIndex(inputs, inputIndex) {
   if (!contractInput) {
     return void 0;
   }
-  if (contractInput.type !== InputType7.Contract) {
+  if (contractInput.type !== InputType6.Contract) {
     throw new FuelError9(
       ErrorCode9.INVALID_TRANSACTION_INPUT,
       `Contract input should be of type 'contract'.`
@@ -2832,10 +2840,10 @@ function getInputContractFromIndex(inputs, inputIndex) {
   return contractInput;
 }
 function getInputAccountAddress(input) {
-  if (input.type === InputType7.Coin) {
+  if (input.type === InputType6.Coin) {
     return input.owner.toString();
   }
-  if (input.type === InputType7.Message) {
+  if (input.type === InputType6.Message) {
     return input.recipient.toString();
   }
   return "";
@@ -2908,7 +2916,7 @@ var mergeAssets = (op1, op2) => {
     if (!matchingAsset) {
       return asset1;
     }
-    const mergedAmount = bn13(asset1.amount).add(matchingAsset.amount);
+    const mergedAmount = bn14(asset1.amount).add(matchingAsset.amount);
     return { ...asset1, amount: mergedAmount };
   });
   return mergedAssets.concat(filteredAssets);
@@ -3314,7 +3322,7 @@ function assembleTransactionSummary(params) {
     maxInputs
   });
   const typeName = getTransactionTypeName(transaction.type);
-  const tip = bn14(transaction.policies?.find((policy) => policy.type === PolicyType3.Tip)?.data);
+  const tip = bn15(transaction.policies?.find((policy) => policy.type === PolicyType3.Tip)?.data);
   const { fee } = calculateTransactionFee({
     gasPrice,
     rawPayload,
@@ -3381,7 +3389,7 @@ var TransactionResponse = class {
   /** Current provider */
   provider;
   /** Gas used on the transaction */
-  gasUsed = bn15(0);
+  gasUsed = bn16(0);
   /** The graphql Transaction with receipts object. */
   gqlTransaction;
   abis;
@@ -3605,30 +3613,30 @@ var processGqlChain = (chain) => {
   const { contractParams, feeParams, predicateParams, scriptParams, txParams, gasCosts } = consensusParameters;
   return {
     name,
-    baseChainHeight: bn16(daHeight),
+    baseChainHeight: bn17(daHeight),
     consensusParameters: {
-      contractMaxSize: bn16(contractParams.contractMaxSize),
-      maxInputs: bn16(txParams.maxInputs),
-      maxOutputs: bn16(txParams.maxOutputs),
-      maxWitnesses: bn16(txParams.maxWitnesses),
-      maxGasPerTx: bn16(txParams.maxGasPerTx),
-      maxScriptLength: bn16(scriptParams.maxScriptLength),
-      maxScriptDataLength: bn16(scriptParams.maxScriptDataLength),
-      maxStorageSlots: bn16(contractParams.maxStorageSlots),
-      maxPredicateLength: bn16(predicateParams.maxPredicateLength),
-      maxPredicateDataLength: bn16(predicateParams.maxPredicateDataLength),
-      maxGasPerPredicate: bn16(predicateParams.maxGasPerPredicate),
-      gasPriceFactor: bn16(feeParams.gasPriceFactor),
-      gasPerByte: bn16(feeParams.gasPerByte),
-      maxMessageDataLength: bn16(predicateParams.maxMessageDataLength),
-      chainId: bn16(consensusParameters.chainId),
+      contractMaxSize: bn17(contractParams.contractMaxSize),
+      maxInputs: bn17(txParams.maxInputs),
+      maxOutputs: bn17(txParams.maxOutputs),
+      maxWitnesses: bn17(txParams.maxWitnesses),
+      maxGasPerTx: bn17(txParams.maxGasPerTx),
+      maxScriptLength: bn17(scriptParams.maxScriptLength),
+      maxScriptDataLength: bn17(scriptParams.maxScriptDataLength),
+      maxStorageSlots: bn17(contractParams.maxStorageSlots),
+      maxPredicateLength: bn17(predicateParams.maxPredicateLength),
+      maxPredicateDataLength: bn17(predicateParams.maxPredicateDataLength),
+      maxGasPerPredicate: bn17(predicateParams.maxGasPerPredicate),
+      gasPriceFactor: bn17(feeParams.gasPriceFactor),
+      gasPerByte: bn17(feeParams.gasPerByte),
+      maxMessageDataLength: bn17(predicateParams.maxMessageDataLength),
+      chainId: bn17(consensusParameters.chainId),
       baseAssetId: consensusParameters.baseAssetId,
       gasCosts
     },
     gasCosts,
     latestBlock: {
       id: latestBlock.id,
-      height: bn16(latestBlock.height),
+      height: bn17(latestBlock.height),
       time: latestBlock.header.time,
       transactions: latestBlock.transactions.map((i) => ({
         id: i.id
@@ -3771,7 +3779,18 @@ var _Provider = class {
   createOperations() {
     const fetchFn = _Provider.getFetchFn(this.options);
     const gqlClient = new GraphQLClient(this.url, {
-      fetch: (url, requestInit) => fetchFn(url, requestInit, this.options)
+      fetch: (url, requestInit) => fetchFn(url, requestInit, this.options),
+      responseMiddleware: (response) => {
+        if ("response" in response) {
+          const graphQlResponse = response.response;
+          if (Array.isArray(graphQlResponse?.errors)) {
+            throw new FuelError13(
+              FuelError13.CODES.INVALID_REQUEST,
+              graphQlResponse.errors.map((err) => err.message).join("\n\n")
+            );
+          }
+        }
+      }
     });
     const executeQuery = (query, vars) => {
       const opDefinition = query.definitions.find((x) => x.kind === "OperationDefinition");
@@ -3806,7 +3825,7 @@ var _Provider = class {
    */
   async getBlockNumber() {
     const { chain } = await this.operations.getChain();
-    return bn16(chain.latestBlock.height, 10);
+    return bn17(chain.latestBlock.height, 10);
   }
   /**
    * Returns the chain information.
@@ -3816,8 +3835,8 @@ var _Provider = class {
   async fetchNode() {
     const { nodeInfo } = await this.operations.getNodeInfo();
     const processedNodeInfo = {
-      maxDepth: bn16(nodeInfo.maxDepth),
-      maxTx: bn16(nodeInfo.maxTx),
+      maxDepth: bn17(nodeInfo.maxDepth),
+      maxTx: bn17(nodeInfo.maxTx),
       nodeVersion: nodeInfo.nodeVersion,
       utxoValidation: nodeInfo.utxoValidation,
       vmBacktrace: nodeInfo.vmBacktrace
@@ -3949,7 +3968,7 @@ var _Provider = class {
     } = response;
     if (inputs) {
       inputs.forEach((input, index) => {
-        if ("predicateGasUsed" in input && bn16(input.predicateGasUsed).gt(0)) {
+        if ("predicateGasUsed" in input && bn17(input.predicateGasUsed).gt(0)) {
           transactionRequest.inputs[index].predicateGasUsed = input.predicateGasUsed;
         }
       });
@@ -4107,12 +4126,12 @@ var _Provider = class {
       gasPrice = await this.estimateGasPrice(10);
     }
     const minFee = calculateGasFee({
-      gasPrice: bn16(gasPrice),
+      gasPrice: bn17(gasPrice),
       gas: minGas,
       priceFactor: gasPriceFactor,
       tip: transactionRequest.tip
     }).add(1);
-    let gasLimit = bn16(0);
+    let gasLimit = bn17(0);
     if (transactionRequest.type === TransactionType8.Script) {
       gasLimit = transactionRequest.gasLimit;
       if (transactionRequest.gasLimit.eq(0)) {
@@ -4125,7 +4144,7 @@ var _Provider = class {
     }
     const maxGas = transactionRequest.calculateMaxGas(chainInfo, minGas);
     const maxFee = calculateGasFee({
-      gasPrice: bn16(gasPrice),
+      gasPrice: bn17(gasPrice),
       gas: maxGas,
       priceFactor: gasPriceFactor,
       tip: transactionRequest.tip
@@ -4188,9 +4207,9 @@ var _Provider = class {
     const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
     const allQuantities = mergeQuantities(coinOutputsQuantities, quantitiesToContract);
     txRequestClone.fundWithFakeUtxos(allQuantities, baseAssetId, resourcesOwner?.address);
-    txRequestClone.maxFee = bn16(0);
+    txRequestClone.maxFee = bn17(0);
     if (isScriptTransaction) {
-      txRequestClone.gasLimit = bn16(0);
+      txRequestClone.gasLimit = bn17(0);
     }
     if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
       resourcesOwner.populateTransactionPredicateData(txRequestClone);
@@ -4209,7 +4228,7 @@ var _Provider = class {
     let receipts = [];
     let missingContractIds = [];
     let outputVariables = 0;
-    let gasUsed = bn16(0);
+    let gasUsed = bn17(0);
     txRequestClone.updatePredicateGasUsed(signedRequest.inputs);
     txRequestClone.maxFee = maxFee;
     if (isScriptTransaction) {
@@ -4276,10 +4295,10 @@ var _Provider = class {
     return coins.map((coin) => ({
       id: coin.utxoId,
       assetId: coin.assetId,
-      amount: bn16(coin.amount),
+      amount: bn17(coin.amount),
       owner: Address2.fromAddressOrString(coin.owner),
-      blockCreated: bn16(coin.blockCreated),
-      txCreatedIdx: bn16(coin.txCreatedIdx)
+      blockCreated: bn17(coin.blockCreated),
+      txCreatedIdx: bn17(coin.txCreatedIdx)
     }));
   }
   /**
@@ -4316,9 +4335,9 @@ var _Provider = class {
       switch (coin.__typename) {
         case "MessageCoin":
           return {
-            amount: bn16(coin.amount),
+            amount: bn17(coin.amount),
             assetId: coin.assetId,
-            daHeight: bn16(coin.daHeight),
+            daHeight: bn17(coin.daHeight),
             sender: Address2.fromAddressOrString(coin.sender),
             recipient: Address2.fromAddressOrString(coin.recipient),
             nonce: coin.nonce
@@ -4326,11 +4345,11 @@ var _Provider = class {
         case "Coin":
           return {
             id: coin.utxoId,
-            amount: bn16(coin.amount),
+            amount: bn17(coin.amount),
             assetId: coin.assetId,
             owner: Address2.fromAddressOrString(coin.owner),
-            blockCreated: bn16(coin.blockCreated),
-            txCreatedIdx: bn16(coin.txCreatedIdx)
+            blockCreated: bn17(coin.blockCreated),
+            txCreatedIdx: bn17(coin.txCreatedIdx)
           };
         default:
           return null;
@@ -4347,13 +4366,13 @@ var _Provider = class {
   async getBlock(idOrHeight) {
     let variables;
     if (typeof idOrHeight === "number") {
-      variables = { height: bn16(idOrHeight).toString(10) };
+      variables = { height: bn17(idOrHeight).toString(10) };
     } else if (idOrHeight === "latest") {
       variables = { height: (await this.getBlockNumber()).toString(10) };
     } else if (idOrHeight.length === 66) {
       variables = { blockId: idOrHeight };
     } else {
-      variables = { blockId: bn16(idOrHeight).toString(10) };
+      variables = { blockId: bn17(idOrHeight).toString(10) };
     }
     const { block } = await this.operations.getBlock(variables);
     if (!block) {
@@ -4361,7 +4380,7 @@ var _Provider = class {
     }
     return {
       id: block.id,
-      height: bn16(block.height),
+      height: bn17(block.height),
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id)
     };
@@ -4376,7 +4395,7 @@ var _Provider = class {
     const { blocks: fetchedData } = await this.operations.getBlocks(params);
     const blocks = fetchedData.edges.map(({ node: block }) => ({
       id: block.id,
-      height: bn16(block.height),
+      height: bn17(block.height),
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id)
     }));
@@ -4391,7 +4410,7 @@ var _Provider = class {
   async getBlockWithTransactions(idOrHeight) {
     let variables;
     if (typeof idOrHeight === "number") {
-      variables = { blockHeight: bn16(idOrHeight).toString(10) };
+      variables = { blockHeight: bn17(idOrHeight).toString(10) };
     } else if (idOrHeight === "latest") {
       variables = { blockHeight: (await this.getBlockNumber()).toString() };
     } else {
@@ -4403,7 +4422,7 @@ var _Provider = class {
     }
     return {
       id: block.id,
-      height: bn16(block.height, 10),
+      height: bn17(block.height, 10),
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id),
       transactions: block.transactions.map(
@@ -4452,7 +4471,7 @@ var _Provider = class {
       contract: Address2.fromAddressOrString(contractId).toB256(),
       asset: hexlify12(assetId)
     });
-    return bn16(contractBalance.amount, 10);
+    return bn17(contractBalance.amount, 10);
   }
   /**
    * Returns the balance for the given owner for the given asset ID.
@@ -4466,7 +4485,7 @@ var _Provider = class {
       owner: Address2.fromAddressOrString(owner).toB256(),
       assetId: hexlify12(assetId)
     });
-    return bn16(balance.amount, 10);
+    return bn17(balance.amount, 10);
   }
   /**
    * Returns balances for the given owner.
@@ -4484,7 +4503,7 @@ var _Provider = class {
     const balances = result.balances.edges.map((edge) => edge.node);
     return balances.map((balance) => ({
       assetId: balance.assetId,
-      amount: bn16(balance.amount)
+      amount: bn17(balance.amount)
     }));
   }
   /**
@@ -4506,15 +4525,15 @@ var _Provider = class {
         sender: message.sender,
         recipient: message.recipient,
         nonce: message.nonce,
-        amount: bn16(message.amount),
+        amount: bn17(message.amount),
         data: message.data
       }),
       sender: Address2.fromAddressOrString(message.sender),
       recipient: Address2.fromAddressOrString(message.recipient),
       nonce: message.nonce,
-      amount: bn16(message.amount),
+      amount: bn17(message.amount),
       data: InputMessageCoder.decodeData(message.data),
-      daHeight: bn16(message.daHeight)
+      daHeight: bn17(message.daHeight)
     }));
   }
   /**
@@ -4567,23 +4586,23 @@ var _Provider = class {
     } = result.messageProof;
     return {
       messageProof: {
-        proofIndex: bn16(messageProof.proofIndex),
+        proofIndex: bn17(messageProof.proofIndex),
         proofSet: messageProof.proofSet
       },
       blockProof: {
-        proofIndex: bn16(blockProof.proofIndex),
+        proofIndex: bn17(blockProof.proofIndex),
         proofSet: blockProof.proofSet
       },
       messageBlockHeader: {
         id: messageBlockHeader.id,
-        daHeight: bn16(messageBlockHeader.daHeight),
-        transactionsCount: bn16(messageBlockHeader.transactionsCount),
+        daHeight: bn17(messageBlockHeader.daHeight),
+        transactionsCount: bn17(messageBlockHeader.transactionsCount),
         transactionsRoot: messageBlockHeader.transactionsRoot,
-        height: bn16(messageBlockHeader.height),
+        height: bn17(messageBlockHeader.height),
         prevRoot: messageBlockHeader.prevRoot,
         time: messageBlockHeader.time,
         applicationHash: messageBlockHeader.applicationHash,
-        messageReceiptCount: bn16(messageBlockHeader.messageReceiptCount),
+        messageReceiptCount: bn17(messageBlockHeader.messageReceiptCount),
         messageOutboxRoot: messageBlockHeader.messageOutboxRoot,
         consensusParametersVersion: messageBlockHeader.consensusParametersVersion,
         eventInboxRoot: messageBlockHeader.eventInboxRoot,
@@ -4591,14 +4610,14 @@ var _Provider = class {
       },
       commitBlockHeader: {
         id: commitBlockHeader.id,
-        daHeight: bn16(commitBlockHeader.daHeight),
-        transactionsCount: bn16(commitBlockHeader.transactionsCount),
+        daHeight: bn17(commitBlockHeader.daHeight),
+        transactionsCount: bn17(commitBlockHeader.transactionsCount),
         transactionsRoot: commitBlockHeader.transactionsRoot,
-        height: bn16(commitBlockHeader.height),
+        height: bn17(commitBlockHeader.height),
         prevRoot: commitBlockHeader.prevRoot,
         time: commitBlockHeader.time,
         applicationHash: commitBlockHeader.applicationHash,
-        messageReceiptCount: bn16(commitBlockHeader.messageReceiptCount),
+        messageReceiptCount: bn17(commitBlockHeader.messageReceiptCount),
         messageOutboxRoot: commitBlockHeader.messageOutboxRoot,
         consensusParametersVersion: commitBlockHeader.consensusParametersVersion,
         eventInboxRoot: commitBlockHeader.eventInboxRoot,
@@ -4607,19 +4626,19 @@ var _Provider = class {
       sender: Address2.fromAddressOrString(sender),
       recipient: Address2.fromAddressOrString(recipient),
       nonce,
-      amount: bn16(amount),
+      amount: bn17(amount),
       data
     };
   }
   async getLatestGasPrice() {
     const { latestGasPrice } = await this.operations.getLatestGasPrice();
-    return bn16(latestGasPrice.gasPrice);
+    return bn17(latestGasPrice.gasPrice);
   }
   async estimateGasPrice(blockHorizon) {
     const { estimateGasPrice } = await this.operations.estimateGasPrice({
       blockHorizon: String(blockHorizon)
     });
-    return bn16(estimateGasPrice.gasPrice);
+    return bn17(estimateGasPrice.gasPrice);
   }
   /**
    * Returns Message Proof for given transaction id and the message id from MessageOut receipt.
@@ -4640,10 +4659,10 @@ var _Provider = class {
    */
   async produceBlocks(amount, startTime) {
     const { produceBlocks: latestBlockHeight } = await this.operations.produceBlocks({
-      blocksToProduce: bn16(amount).toString(10),
+      blocksToProduce: bn17(amount).toString(10),
       startTimestamp: startTime ? DateTime2.fromUnixMilliseconds(startTime).toTai64() : void 0
     });
-    return bn16(latestBlockHeight);
+    return bn17(latestBlockHeight);
   }
   // eslint-disable-next-line @typescript-eslint/require-await
   async getTransactionResponse(transactionId) {
@@ -4670,7 +4689,7 @@ cacheInputs_fn = function(inputs) {
     return;
   }
   inputs.forEach((input) => {
-    if (input.type === InputType8.Coin) {
+    if (input.type === InputType7.Coin) {
       this.cache?.set(input.id);
     }
   });
@@ -4680,7 +4699,7 @@ __publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
 import { ErrorCode as ErrorCode14, FuelError as FuelError14 } from "@fuel-ts/errors";
-import { bn as bn17 } from "@fuel-ts/math";
+import { bn as bn18 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder6 } from "@fuel-ts/transactions";
 import { arrayify as arrayify12 } from "@fuel-ts/utils";
 
@@ -4766,6 +4785,7 @@ var assembleTransferToContractScript = async (params) => {
 };
 
 // src/account.ts
+var MAX_FUNDING_ATTEMPTS = 2;
 var Account = class extends AbstractAccount {
   /**
    * The address associated with the account.
@@ -4923,16 +4943,17 @@ var Account = class extends AbstractAccount {
    * Adds resources to the transaction enough to fund it.
    *
    * @param request - The transaction request.
-   * @param coinQuantities - The coin quantities required to execute the transaction.
+   * @param requiredQuantities - The coin quantities required to execute the transaction.
    * @param fee - The estimated transaction fee.
    * @returns A promise that resolves when the resources are added to the transaction.
    */
   async fund(request, params) {
     const { addedSignatures, estimatedPredicates, maxFee: fee, requiredQuantities } = params;
     const baseAssetId = this.provider.getBaseAssetId();
+    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || bn19(0);
     const txRequest = request;
     const requiredQuantitiesWithFee = addAmountToCoinQuantities({
-      amount: bn18(fee),
+      amount: bn19(fee),
       assetId: baseAssetId,
       coinQuantities: requiredQuantities
     });
@@ -4940,21 +4961,17 @@ var Account = class extends AbstractAccount {
     requiredQuantitiesWithFee.forEach(({ amount, assetId }) => {
       quantitiesDict[assetId] = {
         required: amount,
-        owned: bn18(0)
+        owned: bn19(0)
       };
     });
-    txRequest.inputs.forEach((input) => {
-      const isResource = "amount" in input;
-      if (!isResource) {
-        return;
-      }
-      const isCoin2 = "owner" in input;
+    request.inputs.filter(isRequestInputResource).forEach((input) => {
+      const isCoin2 = isRequestInputCoin(input);
       const assetId = isCoin2 ? String(input.assetId) : baseAssetId;
       if (quantitiesDict[assetId]) {
         quantitiesDict[assetId].owned = quantitiesDict[assetId].owned.add(input.amount);
       }
     });
-    const missingQuantities = [];
+    let missingQuantities = [];
     Object.entries(quantitiesDict).forEach(([assetId, { owned, required }]) => {
       if (owned.lt(required)) {
         missingQuantities.push({
@@ -4963,11 +4980,42 @@ var Account = class extends AbstractAccount {
         });
       }
     });
-    const needsToBeFunded = missingQuantities.length;
-    if (needsToBeFunded) {
-      const excludedIds = cacheTxInputsFromOwner(txRequest.inputs, this.address.toB256());
-      const resources = await this.getResourcesToSpend(missingQuantities, excludedIds);
-      txRequest.addResources(resources);
+    let needsToBeFunded = missingQuantities.length > 0;
+    let fundingAttempts = 0;
+    while (needsToBeFunded && fundingAttempts < MAX_FUNDING_ATTEMPTS) {
+      const resources = await this.getResourcesToSpend(
+        missingQuantities,
+        cacheRequestInputsResourcesFromOwner(request.inputs, this.address)
+      );
+      request.addResources(resources);
+      txRequest.shiftPredicateData();
+      txRequest.updatePredicateGasUsed(estimatedPredicates);
+      const requestToReestimate2 = clone4(txRequest);
+      if (addedSignatures) {
+        Array.from({ length: addedSignatures }).forEach(
+          () => requestToReestimate2.addEmptyWitness()
+        );
+      }
+      const { maxFee: newFee } = await this.provider.estimateTxGasAndFee({
+        transactionRequest: requestToReestimate2
+      });
+      const totalBaseAssetOnInputs = getAssetAmountInRequestInputs(
+        request.inputs,
+        baseAssetId,
+        baseAssetId
+      );
+      const totalBaseAssetRequiredWithFee = requiredInBaseAsset.add(newFee);
+      if (totalBaseAssetOnInputs.gt(totalBaseAssetRequiredWithFee)) {
+        needsToBeFunded = false;
+      } else {
+        missingQuantities = [
+          {
+            amount: totalBaseAssetRequiredWithFee.sub(totalBaseAssetOnInputs),
+            assetId: baseAssetId
+          }
+        ];
+      }
+      fundingAttempts += 1;
     }
     txRequest.shiftPredicateData();
     txRequest.updatePredicateGasUsed(estimatedPredicates);
@@ -5018,7 +5066,7 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transfer(destination, amount, assetId, txParams = {}) {
-    if (bn18(amount).lte(0)) {
+    if (bn19(amount).lte(0)) {
       throw new FuelError15(
         ErrorCode15.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
@@ -5038,7 +5086,7 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transferToContract(contractId, amount, assetId, txParams = {}) {
-    if (bn18(amount).lte(0)) {
+    if (bn19(amount).lte(0)) {
       throw new FuelError15(
         ErrorCode15.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
@@ -5048,7 +5096,7 @@ var Account = class extends AbstractAccount {
     const assetIdToTransfer = assetId ?? this.provider.getBaseAssetId();
     const { script, scriptData } = await assembleTransferToContractScript({
       hexlifiedContractId: contractAddress.toB256(),
-      amountToTransfer: bn18(amount),
+      amountToTransfer: bn19(amount),
       assetId: assetIdToTransfer
     });
     const request = new ScriptTransactionRequest({
@@ -5059,7 +5107,7 @@ var Account = class extends AbstractAccount {
     request.addContractInputAndOutput(contractAddress);
     const txCost = await this.provider.getTransactionCost(request, {
       resourcesOwner: this,
-      quantitiesToContract: [{ amount: bn18(amount), assetId: String(assetIdToTransfer) }]
+      quantitiesToContract: [{ amount: bn19(amount), assetId: String(assetIdToTransfer) }]
     });
     this.validateGasLimitAndMaxFee({
       gasUsed: txCost.gasUsed,
@@ -5085,7 +5133,7 @@ var Account = class extends AbstractAccount {
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
     const amountDataArray = arrayify14(
-      "0x".concat(bn18(amount).toHex().substring(2).padStart(16, "0"))
+      "0x".concat(bn19(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
       ...arrayify14(withdrawScript.bytes),
@@ -5095,7 +5143,7 @@ var Account = class extends AbstractAccount {
     const params = { script, ...txParams };
     const baseAssetId = this.provider.getBaseAssetId();
     const request = new ScriptTransactionRequest(params);
-    const quantitiesToContract = [{ amount: bn18(amount), assetId: baseAssetId }];
+    const quantitiesToContract = [{ amount: bn19(amount), assetId: baseAssetId }];
     const txCost = await this.provider.getTransactionCost(request, { quantitiesToContract });
     this.validateGasLimitAndMaxFee({
       gasUsed: txCost.gasUsed,
@@ -5167,13 +5215,13 @@ var Account = class extends AbstractAccount {
     gasUsed,
     maxFee
   }) {
-    if (isDefined(setGasLimit) && gasUsed.gt(setGasLimit)) {
+    if (isDefined2(setGasLimit) && gasUsed.gt(setGasLimit)) {
       throw new FuelError15(
         ErrorCode15.GAS_LIMIT_TOO_LOW,
         `Gas limit '${setGasLimit}' is lower than the required: '${gasUsed}'.`
       );
     }
-    if (isDefined(setMaxFee) && maxFee.gt(setMaxFee)) {
+    if (isDefined2(setMaxFee) && maxFee.gt(setMaxFee)) {
       throw new FuelError15(
         ErrorCode15.MAX_FEE_TOO_LOW,
         `Max fee '${setMaxFee}' is lower than the required: '${maxFee}'.`
@@ -5505,7 +5553,7 @@ __publicField(BaseWalletUnlocked, "defaultPath", "m/44'/1179993420'/0'/0/0");
 // src/hdwallet/hdwallet.ts
 import { ErrorCode as ErrorCode19, FuelError as FuelError19 } from "@fuel-ts/errors";
 import { sha256 as sha2564 } from "@fuel-ts/hasher";
-import { bn as bn19, toBytes as toBytes2, toHex } from "@fuel-ts/math";
+import { bn as bn20, toBytes as toBytes2, toHex } from "@fuel-ts/math";
 import { arrayify as arrayify18, hexlify as hexlify17, concat as concat5 } from "@fuel-ts/utils";
 import { toBeHex, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58, computeHmac as computeHmac2, ripemd160 } from "ethers";
 
@@ -7971,7 +8019,7 @@ var HDWallet = class {
     const IR = bytes.slice(32);
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
-      const ki = bn19(IL).add(privateKey).mod(N).toBytes(32);
+      const ki = bn20(IL).add(privateKey).mod(N).toBytes(32);
       return new HDWallet({
         privateKey: ki,
         chainCode: IR,
@@ -8476,14 +8524,14 @@ import { UTXO_ID_LEN as UTXO_ID_LEN4 } from "@fuel-ts/abi-coder";
 import { getRandomB256 } from "@fuel-ts/address";
 import { ZeroBytes32 as ZeroBytes329 } from "@fuel-ts/address/configs";
 import { randomBytes as randomBytes7 } from "@fuel-ts/crypto";
-import { bn as bn20 } from "@fuel-ts/math";
-import { InputType as InputType9 } from "@fuel-ts/transactions";
+import { bn as bn21 } from "@fuel-ts/math";
+import { InputType as InputType8 } from "@fuel-ts/transactions";
 import { hexlify as hexlify19 } from "@fuel-ts/utils";
 var generateFakeRequestInputCoin = (partial = {}) => ({
   id: hexlify19(randomBytes7(UTXO_ID_LEN4)),
-  type: InputType9.Coin,
+  type: InputType8.Coin,
   owner: getRandomB256(),
-  amount: bn20(100),
+  amount: bn21(100),
   assetId: ZeroBytes329,
   txPointer: "0x00000000000000000000000000000000",
   witnessIndex: 0,
@@ -8491,16 +8539,16 @@ var generateFakeRequestInputCoin = (partial = {}) => ({
 });
 var generateFakeRequestInputMessage = (partial = {}) => ({
   nonce: getRandomB256(),
-  type: InputType9.Message,
+  type: InputType8.Message,
   sender: getRandomB256(),
   recipient: getRandomB256(),
-  amount: bn20(100),
+  amount: bn21(100),
   witnessIndex: 0,
   ...partial
 });
 var generateFakeRequestInputContract = (partial = {}) => ({
   contractId: getRandomB256(),
-  type: InputType9.Contract,
+  type: InputType8.Contract,
   txPointer: "0x00000000000000000000000000000000",
   ...partial
 });