Add force batch, refactor batch methods (#4486)

* Add force batch, refactor batch methods

* Remove any type

Author: zaelgohary

packages/grid_client/src/modules/utility.ts

@@ -46,6 +46,21 @@ class Utility {
   async batchAll<T>(options: BatchModel<T>): Promise<T[]> {
     return await this.client.utility.batchAll(options.extrinsics);
   }
+
+  /**
+   * Executes a force batch operation for all provided extrinsics.
+   * This uses Substrate's `utility.force_batch`, which attempts to
+   * execute all calls and only reverts the ones that fail.
+   *
+   * @param {BatchModel<T>} options - The options for the force batch operation, including the extrinsics to be executed.
+   * @returns {Promise<T[]>} A promise that resolves with the result of the force batch operation.
+   */
+  @expose
+  @checkBalance
+  async forceBatch<T>(options: BatchModel<T>): Promise<T[]> {
+    // Cast to any until @threefold/tfchain_client Utility type exposes forceBatch in its typings
+    return await this.client.utility.forceBatch(options.extrinsics);
+  }
 }
 
 export { Utility as utility };

packages/tfchain_client/src/client.ts

@@ -407,10 +407,15 @@ class Client extends QueryClient {
     }
     return result;
   }
+
   async applyAllExtrinsics<T>(extrinsics: ExtrinsicResult<T>[]) {
     return this.utility.batchAll<T>(extrinsics);
   }
 
+  async applyForceBatchExtrinsics<T>(extrinsics: ExtrinsicResult<T>[]) {
+    return this.utility.forceBatch<T>(extrinsics);
+  }
+
   patchExtrinsic<R>(extrinsic: Extrinsic, options: PatchExtrinsicOptions<R> = {}): ExtrinsicResult<R> {
     const self = this;
     (<any>extrinsic).apply = async () => {

packages/tfchain_client/src/utility.ts

@@ -12,32 +12,31 @@ class Utility {
 
   @checkConnection
   async batch<T>(extrinsics: ExtrinsicResult<T>[]): Promise<T[]> {
-    extrinsics = extrinsics.filter(Boolean);
-    if (extrinsics.length > 0) {
-      let result: T[] = [];
-      for (let i = 0; i < extrinsics.length; i += BATCH_SIZE) {
-        const batch = extrinsics.slice(i, i + BATCH_SIZE);
-        const { resultSections, resultEvents, map } = this.extractResultSectionsAndEvents(batch);
-        const batchExtrinsic = await this.client.api.tx.utility.batch(batch);
-        const res = await this.client.applyExtrinsic<T>(batchExtrinsic, resultSections, resultEvents, map);
-        result = result.concat(res);
-      }
-
-      return result;
-    }
-    return [];
+    return this.applyBatch(extrinsics, batch => this.client.api.tx.utility.batch(batch));
   }
 
   @checkConnection
   async batchAll<T>(extrinsics: ExtrinsicResult<T>[]): Promise<T[]> {
+    return this.applyBatch(extrinsics, batch => this.client.api.tx.utility.batchAll(batch));
+  }
+
+  @checkConnection
+  async forceBatch<T>(extrinsics: ExtrinsicResult<T>[]): Promise<T[]> {
+    return this.applyBatch(extrinsics, batch => this.client.api.tx.utility.forceBatch(batch));
+  }
+
+  private async applyBatch<T>(
+    extrinsics: ExtrinsicResult<T>[],
+    buildExtrinsic: (batch: ExtrinsicResult<T>[]) => any,
+  ): Promise<T[]> {
     extrinsics = extrinsics.filter(Boolean);
     if (extrinsics.length > 0) {
       let result: T[] = [];
       for (let i = 0; i < extrinsics.length; i += BATCH_SIZE) {
         const batch = extrinsics.slice(i, i + BATCH_SIZE);
         const { resultSections, resultEvents, map } = this.extractResultSectionsAndEvents(batch);
-        const batchAllExtrinsic = await this.client.api.tx.utility.batchAll(batch);
-        const res = await this.client.applyExtrinsic<T>(batchAllExtrinsic, resultSections, resultEvents, map);
+        const extrinsic = await buildExtrinsic(batch);
+        const res = await this.client.applyExtrinsic<T>(extrinsic, resultSections, resultEvents, map);
         result = result.concat(res);
       }