fix: improve error message when persistTransaction times out. Increase default timeout to 130 seconds using Exponential Backoff

README.md

@@ -83,6 +83,12 @@ Test all the packages in the monorepo.
 yarn run test
 ```
 
+Test a specific package by replacing `@requestnetwork/request-client.js` with the desired package name:
+
+```bash
+yarn workspace @requestnetwork/request-client.js test
+```
+
 ## License
 
 [MIT](https://github.com/RequestNetwork/requestNetwork/blob/master/LICENSE)

packages/request-client.js/src/http-data-access.ts

@@ -98,8 +98,6 @@ export default class HttpDataAccess implements DataAccessTypes.IDataAccess {
       { channelId, topics, transactionData },
     );
 
-    const transactionHash: string = normalizeKeccak256Hash(transactionData).value;
-
     // Create the return result with EventEmitter
     const result: DataAccessTypes.IReturnPersistTransaction = Object.assign(
       new EventEmitter() as DataAccessTypes.PersistTransactionEmitter,
@@ -109,33 +107,15 @@ export default class HttpDataAccess implements DataAccessTypes.IDataAccess {
     // Try to get the confirmation
     new Promise((r) => setTimeout(r, this.httpConfig.getConfirmationDeferDelay))
       .then(async () => {
-        const confirmedData =
-          await this.fetchAndRetry<DataAccessTypes.IReturnPersistTransactionRaw>(
-            '/getConfirmedTransaction',
-            {
-              transactionHash,
-            },
-            {
-              maxRetries: this.httpConfig.getConfirmationMaxRetry,
-              retryDelay: this.httpConfig.getConfirmationRetryDelay,
-              exponentialBackoffDelay: this.httpConfig.getConfirmationExponentialBackoffDelay,
-              maxExponentialBackoffDelay: this.httpConfig.getConfirmationMaxExponentialBackoffDelay,
-            },
-          );
+        const confirmedData = await this.getConfirmedTransaction(transactionData);
         // when found, emit the event 'confirmed'
         result.emit('confirmed', confirmedData);
       })
       .catch((e) => {
         let error: Error = e;
         if (e.status === 404) {
           error = new Error(
-            `Transaction confirmation not received. Try polling
-          getTransactionsByChannelId() until the transaction is confirmed.
-          deferDelay: ${this.httpConfig.getConfirmationDeferDelay}ms,
-          maxRetries: ${this.httpConfig.getConfirmationMaxRetry},
-          retryDelay: ${this.httpConfig.getConfirmationRetryDelay}ms,
-          exponentialBackoffDelay: ${this.httpConfig.getConfirmationExponentialBackoffDelay}ms,
-          maxExponentialBackoffDelay: ${this.httpConfig.getConfirmationMaxExponentialBackoffDelay}ms`,
+            `The Request Network SDK timed-out while polling the Request Node to confirm that the Request was persisted successfully. It is likely that the persisted Request will be confirmed eventually. App Builders are discouraged from calling persistTransaction() a second time, which would create a duplicate Request. Instead, App Builders are recommended to catch this error and continue polling the Request Node using getConfirmedTransaction() or by calling the /getConfirmedTransaction endpoint.  To avoid timeouts in the future, try adjusting the httpConfig values when instantiating the RequestNetwork object: getConfirmationDeferDelay: ${this.httpConfig.getConfirmationDeferDelay}ms, getConfirmationMaxRetry: ${this.httpConfig.getConfirmationMaxRetry}, getConfirmationRetryDelay: ${this.httpConfig.getConfirmationRetryDelay}ms, getConfirmationExponentialBackoffDelay: ${this.httpConfig.getConfirmationExponentialBackoffDelay}ms, getConfirmationMaxExponentialBackoffDelay: ${this.httpConfig.getConfirmationMaxExponentialBackoffDelay}ms`,
           );
         }
         result.emit('error', error);
@@ -144,6 +124,29 @@ export default class HttpDataAccess implements DataAccessTypes.IDataAccess {
     return result;
   }
 
+  /**
+   * Gets a transaction from the node through HTTP.
+   * @param transactionData The transaction data
+   */
+  public async getConfirmedTransaction(
+    transactionData: DataAccessTypes.ITransaction,
+  ): Promise<DataAccessTypes.IReturnPersistTransaction> {
+    const transactionHash: string = normalizeKeccak256Hash(transactionData).value;
+
+    return await this.fetchAndRetry(
+      '/getConfirmedTransaction',
+      {
+        transactionHash,
+      },
+      {
+        maxRetries: this.httpConfig.getConfirmationMaxRetry,
+        retryDelay: this.httpConfig.getConfirmationRetryDelay,
+        exponentialBackoffDelay: this.httpConfig.getConfirmationExponentialBackoffDelay,
+        maxExponentialBackoffDelay: this.httpConfig.getConfirmationMaxExponentialBackoffDelay,
+      },
+    );
+  }
+
   /**
    * Gets the transactions for a channel from the node through HTTP.
    *

packages/request-client.js/test/http-data-access.test.ts

@@ -29,22 +29,15 @@ describe('HttpDataAccess', () => {
           getConfirmationMaxRetry: 0,
         },
       });
-      await expect(
-        new Promise((resolve, reject) =>
-          httpDataAccess.persistTransaction({}, '', []).then((returnPersistTransaction) => {
-            returnPersistTransaction.on('confirmed', resolve);
-            returnPersistTransaction.on('error', reject);
-          }),
-        ),
-      ).rejects.toThrow(
-        new Error(`Transaction confirmation not received. Try polling
-          getTransactionsByChannelId() until the transaction is confirmed.
-          deferDelay: 0ms,
-          maxRetries: 0,
-          retryDelay: 1000ms,
-          exponentialBackoffDelay: 0ms,
-          maxExponentialBackoffDelay: 30000ms`),
-      );
+      const returnPersistTransaction = await httpDataAccess.persistTransaction({}, '', []);
+      await new Promise<void>((resolve) => {
+        returnPersistTransaction.on('error', (e: any) => {
+          expect(e.message).toBe(
+            `The Request Network SDK timed-out while polling the Request Node to confirm that the Request was persisted successfully. It is likely that the persisted Request will be confirmed eventually. App Builders are discouraged from calling persistTransaction() a second time, which would create a duplicate Request. Instead, App Builders are recommended to catch this error and continue polling the Request Node using getConfirmedTransaction() or by calling the /getConfirmedTransaction endpoint.  To avoid timeouts in the future, try adjusting the httpConfig values when instantiating the RequestNetwork object: getConfirmationDeferDelay: 0ms, getConfirmationMaxRetries: 0, getConfirmationRetryDelay: 1000ms, getConfirmationExponentialBackoffDelay: 0ms, getConfirmationMaxExponentialBackoffDelay: 30000ms`,
+          );
+          resolve();
+        });
+      });
     });
   });
 });

packages/utils/src/retry.ts

@@ -61,7 +61,7 @@ const retry = <TParams extends unknown[], TReturn>(
             setTimeout(
               resolve,
               retryDelay +
-                Math.min(maxExponentialBackoffDelay, exponentialBackoffDelay * 2 ** retry),
+                Math.min(maxExponentialBackoffDelay, (exponentialBackoffDelay / 2) * 2 ** retry),
             ),
           );
 

packages/utils/test/retry.test.ts

@@ -132,37 +132,88 @@ describe('Retry', () => {
     });
 
     retry(throwFn, {
-      exponentialBackoffDelay: 1000,
-      maxExponentialBackoffDelay: 7000,
-    })();
+      retryDelay: 0,
+      // Exponential backoff starting at 1s, doubling each time, up to a maximum of 64s and max 8 retries, yielding a total timeout of 127s
+      maxRetries: 7,
+      exponentialBackoffDelay: 1000, // 1s
+      maxExponentialBackoffDelay: 64000, // 64s
+    })().catch(() => {
+      // Do nothing
+    });
 
-    // Should call immediately
+    // Should call immediately (1 total calls, 0ms total elapsed)
     expect(throwFn).toHaveBeenCalledTimes(1);
 
-    // Exponential backoff should only call a second time after 2000ms
-    jest.advanceTimersByTime(1100);
+    expect(Date.now()).toBe(0);
+
+    // 1st retry after 1s (2 total calls, 1000ms total elapsed)
+    jest.advanceTimersByTime(999);
     await Promise.resolve();
     expect(throwFn).toHaveBeenCalledTimes(1);
-    jest.advanceTimersByTime(1100);
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(2);
+    expect(Date.now()).toBe(1000);
+
+    // 2nd retry after 3s (3 total calls, 3000ms total elapsed)
+    jest.advanceTimersByTime(1999);
     await Promise.resolve();
     expect(throwFn).toHaveBeenCalledTimes(2);
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(3);
+    expect(Date.now()).toBe(3000);
 
-    // Exponential backoff should call a third time after 4100ms
-    jest.advanceTimersByTime(4100);
+    // 3rd retry after 4s (4 total calls, 7000ms total elapsed)
+    jest.advanceTimersByTime(3999);
     await Promise.resolve();
     expect(throwFn).toHaveBeenCalledTimes(3);
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(4);
+    expect(Date.now()).toBe(7000);
 
-    // Exponential backoff should call a fourth time after 7100ms
-    // since maxExponentialBackoffDelay (7000) < 8000
-    jest.advanceTimersByTime(7100);
+    // 4th retry after 8s (5 total calls, 15000ms total elapsed)
+    jest.advanceTimersByTime(7999);
     await Promise.resolve();
     expect(throwFn).toHaveBeenCalledTimes(4);
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(5);
+    expect(Date.now()).toBe(15000);
 
-    // Exponential backoff should call a fifth time after 7100ms
-    // since maxExponentialBackoffDelay (7000) < 8000
-    jest.advanceTimersByTime(7100);
+    // 5th retry after 16s (6 total calls, 31000ms total elapsed)
+    jest.advanceTimersByTime(15999);
     await Promise.resolve();
     expect(throwFn).toHaveBeenCalledTimes(5);
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(6);
+    expect(Date.now()).toBe(31000);
+
+    // 6th retry after 32s (7 total calls, 63000ms total elapsed)
+    jest.advanceTimersByTime(31999);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(6);
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(7);
+    expect(Date.now()).toBe(63000);
+
+    // 7th retry after 64s (8 total calls, 127000ms total elapsed)
+    jest.advanceTimersByTime(63999);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(7);
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(8);
+    expect(Date.now()).toBe(127000);
+
+    // No further retries
+    jest.advanceTimersByTime(1000000000);
+    await Promise.resolve();
+    expect(throwFn).toHaveBeenCalledTimes(8);
+    expect(Date.now()).toBe(1000127000);
 
     jest.useRealTimers();
   });