@fuel-ts/account 0.0.0-pr-1699-20240214162434 → 0.0.0-pr-1784-20240221124858

package/dist/index.js

@@ -59,22 +59,17 @@ var src_exports = {};
 __export(src_exports, {
   Account: () => Account,
   AddressType: () => AddressType,
-  BACKGROUND_SCRIPT_NAME: () => BACKGROUND_SCRIPT_NAME,
   BaseTransactionRequest: () => BaseTransactionRequest,
   BaseWalletUnlocked: () => BaseWalletUnlocked,
-  CONNECTOR_SCRIPT: () => CONNECTOR_SCRIPT,
-  CONTENT_SCRIPT_NAME: () => CONTENT_SCRIPT_NAME,
+  CHAIN_IDS: () => CHAIN_IDS,
   ChainName: () => ChainName,
   ChangeOutputCollisionError: () => ChangeOutputCollisionError,
   CreateTransactionRequest: () => CreateTransactionRequest,
-  EVENT_MESSAGE: () => EVENT_MESSAGE,
   Fuel: () => Fuel,
   FuelConnector: () => FuelConnector,
   FuelConnectorEventType: () => FuelConnectorEventType,
   FuelConnectorEventTypes: () => FuelConnectorEventTypes,
   FuelConnectorMethods: () => FuelConnectorMethods,
-  FuelWalletLocked: () => FuelWalletLocked,
-  FuelWalletProvider: () => FuelWalletProvider,
   HDWallet: () => hdwallet_default,
   Language: () => Language,
   LocalStorage: () => LocalStorage,
@@ -86,7 +81,6 @@ __export(src_exports, {
   NoWitnessAtIndexError: () => NoWitnessAtIndexError,
   NoWitnessByOwnerError: () => NoWitnessByOwnerError,
   OperationName: () => OperationName,
-  POPUP_SCRIPT_NAME: () => POPUP_SCRIPT_NAME,
   Predicate: () => Predicate,
   PrivateKeyVault: () => PrivateKeyVault,
   Provider: () => Provider,
@@ -97,7 +91,6 @@ __export(src_exports, {
   TransactionStatus: () => TransactionStatus,
   TransactionType: () => import_transactions5.TransactionType,
   TransactionTypeName: () => TransactionTypeName,
-  VAULT_SCRIPT_NAME: () => VAULT_SCRIPT_NAME,
   Vault: () => Vault,
   Wallet: () => Wallet,
   WalletLocked: () => WalletLocked,
@@ -107,6 +100,7 @@ __export(src_exports, {
   addOperation: () => addOperation,
   assembleReceiptByType: () => assembleReceiptByType,
   assembleTransactionSummary: () => assembleTransactionSummary,
+  assets: () => assets,
   buildBlockExplorerUrl: () => buildBlockExplorerUrl,
   cacheFor: () => cacheFor,
   calculateMetadataGasForTxCreate: () => calculateMetadataGasForTxCreate,
@@ -124,11 +118,15 @@ __export(src_exports, {
   fromTai64ToUnix: () => fromTai64ToUnix,
   fromUnixToTai64: () => fromUnixToTai64,
   gasUsedByInputs: () => gasUsedByInputs,
-  getAssetByChain: () => getAssetByChain,
+  getAssetEth: () => getAssetEth,
+  getAssetFuel: () => getAssetFuel,
+  getAssetNetwork: () => getAssetNetwork,
+  getAssetWithNetwork: () => getAssetWithNetwork,
   getContractCallOperations: () => getContractCallOperations,
   getContractCreatedOperations: () => getContractCreatedOperations,
   getContractTransferOperations: () => getContractTransferOperations,
   getDecodedLogs: () => getDecodedLogs,
+  getDefaultChainId: () => getDefaultChainId,
   getGasUsedFromReceipts: () => getGasUsedFromReceipts,
   getInputAccountAddress: () => getInputAccountAddress,
   getInputContractFromIndex: () => getInputContractFromIndex,
@@ -177,9 +175,11 @@ __export(src_exports, {
   processGqlReceipt: () => processGqlReceipt,
   processGraphqlStatus: () => processGraphqlStatus,
   resolveGasDependentCosts: () => resolveGasDependentCosts,
+  resolveIconPaths: () => resolveIconPaths,
   returnZeroScript: () => returnZeroScript,
   sleep: () => sleep,
   transactionRequestify: () => transactionRequestify,
+  urlJoin: () => urlJoin,
   withTimeout: () => withTimeout,
   withdrawScript: () => withdrawScript
 });
@@ -234,7 +234,9 @@ var import_address3 = require("@fuel-ts/address");
 var import_errors13 = require("@fuel-ts/errors");
 var import_math14 = require("@fuel-ts/math");
 var import_transactions17 = require("@fuel-ts/transactions");
+var import_utils5 = require("@fuel-ts/utils");
 var import_versions = require("@fuel-ts/versions");
+var import_utils6 = require("@noble/curves/abstract/utils");
 var import_ethers18 = require("ethers");
 var import_graphql_request = require("graphql-request");
 var import_ramda3 = require("ramda");
@@ -2140,7 +2142,7 @@ var BaseTransactionRequest = class {
    *
    * @param quantities - CoinQuantity Array.
    */
-  fundWithFakeUtxos(quantities) {
+  fundWithFakeUtxos(quantities, resourcesOwner) {
     let idCounter = 0;
     const generateId = () => {
       const counterString = String(idCounter++);
@@ -2164,7 +2166,7 @@ var BaseTransactionRequest = class {
             id: generateId(),
             amount: quantity,
             assetId,
-            owner: import_address.Address.fromRandom(),
+            owner: resourcesOwner || import_address.Address.fromRandom(),
             maturity: 0,
             blockCreated: (0, import_math6.bn)(1),
             txCreatedIdx: (0, import_math6.bn)(1)
@@ -2197,19 +2199,29 @@ var BaseTransactionRequest = class {
   toJSON() {
     return normalizeJSON(this);
   }
-  /**
-   * @hidden
-   *
-   * Determines whether the transaction has a predicate input.
-   *
-   * @returns Whether the transaction has a predicate input.
-   */
-  hasPredicateInput() {
-    return Boolean(
-      this.inputs.find(
-        (input) => "predicate" in input && input.predicate && input.predicate !== (0, import_ethers9.getBytesCopy)("0x")
-      )
-    );
+  updatePredicateInputs(inputs) {
+    this.inputs.forEach((i) => {
+      let correspondingInput;
+      switch (i.type) {
+        case import_transactions5.InputType.Contract:
+          return;
+        case import_transactions5.InputType.Coin:
+          correspondingInput = inputs.find((x) => x.type === import_transactions5.InputType.Coin && x.owner === i.owner);
+          break;
+        case import_transactions5.InputType.Message:
+          correspondingInput = inputs.find(
+            (x) => x.type === import_transactions5.InputType.Message && x.sender === i.sender
+          );
+          break;
+        default:
+          break;
+      }
+      if (correspondingInput && "predicateGasUsed" in correspondingInput && (0, import_math6.bn)(correspondingInput.predicateGasUsed).gt(0)) {
+        i.predicate = correspondingInput.predicate;
+        i.predicateData = correspondingInput.predicateData;
+        i.predicateGasUsed = correspondingInput.predicateGasUsed;
+      }
+    });
   }
 };
 
@@ -3932,7 +3944,7 @@ var _Provider = class {
   async call(transactionRequestLike, { utxoValidation, estimateTxDependencies = true } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
     if (estimateTxDependencies) {
-      await this.estimateTxDependencies(transactionRequest);
+      return this.estimateTxDependencies(transactionRequest);
     }
     const encodedTransaction = (0, import_ethers18.hexlify)(transactionRequest.toTransactionBytes());
     const { dryRun: gqlReceipts } = await this.operations.dryRun({
@@ -3951,6 +3963,14 @@ var _Provider = class {
    * @returns A promise that resolves to the estimated transaction request object.
    */
   async estimatePredicates(transactionRequest) {
+    const shouldEstimatePredicates = Boolean(
+      transactionRequest.inputs.find(
+        (input) => "predicate" in input && input.predicate && !(0, import_utils6.equalBytes)((0, import_utils5.arrayify)(input.predicate), (0, import_utils5.arrayify)("0x")) && new import_math14.BN(input.predicateGasUsed).isZero()
+      )
+    );
+    if (!shouldEstimatePredicates) {
+      return transactionRequest;
+    }
     const encodedTransaction = (0, import_ethers18.hexlify)(transactionRequest.toTransactionBytes());
     const response = await this.operations.estimatePredicates({
       encodedTransaction
@@ -3981,34 +4001,33 @@ var _Provider = class {
    * @returns A promise.
    */
   async estimateTxDependencies(transactionRequest) {
-    let missingOutputVariableCount = 0;
-    let missingOutputContractIdsCount = 0;
-    let tries = 0;
     if (transactionRequest.type === import_transactions17.TransactionType.Create) {
-      return;
-    }
-    let txRequest = transactionRequest;
-    if (txRequest.hasPredicateInput()) {
-      txRequest = await this.estimatePredicates(txRequest);
+      return {
+        receipts: []
+      };
     }
-    while (tries < MAX_RETRIES) {
+    await this.estimatePredicates(transactionRequest);
+    let receipts = [];
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
       const { dryRun: gqlReceipts } = await this.operations.dryRun({
-        encodedTransaction: (0, import_ethers18.hexlify)(txRequest.toTransactionBytes()),
+        encodedTransaction: (0, import_ethers18.hexlify)(transactionRequest.toTransactionBytes()),
         utxoValidation: false
       });
-      const receipts = gqlReceipts.map(processGqlReceipt);
+      receipts = gqlReceipts.map(processGqlReceipt);
       const { missingOutputVariables, missingOutputContractIds } = getReceiptsWithMissingData(receipts);
-      missingOutputVariableCount = missingOutputVariables.length;
-      missingOutputContractIdsCount = missingOutputContractIds.length;
-      if (missingOutputVariableCount === 0 && missingOutputContractIdsCount === 0) {
-        return;
+      const hasMissingOutputs = missingOutputVariables.length !== 0 || missingOutputContractIds.length !== 0;
+      if (hasMissingOutputs) {
+        transactionRequest.addVariableOutputs(missingOutputVariables.length);
+        missingOutputContractIds.forEach(({ contractId }) => {
+          transactionRequest.addContractInputAndOutput(import_address3.Address.fromString(contractId));
+        });
+      } else {
+        break;
       }
-      txRequest.addVariableOutputs(missingOutputVariableCount);
-      missingOutputContractIds.forEach(
-        ({ contractId }) => txRequest.addContractInputAndOutput(import_address3.Address.fromString(contractId))
-      );
-      tries += 1;
     }
+    return {
+      receipts
+    };
   }
   /**
    * Executes a signed transaction without applying the states changes
@@ -4023,7 +4042,7 @@ var _Provider = class {
   async simulate(transactionRequestLike, { estimateTxDependencies = true } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
     if (estimateTxDependencies) {
-      await this.estimateTxDependencies(transactionRequest);
+      return this.estimateTxDependencies(transactionRequest);
     }
     const encodedTransaction = (0, import_ethers18.hexlify)(transactionRequest.toTransactionBytes());
     const { dryRun: gqlReceipts } = await this.operations.dryRun({
@@ -4050,36 +4069,38 @@ var _Provider = class {
    * @param tolerance - The tolerance to add on top of the gasUsed.
    * @returns A promise that resolves to the transaction cost object.
    */
-  async getTransactionCost(transactionRequestLike, forwardingQuantities = [], { estimateTxDependencies = true, estimatePredicates = true } = {}) {
-    const transactionRequest = transactionRequestify((0, import_ramda3.clone)(transactionRequestLike));
+  async getTransactionCost(transactionRequestLike, forwardingQuantities = [], {
+    estimateTxDependencies = true,
+    estimatePredicates = true,
+    resourcesOwner
+  } = {}) {
+    const txRequestClone = (0, import_ramda3.clone)(transactionRequestify(transactionRequestLike));
     const chainInfo = this.getChain();
     const { gasPriceFactor, minGasPrice, maxGasPerTx } = this.getGasConfig();
-    const gasPrice = (0, import_math14.max)(transactionRequest.gasPrice, minGasPrice);
-    const isScriptTransaction = transactionRequest.type === import_transactions17.TransactionType.Script;
-    if (transactionRequest.hasPredicateInput() && estimatePredicates) {
+    const gasPrice = (0, import_math14.max)(txRequestClone.gasPrice, minGasPrice);
+    const isScriptTransaction = txRequestClone.type === import_transactions17.TransactionType.Script;
+    const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
+    const allQuantities = mergeQuantities(coinOutputsQuantities, forwardingQuantities);
+    txRequestClone.fundWithFakeUtxos(allQuantities, resourcesOwner?.address);
+    if (estimatePredicates) {
       if (isScriptTransaction) {
-        transactionRequest.gasLimit = (0, import_math14.bn)(0);
+        txRequestClone.gasLimit = (0, import_math14.bn)(0);
       }
-      await this.estimatePredicates(transactionRequest);
+      if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
+        resourcesOwner.populateTransactionPredicateData(txRequestClone);
+      }
+      await this.estimatePredicates(txRequestClone);
     }
-    const minGas = transactionRequest.calculateMinGas(chainInfo);
-    const maxGas = transactionRequest.calculateMaxGas(chainInfo, minGas);
-    const coinOutputsQuantities = transactionRequest.getCoinOutputsQuantities();
-    const allQuantities = mergeQuantities(coinOutputsQuantities, forwardingQuantities);
-    transactionRequest.fundWithFakeUtxos(allQuantities);
-    let gasUsed = minGas;
+    const minGas = txRequestClone.calculateMinGas(chainInfo);
+    const maxGas = txRequestClone.calculateMaxGas(chainInfo, minGas);
     let receipts = [];
-    if (isScriptTransaction) {
-      transactionRequest.gasPrice = (0, import_math14.bn)(0);
-      transactionRequest.gasLimit = (0, import_math14.bn)(maxGasPerTx.sub(maxGas).toNumber() * 0.9);
-      const result = await this.call(transactionRequest, {
-        estimateTxDependencies
-      });
+    if (isScriptTransaction && estimateTxDependencies) {
+      txRequestClone.gasPrice = (0, import_math14.bn)(0);
+      txRequestClone.gasLimit = (0, import_math14.bn)(maxGasPerTx.sub(maxGas).toNumber() * 0.9);
+      const result = await this.estimateTxDependencies(txRequestClone);
       receipts = result.receipts;
-      gasUsed = getGasUsedFromReceipts(receipts);
-    } else {
-      gasUsed = minGas;
     }
+    const gasUsed = isScriptTransaction ? getGasUsedFromReceipts(receipts) : minGas;
     const usedFee = calculatePriceWithFactor(
       gasUsed,
       gasPrice,
@@ -4097,7 +4118,9 @@ var _Provider = class {
       maxGas,
       usedFee,
       minFee,
-      maxFee
+      maxFee,
+      estimatedInputs: txRequestClone.inputs,
+      estimatedOutputs: txRequestClone.outputs
     };
   }
   async getResourcesForTransaction(owner, transactionRequestLike, forwardingQuantities = []) {
@@ -4487,6 +4510,10 @@ var _Provider = class {
     });
     return (0, import_math14.bn)(latestBlockHeight);
   }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getTransactionResponse(transactionId) {
+    return new TransactionResponse(transactionId, this);
+  }
 };
 var Provider = _Provider;
 _cacheInputs = new WeakSet();
@@ -4599,6 +4626,127 @@ async function getTransactionsSummaries(params) {
   };
 }
 
+// src/providers/chains.ts
+var CHAIN_IDS = {
+  eth: {
+    sepolia: 11155111,
+    foundry: 31337
+  },
+  fuel: {
+    beta5: 0,
+    devnet: 10
+  }
+};
+
+// src/providers/assets/utils/network.ts
+var getDefaultChainId = (networkType) => {
+  if (networkType === "ethereum") {
+    return CHAIN_IDS.eth.sepolia;
+  }
+  if (networkType === "fuel") {
+    return CHAIN_IDS.fuel.beta5;
+  }
+  return void 0;
+};
+var getAssetNetwork = ({
+  asset,
+  chainId,
+  networkType
+}) => {
+  const network = asset.networks.find(
+    (item) => item.chainId === chainId && item.type === networkType
+  );
+  return network;
+};
+var getAssetWithNetwork = ({
+  asset,
+  chainId,
+  networkType
+}) => {
+  const { networks: _, ...assetRest } = asset;
+  const chainIdToUse = chainId ?? getDefaultChainId(networkType);
+  if (chainIdToUse === void 0) {
+    return void 0;
+  }
+  const assetNetwork = getAssetNetwork({
+    asset,
+    chainId: chainIdToUse,
+    networkType
+  });
+  if (!assetNetwork) {
+    return void 0;
+  }
+  return {
+    ...assetRest,
+    ...assetNetwork
+  };
+};
+var getAssetEth = (asset, chainId) => getAssetWithNetwork({
+  asset,
+  networkType: "ethereum",
+  chainId
+});
+var getAssetFuel = (asset, chainId) => getAssetWithNetwork({
+  asset,
+  networkType: "fuel",
+  chainId
+});
+
+// src/providers/assets/utils/url.ts
+var DELIMITER_PATH = "/";
+var trimRegex = /^\/|\/$/g;
+var trimPath = (path = "") => path.replace(trimRegex, "");
+function urlJoin(baseUrl, ...paths) {
+  const hasBaseUrl = baseUrl !== null && baseUrl !== void 0;
+  const rootPath = baseUrl?.[0] === "/" && baseUrl.length > 1;
+  const allPaths = [baseUrl, ...paths].filter(Boolean).map(trimPath);
+  if (rootPath && hasBaseUrl) {
+    allPaths.unshift("");
+  }
+  return allPaths.join(DELIMITER_PATH);
+}
+
+// src/providers/assets/utils/resolveIconPaths.ts
+function resolveIconPaths(assets2, basePath = "./") {
+  return assets2.map((asset) => ({
+    ...asset,
+    icon: urlJoin(basePath, asset.icon)
+  }));
+}
+
+// src/providers/assets/index.ts
+var assets = [
+  {
+    name: "Ethereum",
+    symbol: "ETH",
+    icon: "eth.svg",
+    networks: [
+      {
+        type: "ethereum",
+        chainId: CHAIN_IDS.eth.sepolia,
+        decimals: 18
+      },
+      {
+        type: "ethereum",
+        chainId: CHAIN_IDS.eth.foundry,
+        decimals: 18
+      },
+      {
+        type: "fuel",
+        chainId: CHAIN_IDS.fuel.beta5,
+        decimals: 9,
+        assetId: "0x0000000000000000000000000000000000000000000000000000000000000000"
+      },
+      {
+        type: "fuel",
+        chainId: CHAIN_IDS.fuel.devnet,
+        decimals: 9,
+        assetId: "0x0000000000000000000000000000000000000000000000000000000000000000"
+      }
+    ]
+  }
+];
+
 // src/utils/formatTransferToContractScriptData.ts
 var import_abi_coder4 = require("@fuel-ts/abi-coder");
 var import_math16 = require("@fuel-ts/math");
@@ -4645,15 +4793,17 @@ var Account = class extends import_interfaces.AbstractAccount {
    * The provider used to interact with the network.
    */
   _provider;
+  _connector;
   /**
    * Creates a new Account instance.
    *
    * @param address - The address of the account.
    * @param provider - A Provider instance  (optional).
    */
-  constructor(address, provider) {
+  constructor(address, provider, connector) {
     super();
     this._provider = provider;
+    this._connector = connector;
     this.address = import_address4.Address.fromDynamicInput(address);
   }
   /**
@@ -4859,7 +5009,10 @@ var Account = class extends import_interfaces.AbstractAccount {
     const params = { gasPrice: minGasPrice, ...txParams };
     const request = new ScriptTransactionRequest(params);
     request.addCoinOutput(import_address4.Address.fromAddressOrString(destination), amount, assetId);
-    const { maxFee, requiredQuantities, gasUsed } = await this.provider.getTransactionCost(request);
+    const { maxFee, requiredQuantities, gasUsed, estimatedInputs } = await this.provider.getTransactionCost(request, [], {
+      estimateTxDependencies: true,
+      resourcesOwner: this
+    });
     request.gasPrice = (0, import_math17.bn)(txParams.gasPrice ?? minGasPrice);
     request.gasLimit = (0, import_math17.bn)(txParams.gasLimit ?? gasUsed);
     this.validateGas({
@@ -4869,6 +5022,7 @@ var Account = class extends import_interfaces.AbstractAccount {
       minGasPrice
     });
     await this.fund(request, requiredQuantities, maxFee);
+    request.updatePredicateInputs(estimatedInputs);
     return request;
   }
   /**
@@ -4882,7 +5036,7 @@ var Account = class extends import_interfaces.AbstractAccount {
    */
   async transfer(destination, amount, assetId = import_configs10.BaseAssetId, txParams = {}) {
     const request = await this.createTransfer(destination, amount, assetId, txParams);
-    return this.sendTransaction(request);
+    return this.sendTransaction(request, { estimateTxDependencies: false });
   }
   /**
    * Transfers coins to a contract address.
@@ -4961,17 +5115,30 @@ var Account = class extends import_interfaces.AbstractAccount {
     await this.fund(request, requiredQuantities, maxFee);
     return this.sendTransaction(request);
   }
+  async signMessage(message) {
+    if (!this._connector) {
+      throw new import_errors15.FuelError(import_errors15.ErrorCode.MISSING_CONNECTOR, "A connector is required to sign messages.");
+    }
+    return this._connector.signMessage(this.address.toString(), message);
+  }
   /**
    * Sends a transaction to the network.
    *
    * @param transactionRequestLike - The transaction request to be sent.
    * @returns A promise that resolves to the transaction response.
    */
-  async sendTransaction(transactionRequestLike, options) {
+  async sendTransaction(transactionRequestLike, { estimateTxDependencies = true, awaitExecution } = {}) {
+    if (this._connector) {
+      return this.provider.getTransactionResponse(
+        await this._connector.sendTransaction(this.address.toString(), transactionRequestLike)
+      );
+    }
     const transactionRequest = transactionRequestify(transactionRequestLike);
-    await this.provider.estimateTxDependencies(transactionRequest);
+    if (estimateTxDependencies) {
+      await this.provider.estimateTxDependencies(transactionRequest);
+    }
     return this.provider.sendTransaction(transactionRequest, {
-      ...options,
+      awaitExecution,
       estimateTxDependencies: false
     });
   }
@@ -4981,9 +5148,11 @@ var Account = class extends import_interfaces.AbstractAccount {
    * @param transactionRequestLike - The transaction request to be simulated.
    * @returns A promise that resolves to the call result.
    */
-  async simulateTransaction(transactionRequestLike) {
+  async simulateTransaction(transactionRequestLike, { estimateTxDependencies = true } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
-    await this.provider.estimateTxDependencies(transactionRequest);
+    if (estimateTxDependencies) {
+      await this.provider.estimateTxDependencies(transactionRequest);
+    }
     return this.provider.simulate(transactionRequest, { estimateTxDependencies: false });
   }
   validateGas({
@@ -5284,12 +5453,14 @@ var BaseWalletUnlocked = class extends Account {
    * @param transactionRequestLike - The transaction request to send.
    * @returns A promise that resolves to the TransactionResponse object.
    */
-  async sendTransaction(transactionRequestLike, options) {
+  async sendTransaction(transactionRequestLike, { estimateTxDependencies = true, awaitExecution } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
-    await this.provider.estimateTxDependencies(transactionRequest);
+    if (estimateTxDependencies) {
+      await this.provider.estimateTxDependencies(transactionRequest);
+    }
     return this.provider.sendTransaction(
       await this.populateTransactionWitnessesSignature(transactionRequest),
-      { ...options, estimateTxDependencies: false }
+      { awaitExecution, estimateTxDependencies: false }
     );
   }
   /**
@@ -5298,9 +5469,11 @@ var BaseWalletUnlocked = class extends Account {
    * @param transactionRequestLike - The transaction request to simulate.
    * @returns A promise that resolves to the CallResult object.
    */
-  async simulateTransaction(transactionRequestLike) {
+  async simulateTransaction(transactionRequestLike, { estimateTxDependencies = true } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
-    await this.provider.estimateTxDependencies(transactionRequest);
+    if (estimateTxDependencies) {
+      await this.provider.estimateTxDependencies(transactionRequest);
+    }
     return this.provider.call(
       await this.populateTransactionWitnessesSignature(transactionRequest),
       {
@@ -8479,12 +8652,12 @@ var import_ethers28 = require("ethers");
 // src/predicate/utils/getPredicateRoot.ts
 var import_hasher4 = require("@fuel-ts/hasher");
 var import_merkle = require("@fuel-ts/merkle");
-var import_utils7 = require("@fuel-ts/utils");
+var import_utils9 = require("@fuel-ts/utils");
 var import_ethers27 = require("ethers");
 var getPredicateRoot = (bytecode) => {
   const chunkSize = 16 * 1024;
   const bytes = (0, import_ethers27.getBytesCopy)(bytecode);
-  const chunks = (0, import_utils7.chunkAndPadBytes)(bytes, chunkSize);
+  const chunks = (0, import_utils9.chunkAndPadBytes)(bytes, chunkSize);
   const codeRoot = (0, import_merkle.calcRoot)(chunks.map((c) => (0, import_ethers27.hexlify)(c)));
   const predicateRoot = (0, import_hasher4.hash)((0, import_ethers27.concat)(["0x4655454C", codeRoot]));
   return predicateRoot;
@@ -8656,6 +8829,9 @@ var Predicate = class extends Account {
   }
 };
 
+// src/connectors/fuel.ts
+var import_errors25 = require("@fuel-ts/errors");
+
 // src/connectors/fuel-connector.ts
 var import_events2 = require("events");
 
@@ -8696,14 +8872,6 @@ var FuelConnectorEventTypes = /* @__PURE__ */ ((FuelConnectorEventTypes2) => {
 })(FuelConnectorEventTypes || {});
 var FuelConnectorEventType = "FuelConnector";
 
-// src/connectors/types/constants.ts
-var CONNECTOR_SCRIPT = "FuelConnectorScript";
-var CONTENT_SCRIPT_NAME = "FuelContentScript";
-var BACKGROUND_SCRIPT_NAME = "FuelBackgroundScript";
-var POPUP_SCRIPT_NAME = "FuelPopUpScript";
-var VAULT_SCRIPT_NAME = "FuelVaultScript";
-var EVENT_MESSAGE = "message";
-
 // src/connectors/types/data-type.ts
 var MessageTypes = /* @__PURE__ */ ((MessageTypes2) => {
   MessageTypes2["ping"] = "ping";
@@ -8953,40 +9121,6 @@ var FuelConnector = class extends import_events2.EventEmitter {
   }
 };
 
-// src/connectors/fuel-wallet-locked.ts
-var FuelWalletLocked = class extends WalletLocked {
-  connector;
-  _provider;
-  constructor(address, connector, provider) {
-    super(address, provider);
-    this.connector = connector;
-    this._provider = provider;
-  }
-  async signMessage(message) {
-    return this.connector.signMessage(this.address.toString(), message);
-  }
-  async sendTransaction(transaction) {
-    const transactionId = await this.connector.sendTransaction(
-      this.address.toString(),
-      transaction
-    );
-    return this.provider.getTransactionResponse(transactionId);
-  }
-};
-
-// src/connectors/fuel-wallet-provider.ts
-var FuelWalletProvider = class extends Provider {
-  static async create(url, options) {
-    const provider = new FuelWalletProvider(url, options);
-    await provider.fetchChainAndNodeInfo();
-    return provider;
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async getTransactionResponse(transactionId) {
-    return new TransactionResponse(transactionId, this);
-  }
-};
-
 // src/connectors/utils/cache.ts
 function cacheFor(fn, { cache: cache2, cacheTime, key }) {
   return async (...args) => {
@@ -9016,23 +9150,6 @@ function dispatchFuelConnectorEvent(connector) {
   );
 }
 
-// src/connectors/utils/get-asset-by-chain.ts
-function getAssetByChain(asset, chainId, network = "fuel") {
-  const assetFuelNetwork = asset.networks.find(
-    (item) => item.chainId === chainId && item.type === network
-  );
-  if (!assetFuelNetwork) {
-    throw new Error("Asset not found for the given chain and network.");
-  }
-  return {
-    ...asset,
-    assetId: assetFuelNetwork.assetId,
-    decimals: assetFuelNetwork.decimals,
-    chainId: assetFuelNetwork.chainId,
-    network: assetFuelNetwork.type
-  };
-}
-
 // src/connectors/utils/promises.ts
 function deferPromise() {
   const defer = {};
@@ -9054,6 +9171,7 @@ async function withTimeout(promise, timeout = 1050) {
 // src/connectors/fuel.ts
 var HAS_CONNECTOR_TIMEOUT = 2e3;
 var PING_CACHE_TIME = 5e3;
+var { warn } = console;
 var _Fuel = class extends FuelConnector {
   _storage = null;
   _connectors = [];
@@ -9322,14 +9440,12 @@ var _Fuel = class extends FuelConnector {
    * Return a Fuel Provider instance with extends features to work with
    * connectors.
    *
-   * @deprecated Provider is going to be deprecated in the future.
+   * @deprecated getProvider is deprecated and is going to be removed in the future, use getWallet instead.
    */
   async getProvider(providerOrNetwork) {
-    if (process.env.NODE_ENV !== "production") {
-      console.warn(
-        "Get provider is deprecated, use getWallet instead. Provider is going to be removed in the future."
-      );
-    }
+    warn(
+      "getProvider is deprecated and is going to be removed in the future, use getWallet instead."
+    );
     return this._getProvider(providerOrNetwork);
   }
   /**
@@ -9341,12 +9457,12 @@ var _Fuel = class extends FuelConnector {
     if (providerOrNetwork && "getTransactionResponse" in providerOrNetwork) {
       provider = providerOrNetwork;
     } else if (providerOrNetwork && "chainId" in providerOrNetwork && "url" in providerOrNetwork) {
-      provider = await FuelWalletProvider.create(providerOrNetwork.url);
+      provider = await Provider.create(providerOrNetwork.url);
     } else if (!providerOrNetwork) {
       const currentNetwork = await this.currentNetwork();
-      provider = await FuelWalletProvider.create(currentNetwork.url);
+      provider = await Provider.create(currentNetwork.url);
     } else {
-      throw new Error("Provider is not valid.");
+      throw new import_errors25.FuelError(import_errors25.ErrorCode.INVALID_PROVIDER, "Provider is not valid.");
     }
     return provider;
   }
@@ -9356,7 +9472,7 @@ var _Fuel = class extends FuelConnector {
    */
   async getWallet(address, providerOrNetwork) {
     const provider = await this._getProvider(providerOrNetwork);
-    return new FuelWalletLocked(address, this, provider);
+    return new Account(address, provider, this);
   }
   /**
    * Remove all open listeners this is useful when you want to
@@ -9388,22 +9504,17 @@ __publicField(Fuel, "defaultConfig", {});
 0 && (module.exports = {
   Account,
   AddressType,
-  BACKGROUND_SCRIPT_NAME,
   BaseTransactionRequest,
   BaseWalletUnlocked,
-  CONNECTOR_SCRIPT,
-  CONTENT_SCRIPT_NAME,
+  CHAIN_IDS,
   ChainName,
   ChangeOutputCollisionError,
   CreateTransactionRequest,
-  EVENT_MESSAGE,
   Fuel,
   FuelConnector,
   FuelConnectorEventType,
   FuelConnectorEventTypes,
   FuelConnectorMethods,
-  FuelWalletLocked,
-  FuelWalletProvider,
   HDWallet,
   Language,
   LocalStorage,
@@ -9415,7 +9526,6 @@ __publicField(Fuel, "defaultConfig", {});
   NoWitnessAtIndexError,
   NoWitnessByOwnerError,
   OperationName,
-  POPUP_SCRIPT_NAME,
   Predicate,
   PrivateKeyVault,
   Provider,
@@ -9426,7 +9536,6 @@ __publicField(Fuel, "defaultConfig", {});
   TransactionStatus,
   TransactionType,
   TransactionTypeName,
-  VAULT_SCRIPT_NAME,
   Vault,
   Wallet,
   WalletLocked,
@@ -9436,6 +9545,7 @@ __publicField(Fuel, "defaultConfig", {});
   addOperation,
   assembleReceiptByType,
   assembleTransactionSummary,
+  assets,
   buildBlockExplorerUrl,
   cacheFor,
   calculateMetadataGasForTxCreate,
@@ -9453,11 +9563,15 @@ __publicField(Fuel, "defaultConfig", {});
   fromTai64ToUnix,
   fromUnixToTai64,
   gasUsedByInputs,
-  getAssetByChain,
+  getAssetEth,
+  getAssetFuel,
+  getAssetNetwork,
+  getAssetWithNetwork,
   getContractCallOperations,
   getContractCreatedOperations,
   getContractTransferOperations,
   getDecodedLogs,
+  getDefaultChainId,
   getGasUsedFromReceipts,
   getInputAccountAddress,
   getInputContractFromIndex,
@@ -9506,9 +9620,11 @@ __publicField(Fuel, "defaultConfig", {});
   processGqlReceipt,
   processGraphqlStatus,
   resolveGasDependentCosts,
+  resolveIconPaths,
   returnZeroScript,
   sleep,
   transactionRequestify,
+  urlJoin,
   withTimeout,
   withdrawScript
 });