Add destroy method to block tracker classes

src/BaseBlockTracker.ts

@@ -45,6 +45,12 @@ export abstract class BaseBlockTracker extends SafeEventEmitter {
     this._setupInternalEvents();
   }
 
+  async destroy() {
+    this._cancelBlockResetTimeout();
+    await this._maybeEnd();
+    super.removeAllListeners();
+  }
+
   isRunning(): boolean {
     return this._isRunning;
   }

src/PollingBlockTracker.test.ts

@@ -36,6 +36,115 @@ describe('PollingBlockTracker', () => {
     });
   });
 
+  describe('destroy', () => {
+    it('should stop the block tracker if any "latest" and "sync" events were added previously', async () => {
+      recordCallsToSetTimeout();
+
+      await withPollingBlockTracker(async ({ blockTracker }) => {
+        blockTracker.on('latest', EMPTY_FUNCTION);
+        await new Promise<void>((resolve) => {
+          blockTracker.on('sync', resolve);
+        });
+        expect(blockTracker.isRunning()).toBe(true);
+
+        await blockTracker.destroy();
+
+        expect(blockTracker.isRunning()).toBe(false);
+      });
+    });
+
+    it('should not start a timer to clear the current block number if called after removing all listeners but before enough time passes that the cache would have been cleared', async () => {
+      const setTimeoutRecorder = recordCallsToSetTimeout();
+      const blockTrackerOptions = {
+        pollingInterval: 100,
+        blockResetDuration: 200,
+      };
+
+      await withPollingBlockTracker(
+        {
+          provider: {
+            stubs: [
+              {
+                methodName: 'eth_blockNumber',
+                response: {
+                  result: '0x0',
+                },
+              },
+            ],
+          },
+          blockTracker: blockTrackerOptions,
+        },
+        async ({ blockTracker }) => {
+          blockTracker.on('latest', EMPTY_FUNCTION);
+          blockTracker.on('sync', EMPTY_FUNCTION);
+          await new Promise((resolve) => {
+            blockTracker.on('_waitingForNextIteration', resolve);
+          });
+          expect(blockTracker.getCurrentBlock()).toStrictEqual('0x0');
+          blockTracker.removeAllListeners();
+          expect(
+            setTimeoutRecorder.calls.some((call) => {
+              return call.duration === blockTrackerOptions.blockResetDuration;
+            }),
+          ).toBe(true);
+
+          await blockTracker.destroy();
+
+          expect(
+            setTimeoutRecorder.calls.some((call) => {
+              return call.duration === blockTrackerOptions.blockResetDuration;
+            }),
+          ).toBe(false);
+
+          await new Promise((resolve) =>
+            originalSetTimeout(resolve, blockTrackerOptions.blockResetDuration),
+          );
+          expect(blockTracker.getCurrentBlock()).toStrictEqual('0x0');
+        },
+      );
+    });
+
+    it('should only clear the current block number if enough time passes after all "latest" and "sync" events are removed', async () => {
+      const setTimeoutRecorder = recordCallsToSetTimeout();
+      const blockTrackerOptions = {
+        pollingInterval: 100,
+        blockResetDuration: 200,
+      };
+
+      await withPollingBlockTracker(
+        {
+          provider: {
+            stubs: [
+              {
+                methodName: 'eth_blockNumber',
+                response: {
+                  result: '0x0',
+                },
+              },
+            ],
+          },
+          blockTracker: blockTrackerOptions,
+        },
+        async ({ blockTracker }) => {
+          blockTracker.on('latest', EMPTY_FUNCTION);
+          blockTracker.on('sync', EMPTY_FUNCTION);
+          await new Promise((resolve) => {
+            blockTracker.on('_waitingForNextIteration', resolve);
+          });
+          expect(blockTracker.getCurrentBlock()).toStrictEqual('0x0');
+          blockTracker.removeAllListeners();
+          await setTimeoutRecorder.nextMatchingDuration(
+            blockTrackerOptions.blockResetDuration,
+          );
+
+          await blockTracker.destroy();
+
+          expect(blockTracker.getCurrentBlock()).toBeNull();
+        },
+      );
+    });
+  });
+
   describe('getLatestBlock', () => {
     it('should start the block tracker immediately after being called', async () => {
       recordCallsToSetTimeout();

src/SubscribeBlockTracker.test.ts

@@ -15,6 +15,7 @@ const METHODS_TO_GET_LATEST_BLOCK = [
   'getLatestBlock',
   'checkForLatestBlock',
 ] as const;
+const originalSetTimeout = setTimeout;
 
 describe('SubscribeBlockTracker', () => {
   describe('constructor', () => {
@@ -39,6 +40,96 @@ describe('SubscribeBlockTracker', () => {
     });
   });
 
+  describe('destroy', () => {
+    it('should stop the block tracker if any "latest" and "sync" events were added previously', async () => {
+      recordCallsToSetTimeout();
+
+      await withSubscribeBlockTracker(async ({ blockTracker }) => {
+        blockTracker.on('latest', EMPTY_FUNCTION);
+        await new Promise<void>((resolve) => {
+          blockTracker.on('sync', resolve);
+        });
+        expect(blockTracker.isRunning()).toBe(true);
+
+        await blockTracker.destroy();
+
+        expect(blockTracker.isRunning()).toBe(false);
+      });
+    });
+
+    it('should not start a timer to clear the current block number if called after removing all listeners but before enough time passes that the cache would have been cleared', async () => {
+      const setTimeoutRecorder = recordCallsToSetTimeout();
+      const blockResetDuration = 500;
+
+      await withSubscribeBlockTracker(
+        {
+          blockTracker: {
+            blockResetDuration,
+          },
+          provider: {
+            stubs: [
+              {
+                methodName: 'eth_blockNumber',
+                response: {
+                  result: '0x0',
+                },
+              },
+            ],
+          },
+        },
+        async ({ blockTracker }) => {
+          blockTracker.on('latest', EMPTY_FUNCTION);
+          await new Promise((resolve) => {
+            blockTracker.on('sync', resolve);
+          });
+          expect(blockTracker.getCurrentBlock()).toStrictEqual('0x0');
+          blockTracker.removeAllListeners();
+          expect(setTimeoutRecorder.calls).not.toHaveLength(0);
+
+          await blockTracker.destroy();
+
+          expect(setTimeoutRecorder.calls).toHaveLength(0);
+          await new Promise((resolve) =>
+            originalSetTimeout(resolve, blockResetDuration),
+          );
+          expect(blockTracker.getCurrentBlock()).toStrictEqual('0x0');
+        },
+      );
+    });
+
+    it('should only clear the current block number if enough time passes after all "latest" and "sync" events are removed', async () => {
+      const setTimeoutRecorder = recordCallsToSetTimeout();
+
+      await withSubscribeBlockTracker(
+        {
+          provider: {
+            stubs: [
+              {
+                methodName: 'eth_blockNumber',
+                response: {
+                  result: '0x0',
+                },
+              },
+            ],
+          },
+        },
+        async ({ blockTracker }) => {
+          blockTracker.on('latest', EMPTY_FUNCTION);
+          await new Promise((resolve) => {
+            blockTracker.on('sync', resolve);
+          });
+          expect(blockTracker.getCurrentBlock()).toStrictEqual('0x0');
+          blockTracker.removeAllListeners();
+          await setTimeoutRecorder.next();
+
+          await blockTracker.destroy();
+
+          expect(blockTracker.getCurrentBlock()).toBeNull();
+        },
+      );
+    });
+  });
+
   METHODS_TO_GET_LATEST_BLOCK.forEach((methodToGetLatestBlock) => {
     describe(`${methodToGetLatestBlock}`, () => {
       it('should start the block tracker immediately after being called', async () => {

tests/recordCallsToSetTimeout.ts

@@ -43,6 +43,29 @@ class SetTimeoutRecorder {
     this.#numAutomaticCallsRemaining = numAutomaticCalls;
   }
 
+  /**
+   * Removes the first `setTimeout` call from the call stack and calls it, or
+   * waits until one appears.
+   *
+   * @returns A promise that resolves when the first `setTimeout` call is
+   * called.
+   */
+  next(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      if (this.calls.length > 0) {
+        const call = this.calls.shift() as SetTimeoutCall;
+        call.callback();
+        resolve();
+      } else {
+        this.#events.once('setTimeoutAdded', () => {
+          const call = this.calls.shift() as SetTimeoutCall;
+          call.callback();
+          resolve();
+        });
+      }
+    });
+  }
+
   /**
    * Looks for the first `setTimeout` call in the call stack that matches the
    * given duration and calls it, removing it from the call stack, or waits