feat!: non-blocking blob deployment

.changeset/forty-apes-tell.md

@@ -0,0 +1,5 @@
+---
+"@fuel-ts/contract": minor
+---
+
+feat!: non-blocking blob deployment

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

@@ -50,7 +50,9 @@ describe('Deploying Contracts', () => {
 
     // #region deploy
     // Deploy the contract
-    const { waitForResult, contractId, transactionId } = await factory.deploy();
+    const { waitForResult, contractId, waitForTransactionId } = await factory.deploy();
+    // Retrieve the transactionId
+    const transactionId = await waitForTransactionId();
     // Await it's deployment
     const { contract, transactionResult } = await waitForResult();
     // #endregion deploy
@@ -90,14 +92,15 @@ describe('Deploying Contracts', () => {
     const factory = new ContractFactory(bytecode, abi, wallet);
 
     // Deploy the contract as blobs
-    const { waitForResult, contractId, transactionId } = await factory.deployAsBlobTx({
+    const { waitForResult, contractId, waitForTransactionId } = await factory.deployAsBlobTx({
       // Increasing chunk size multiplier to be 90% of the max chunk size
       chunkSizeMultiplier: 0.9,
     });
     // Await it's deployment
     const { contract, transactionResult } = await waitForResult();
     // #endregion blobs
 
+    const transactionId = await waitForTransactionId();
     expect(contract).toBeDefined();
     expect(transactionId).toBeDefined();
     expect(transactionResult.status).toBeTruthy();

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

@@ -39,11 +39,11 @@ Once you have the contract artifacts, it can be passed to the `ContractFactory`
 
 As mentioned earlier, there are two different processes for contract deployment handled by the `ContractFactory`. These can be used interchangeably, however, the `deploy` method is recommended as it will automatically choose the appropriate deployment process based on the contract size.
 
-This call resolves as soon as the transaction to deploy the contract is submitted and returns three items: the `contractId`, the `transactionId` and a `waitForResult` function.
+This call resolves as soon as the transaction to deploy the contract is submitted and returns three items: the `contractId`, a `waitForTransactionId` function and a `waitForResult` function.
 
 <<< @/../../docs-snippets/src/guide/contracts/deploying-contracts.test.ts#deploy{ts:line-numbers}
 
-The `contract` instance will be returned only after calling `waitForResult` and waiting for it to resolve. 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.
+The `contract` instance will be returned only after calling `waitForResult` and waiting for it to resolve. 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. Similarly, the transaction ID is only available once the underlying transaction has been funded. To avoid blocking the code until the ID is ready, you can use the `waitForTransactionId` function to await it's retrieval.
 
 ### 3. Executing a Contract Call
 
@@ -59,4 +59,4 @@ In the above guide we use the recommended `deploy` method. If you are working wi
 
 In the above example, we also pass a `chunkSizeMultiplier` option to the deployment method. The SDK will attempt to chunk the contract to the most optimal about, however the transaction size can fluctuate and you can also be limited by request size limits against the node. By default we set a multiplier of 0.95, meaning the chunk size will be 95% of the potential maximum size, however you can adjust this to suit your needs and ensure the transaction passes. It must be set to a value between 0 and 1.
 
-> **Note:** Blob deployments contain multiple dependent transactions, so you will need to wait longer than usual for the contract to be fully deployed and can be interacted with.
+> **Note:** Deploying large contracts using blob transactions will take more time. Each transaction is dependent and has to wait for a block to be produced before it gets mined. Then a create transaction is submitted as normal. So you will need to wait longer than usual for the contract to be fully deployed and can be interacted with.

packages/contract/src/contract-factory.ts

@@ -21,7 +21,7 @@ import type { BytesLike } from '@fuel-ts/interfaces';
 import { bn } from '@fuel-ts/math';
 import { Contract } from '@fuel-ts/program';
 import type { StorageSlot } from '@fuel-ts/transactions';
-import { arrayify, isDefined } from '@fuel-ts/utils';
+import { arrayify, isDefined, sleep } from '@fuel-ts/utils';
 
 import { getLoaderInstructions, getContractChunks } from './loader';
 import { getContractId, getContractStorageRoot, hexlifyWithPrefix } from './util';
@@ -41,8 +41,8 @@ export type DeployContractOptions = {
 } & CreateTransactionRequestLike;
 
 export type DeployContractResult<TContract extends Contract = Contract> = {
-  transactionId: string;
   contractId: string;
+  waitForTransactionId: () => Promise<string>;
   waitForResult: () => Promise<{
     contract: TContract;
     transactionResult: TransactionResult<TransactionType.Create>;
@@ -235,7 +235,11 @@ export default class ContractFactory {
       return { contract, transactionResult };
     };
 
-    return { waitForResult, contractId, transactionId: transactionResponse.id };
+    return {
+      contractId,
+      waitForTransactionId: () => Promise.resolve(transactionResponse.id),
+      waitForResult,
+    };
   }
 
   /**
@@ -255,7 +259,7 @@ export default class ContractFactory {
       this.setConfigurableConstants(configurableConstants);
     }
 
-    // Generate the chunks based on the maximum chunk size
+    // Generate the chunks based on the maximum chunk size and create blob txs
     const chunkSize = this.getMaxChunkSize(deployOptions, chunkSizeMultiplier);
     const chunks = getContractChunks(arrayify(this.bytecode), chunkSize).map((c) => {
       const transactionRequest = this.blobTransactionRequest({
@@ -269,10 +273,19 @@ export default class ContractFactory {
       };
     });
 
-    // Check the account can afford to deploy all chunks
+    // Generate the associated create tx for the loader contract
+    const blobIds = chunks.map(({ blobId }) => blobId);
+    const loaderBytecode = getLoaderInstructions(blobIds);
+    const { contractId, transactionRequest: createRequest } = this.createTransactionRequest({
+      bytecode: loaderBytecode,
+      ...deployOptions,
+    });
+
+    // Check the account can afford to deploy all chunks and loader
     let totalCost = bn(0);
     const chainInfo = account.provider.getChain();
     const gasPrice = await account.provider.estimateGasPrice(10);
+    const priceFactor = chainInfo.consensusParameters.feeParameters.gasPriceFactor;
     const estimatedBlobIds: string[] = [];
 
     for (const { transactionRequest, blobId } of chunks) {
@@ -281,73 +294,90 @@ export default class ContractFactory {
         const minFee = calculateGasFee({
           gasPrice,
           gas: minGas,
-          priceFactor: chainInfo.consensusParameters.feeParameters.gasPriceFactor,
+          priceFactor,
           tip: transactionRequest.tip,
         }).add(1);
 
         totalCost = totalCost.add(minFee);
         estimatedBlobIds.push(blobId);
       }
+      const createMinGas = createRequest.calculateMinGas(chainInfo);
+      const createMinFee = calculateGasFee({
+        gasPrice,
+        gas: createMinGas,
+        priceFactor,
+        tip: createRequest.tip,
+      }).add(1);
+      totalCost = totalCost.add(createMinFee);
     }
     if (totalCost.gt(await account.getBalance())) {
       throw new FuelError(ErrorCode.FUNDS_TOO_LOW, 'Insufficient balance to deploy contract.');
     }
 
-    // Upload the blob if it hasn't been uploaded yet. Duplicate blob IDs will fail gracefully.
-    const uploadedBlobs: string[] = [];
+    // Transaction id is unset until we have funded the create tx, which is dependent on the blob txs
+    let transactionId: string;
 
-    // Deploy the chunks as blob txs
-    for (const { blobId, transactionRequest } of chunks) {
-      if (!uploadedBlobs.includes(blobId)) {
-        const fundedBlobRequest = await this.fundTransactionRequest(
-          transactionRequest,
-          deployOptions
-        );
+    const waitForResult = async () => {
+      // Upload the blob if it hasn't been uploaded yet. Duplicate blob IDs will fail gracefully.
+      const uploadedBlobs: string[] = [];
+      // Deploy the chunks as blob txs
+      for (const { blobId, transactionRequest } of chunks) {
+        if (!uploadedBlobs.includes(blobId)) {
+          const fundedBlobRequest = await this.fundTransactionRequest(
+            transactionRequest,
+            deployOptions
+          );
 
-        let result: TransactionResult<TransactionType.Blob>;
-
-        try {
-          const blobTx = await account.sendTransaction(fundedBlobRequest);
-          result = await blobTx.waitForResult();
-        } catch (err: unknown) {
-          // Core will throw for blobs that have already been uploaded, but the blobId
-          // is still valid so we can use this for the loader contract
-          if ((<Error>err).message.indexOf(`BlobId is already taken ${blobId}`) > -1) {
-            // eslint-disable-next-line no-continue
-            continue;
+          let result: TransactionResult<TransactionType.Blob>;
+
+          try {
+            const blobTx = await account.sendTransaction(fundedBlobRequest);
+            result = await blobTx.waitForResult();
+          } catch (err: unknown) {
+            // Core will throw for blobs that have already been uploaded, but the blobId
+            // is still valid so we can use this for the loader contract
+            if ((<Error>err).message.indexOf(`BlobId is already taken ${blobId}`) > -1) {
+              // eslint-disable-next-line no-continue
+              continue;
+            }
+
+            throw new FuelError(ErrorCode.TRANSACTION_FAILED, 'Failed to deploy contract chunk');
           }
 
-          throw new FuelError(ErrorCode.TRANSACTION_FAILED, 'Failed to deploy contract chunk');
-        }
+          if (!result.status || result.status !== TransactionStatus.success) {
+            throw new FuelError(ErrorCode.TRANSACTION_FAILED, 'Failed to deploy contract chunk');
+          }
 
-        if (!result.status || result.status !== TransactionStatus.success) {
-          throw new FuelError(ErrorCode.TRANSACTION_FAILED, 'Failed to deploy contract chunk');
+          uploadedBlobs.push(blobId);
         }
-
-        uploadedBlobs.push(blobId);
       }
-    }
-
-    // Get the loader bytecode
-    const blobIds = chunks.map(({ blobId }) => blobId);
-    const loaderBytecode = getLoaderInstructions(blobIds);
 
-    // Deploy the loader contract via create tx
-    const { contractId, transactionRequest: createRequest } = this.createTransactionRequest({
-      bytecode: loaderBytecode,
-      ...deployOptions,
-    });
-    await this.fundTransactionRequest(createRequest, deployOptions);
-    const transactionResponse = await account.sendTransaction(createRequest);
-
-    const waitForResult = async () => {
+      await this.fundTransactionRequest(createRequest, deployOptions);
+      transactionId = createRequest.getTransactionId(account.provider.getChainId());
+      const transactionResponse = await account.sendTransaction(createRequest);
       const transactionResult = await transactionResponse.waitForResult<TransactionType.Create>();
       const contract = new Contract(contractId, this.interface, account) as TContract;
 
       return { contract, transactionResult };
     };
 
-    return { waitForResult, contractId, transactionId: transactionResponse.id };
+    const waitForTransactionId = async () => {
+      const maxPollingTime = 15_000_000; // 15 Minutes
+      const timePerPoll = 500; // 1/2 Second
+      const maxPollingAttempts = maxPollingTime / timePerPoll;
+      let attempts = 0;
+
+      while (!transactionId) {
+        if (attempts++ > maxPollingAttempts) {
+          throw new FuelError(ErrorCode.TRANSACTION_FAILED, 'Failed to retrieve transaction ID');
+        }
+
+        await sleep(timePerPoll);
+      }
+      return Promise.resolve(transactionId);
+    };
+
+    return { waitForResult, contractId, waitForTransactionId };
   }
 
   /**

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

@@ -293,6 +293,34 @@ describe('Contract Factory', () => {
     expect(value.toNumber()).toBe(1001);
   }, 15000);
 
+  it('deploys large contracts via blobs and awaits transaction id', async () => {
+    using launched = await launchTestNode({
+      nodeOptions: {
+        args: ['--tx-pool-ttl', '1s'],
+      },
+      providerOptions: {
+        resourceCacheTTL: -1,
+      },
+    });
+
+    const {
+      wallets: [wallet],
+    } = launched;
+
+    const factory = new ContractFactory(LargeContractFactory.bytecode, LargeContract.abi, wallet);
+    const deploy = await factory.deployAsBlobTx<LargeContract>();
+    const initTxId = deploy.waitForTransactionId();
+    expect(initTxId).toStrictEqual(new Promise(() => {}));
+    const { contract } = await deploy.waitForResult();
+    expect(contract.id).toBeDefined();
+    const awaitTxId = await deploy.waitForTransactionId();
+    expect(awaitTxId).toBeTruthy();
+
+    const call = await contract.functions.something().call();
+    const { value } = await call.waitForResult();
+    expect(value.toNumber()).toBe(1001);
+  });
+
   it('deploys large contracts via blobs [padded]', async () => {
     using launched = await launchTestNode({
       providerOptions: {