feat!: add a non-blocking call for deploy contract

.changeset/giant-ads-dream.md

@@ -0,0 +1,5 @@
+---
+"@fuel-ts/contract": patch
+---
+
+feat: add a non-blocking call for deploy contract

apps/docs-snippets/src/guide/contracts/deploying-contracts.test.ts

@@ -53,4 +53,29 @@ describe(__filename, () => {
     expect(value).toBe(15);
     // #endregion contract-setup-4
   });
+
+  it('should successfully deploy a contract async and execute contract function', async () => {
+    const provider = await Provider.create(FUEL_NETWORK_URL);
+
+    const wallet = Wallet.fromPrivateKey(PRIVATE_KEY, provider);
+
+    const byteCodePath = join(projectsPath, `${contractName}/out/release/${contractName}.bin`);
+    const byteCode = readFileSync(byteCodePath);
+
+    const abiJsonPath = join(projectsPath, `${contractName}/out/release/${contractName}-abi.json`);
+    const abi = JSON.parse(readFileSync(abiJsonPath, 'utf8'));
+
+    // #region contract-async-1
+    const factory = new ContractFactory(byteCode, abi, wallet);
+
+    const { contract, transactionResponse } = await factory.deployContractAsync();
+
+    const deployResult = await transactionResponse.waitForResult();
+    // #endregion contract-async-1
+
+    const { value } = await contract.functions.echo_u8(15).simulate();
+
+    expect(deployResult).toBeDefined();
+    expect(value).toBe(15);
+  });
 });

apps/docs/src/guide/contracts/deploying-contracts.md

@@ -27,11 +27,23 @@ Load the contract bytecode and JSON ABI, generated from the Sway source, into th
 
 ## 4. Deploying the Contract
 
-Initialize a [`ContractFactory`](../../api/Contract/ContractFactory.md) with the bytecode, ABI, and wallet. Deploy the contract and use its methods.
+To deploy the contract we can instantiate the [`ContractFactory`](../../api/Contract/ContractFactory.md) with the bytecode, ABI, and wallet. The we can call `deployContract` method. This method returns a promise that will resolve to a `Contract` instance, ready to be used to interact with the deployed smart contract.
 
 <<< @/../../docs-snippets/src/guide/contracts/deploying-contracts.test.ts#contract-setup-3{ts:line-numbers}
 
-## 5. Executing a Contract Call
+The `deployContract` method will only resolve after the deploy contract transaction has been processed and the smart contract is deployed on the blockchain. As a result, this call can take several seconds to resolve and will block any code execution that follows.
+
+If this situation is inappropriate for your dApp, you can use the `deployContractAsync` method.
+
+## 5. Deploying the Contract Asynchronously
+
+In some cases, you may not want to wait for the deploy contract transaction to finish processing. In these instances, you can use `deployContractAsync`. This method resolves as soon as the transaction to deploy the contract is submitted and returns two objects: a `TransactionResponse` and a `Contract` instance.
+
+<<< @/../../docs-snippets/src/guide/contracts/deploying-contracts.test.ts#contract-async-1{ts:line-numbers}
+
+It's important to note that the `contract` instance can only be safely used after the promise from the call to `transactionResponse.waitForResult` is resolved. To avoid blocking the rest of your code, you can attach this promise to a hook or listener that will use the contract only after it is fully deployed.
+
+## 6. Executing a Contract Call
 
 Now that the contract is deployed, you can interact with it. In the following steps, you'll learn how to execute contract calls.
 

packages/contract/src/contract-factory.ts

@@ -132,39 +132,35 @@ export default class ContractFactory {
    * @returns A promise that resolves to the deployed contract instance.
    */
   async deployContract(deployContractOptions: DeployContractOptions = {}) {
-    if (!this.account) {
-      throw new FuelError(ErrorCode.ACCOUNT_REQUIRED, 'Cannot deploy Contract without account.');
-    }
-
-    const { configurableConstants } = deployContractOptions;
-
-    if (configurableConstants) {
-      this.setConfigurableConstants(configurableConstants);
-    }
+    const { contractId, transactionRequest } = await this.prepareDeploy(deployContractOptions);
+    const account = this.getAccount();
 
-    const { contractId, transactionRequest } = this.createTransactionRequest(deployContractOptions);
-
-    const txCost = await this.account.provider.getTransactionCost(transactionRequest);
+    await account.sendTransaction(transactionRequest, {
+      awaitExecution: true,
+    });
 
-    const { maxFee: setMaxFee } = deployContractOptions;
+    return new Contract(contractId, this.interface, account);
+  }
 
-    if (isDefined(setMaxFee)) {
-      if (txCost.maxFee.gt(setMaxFee)) {
-        throw new FuelError(
-          ErrorCode.MAX_FEE_TOO_LOW,
-          `Max fee '${deployContractOptions.maxFee}' is lower than the required: '${txCost.maxFee}'.`
-        );
-      }
-    } else {
-      transactionRequest.maxFee = txCost.maxFee;
-    }
+  /**
+   * Deploys a contract asynchronously.
+   *
+   * @param deployContractOptions - The options for deploying the contract (optional).
+   * @returns An object containing the deployed contract and the transaction response.
+   */
+  async deployContractAsync(deployContractOptions: DeployContractOptions = {}) {
+    const { contractId, transactionRequest } = await this.prepareDeploy(deployContractOptions);
+    const account = this.getAccount();
 
-    await this.account.fund(transactionRequest, txCost);
-    await this.account.sendTransaction(transactionRequest, {
-      awaitExecution: true,
+    const transactionResponse = await account.sendTransaction(transactionRequest, {
+      awaitExecution: false,
     });
 
-    return new Contract(contractId, this.interface, this.account);
+    const contract = new Contract(contractId, this.interface, account);
+    return {
+      contract,
+      transactionResponse,
+    };
   }
 
   /**
@@ -202,4 +198,45 @@ export default class ContractFactory {
       );
     }
   }
+
+  private getAccount(): Account {
+    if (!this.account) {
+      throw new FuelError(ErrorCode.ACCOUNT_REQUIRED, 'Cannot deploy Contract without account.');
+    }
+    return this.account;
+  }
+
+  private async prepareDeploy(deployContractOptions: DeployContractOptions) {
+    const { configurableConstants } = deployContractOptions;
+
+    if (configurableConstants) {
+      this.setConfigurableConstants(configurableConstants);
+    }
+
+    const { contractId, transactionRequest } = this.createTransactionRequest(deployContractOptions);
+
+    const account = this.getAccount();
+
+    const txCost = await account.provider.getTransactionCost(transactionRequest);
+
+    const { maxFee: setMaxFee } = deployContractOptions;
+
+    if (isDefined(setMaxFee)) {
+      if (txCost.maxFee.gt(setMaxFee)) {
+        throw new FuelError(
+          ErrorCode.MAX_FEE_TOO_LOW,
+          `Max fee '${deployContractOptions.maxFee}' is lower than the required: '${txCost.maxFee}'.`
+        );
+      }
+    } else {
+      transactionRequest.maxFee = txCost.maxFee;
+    }
+
+    await account.fund(transactionRequest, txCost);
+
+    return {
+      contractId,
+      transactionRequest,
+    };
+  }
 }

packages/fuel-gauge/src/contract-factory.test.ts

@@ -91,6 +91,23 @@ describe('Contract Factory', () => {
     });
   });
 
+  it('can deploy a contract asynchronously without waiting for the TX to be processed', async () => {
+    const factory = await createContractFactory();
+
+    const { transactionResponse, contract } = await factory.deployContractAsync();
+
+    expect(transactionResponse.gqlTransaction).toBeUndefined();
+
+    const deployResult = await transactionResponse.waitForResult();
+
+    expect(deployResult.isStatusSuccess).toBeTruthy();
+    expect(transactionResponse.gqlTransaction).toBeDefined();
+
+    const { value } = await contract.functions.increment_counter(1).call();
+
+    expect(value.toNumber()).toEqual(1);
+  });
+
   it('Creates a factory from inputs that can prepare call data', async () => {
     const factory = await createContractFactory();