@metamask-previews/eth-block-tracker 15.0.0-preview-7bc2d97e → 15.0.0-preview-6bed60a6

package/CHANGELOG.md

@@ -7,10 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Changed
-
-- Upgrade `@metamask/utils` from `^11.8.1` to `^11.9.0` ([#7511](https://github.com/MetaMask/core/pull/7511))
-
 ## [15.0.0]
 
 ### Added

package/dist/PollingBlockTracker.cjs

@@ -1,19 +1,19 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _PollingBlockTracker_instances, _PollingBlockTracker_isRunning, _PollingBlockTracker_blockResetDuration, _PollingBlockTracker_usePastBlocks, _PollingBlockTracker_currentBlock, _PollingBlockTracker_blockResetTimeout, _PollingBlockTracker_pollingTimeout, _PollingBlockTracker_provider, _PollingBlockTracker_pollingInterval, _PollingBlockTracker_retryTimeout, _PollingBlockTracker_keepEventLoopActive, _PollingBlockTracker_setSkipCacheFlag, _PollingBlockTracker_internalEventListeners, _PollingBlockTracker_pendingLatestBlock, _PollingBlockTracker_pendingFetch, _PollingBlockTracker_onNewListener, _PollingBlockTracker_onRemoveListener, _PollingBlockTracker_resetCurrentBlock, _PollingBlockTracker_setupInternalEvents, _PollingBlockTracker_onNewListenerUnbound, _PollingBlockTracker_onRemoveListenerUnbound, _PollingBlockTracker_maybeStart, _PollingBlockTracker_maybeEnd, _PollingBlockTracker_getBlockTrackerEventCount, _PollingBlockTracker_shouldUseNewBlock, _PollingBlockTracker_newPotentialLatest, _PollingBlockTracker_setCurrentBlock, _PollingBlockTracker_setupBlockResetTimeout, _PollingBlockTracker_cancelBlockResetTimeout, _PollingBlockTracker_resetCurrentBlockUnbound, _PollingBlockTracker_start, _PollingBlockTracker_end, _PollingBlockTracker_updateLatestBlock, _PollingBlockTracker_fetchLatestBlock, _PollingBlockTracker_updateAndQueue, _PollingBlockTracker_clearPollingTimeout, _PollingBlockTracker_addInternalListener, _PollingBlockTracker_removeInternalListener, _PollingBlockTracker_rejectPendingLatestBlock;
+var _PollingBlockTracker_instances, _PollingBlockTracker_internalEventListeners, _PollingBlockTracker_pendingLatestBlock, _PollingBlockTracker_pendingFetch, _PollingBlockTracker_addInternalListener, _PollingBlockTracker_removeInternalListener, _PollingBlockTracker_rejectPendingLatestBlock;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PollingBlockTracker = void 0;
 const safe_event_emitter_1 = __importDefault(require("@metamask/safe-event-emitter"));
@@ -32,57 +32,44 @@ class PollingBlockTracker extends safe_event_emitter_1.default {
         }
         super();
         _PollingBlockTracker_instances.add(this);
-        _PollingBlockTracker_isRunning.set(this, void 0);
-        _PollingBlockTracker_blockResetDuration.set(this, void 0);
-        _PollingBlockTracker_usePastBlocks.set(this, void 0);
-        _PollingBlockTracker_currentBlock.set(this, void 0);
-        _PollingBlockTracker_blockResetTimeout.set(this, void 0);
-        _PollingBlockTracker_pollingTimeout.set(this, void 0);
-        _PollingBlockTracker_provider.set(this, void 0);
-        _PollingBlockTracker_pollingInterval.set(this, void 0);
-        _PollingBlockTracker_retryTimeout.set(this, void 0);
-        _PollingBlockTracker_keepEventLoopActive.set(this, void 0);
-        _PollingBlockTracker_setSkipCacheFlag.set(this, void 0);
         _PollingBlockTracker_internalEventListeners.set(this, []);
         _PollingBlockTracker_pendingLatestBlock.set(this, void 0);
         _PollingBlockTracker_pendingFetch.set(this, void 0);
-        _PollingBlockTracker_onNewListener.set(this, void 0);
-        _PollingBlockTracker_onRemoveListener.set(this, void 0);
-        _PollingBlockTracker_resetCurrentBlock.set(this, void 0);
         // config
-        __classPrivateFieldSet(this, _PollingBlockTracker_blockResetDuration, opts.blockResetDuration ?? 20 * sec, "f");
-        __classPrivateFieldSet(this, _PollingBlockTracker_usePastBlocks, opts.usePastBlocks ?? false, "f");
+        this._blockResetDuration = opts.blockResetDuration || 20 * sec;
+        this._usePastBlocks = opts.usePastBlocks || false;
         // state
-        __classPrivateFieldSet(this, _PollingBlockTracker_currentBlock, null, "f");
-        __classPrivateFieldSet(this, _PollingBlockTracker_isRunning, false, "f");
+        this._currentBlock = null;
+        this._isRunning = false;
         // bind functions for internal use
-        __classPrivateFieldSet(this, _PollingBlockTracker_onNewListener, __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_onNewListenerUnbound).bind(this), "f");
-        __classPrivateFieldSet(this, _PollingBlockTracker_onRemoveListener, __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_onRemoveListenerUnbound).bind(this), "f");
-        __classPrivateFieldSet(this, _PollingBlockTracker_resetCurrentBlock, __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_resetCurrentBlockUnbound).bind(this), "f");
+        this._onNewListener = this._onNewListener.bind(this);
+        this._onRemoveListener = this._onRemoveListener.bind(this);
+        this._resetCurrentBlock = this._resetCurrentBlock.bind(this);
         // listen for handler changes
-        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_setupInternalEvents).call(this);
+        this._setupInternalEvents();
         // config
-        __classPrivateFieldSet(this, _PollingBlockTracker_provider, opts.provider, "f");
-        __classPrivateFieldSet(this, _PollingBlockTracker_pollingInterval, opts.pollingInterval ?? 20 * sec, "f");
-        __classPrivateFieldSet(this, _PollingBlockTracker_retryTimeout, opts.retryTimeout ?? __classPrivateFieldGet(this, _PollingBlockTracker_pollingInterval, "f") / 10, "f");
-        __classPrivateFieldSet(this, _PollingBlockTracker_keepEventLoopActive, opts.keepEventLoopActive ?? true, "f");
-        __classPrivateFieldSet(this, _PollingBlockTracker_setSkipCacheFlag, opts.setSkipCacheFlag ?? false, "f");
+        this._provider = opts.provider;
+        this._pollingInterval = opts.pollingInterval || 20 * sec;
+        this._retryTimeout = opts.retryTimeout || this._pollingInterval / 10;
+        this._keepEventLoopActive =
+            opts.keepEventLoopActive === undefined ? true : opts.keepEventLoopActive;
+        this._setSkipCacheFlag = opts.setSkipCacheFlag || false;
     }
     async destroy() {
-        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_cancelBlockResetTimeout).call(this);
+        this._cancelBlockResetTimeout();
         super.removeAllListeners();
-        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_maybeEnd).call(this);
+        this._maybeEnd();
     }
     isRunning() {
-        return __classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f");
+        return this._isRunning;
     }
     getCurrentBlock() {
-        return __classPrivateFieldGet(this, _PollingBlockTracker_currentBlock, "f");
+        return this._currentBlock;
     }
     async getLatestBlock({ useCache = true, } = {}) {
         // return if available
-        if (__classPrivateFieldGet(this, _PollingBlockTracker_currentBlock, "f") && useCache) {
-            return __classPrivateFieldGet(this, _PollingBlockTracker_currentBlock, "f");
+        if (this._currentBlock && useCache) {
+            return this._currentBlock;
         }
         if (__classPrivateFieldGet(this, _PollingBlockTracker_pendingLatestBlock, "f")) {
             return await __classPrivateFieldGet(this, _PollingBlockTracker_pendingLatestBlock, "f").promise;
@@ -91,7 +78,7 @@ class PollingBlockTracker extends safe_event_emitter_1.default {
             suppressUnhandledRejection: true,
         });
         __classPrivateFieldSet(this, _PollingBlockTracker_pendingLatestBlock, { reject, promise }, "f");
-        if (__classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f")) {
+        if (this._isRunning) {
             try {
                 // If tracker is running, wait for next block with timeout
                 const onLatestBlock = (value) => {
@@ -114,7 +101,7 @@ class PollingBlockTracker extends safe_event_emitter_1.default {
         else {
             // If tracker isn't running, just fetch directly
             try {
-                const latestBlock = await __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_updateLatestBlock).call(this);
+                const latestBlock = await this._updateLatestBlock();
                 resolve(latestBlock);
                 return latestBlock;
             }
@@ -128,11 +115,11 @@ class PollingBlockTracker extends safe_event_emitter_1.default {
                 // achieve this by delaying the unsetting of the #pendingLatestBlock promise.
                 setTimeout(() => {
                     __classPrivateFieldSet(this, _PollingBlockTracker_pendingLatestBlock, undefined, "f");
-                }, __classPrivateFieldGet(this, _PollingBlockTracker_pollingInterval, "f"));
+                }, this._pollingInterval);
             }
         }
     }
-    // Don't allow module consumer to remove our internal event listeners.
+    // dont allow module consumer to remove our internal event listeners
     removeAllListeners(eventName) {
         // perform default behavior, preserve fn arity
         if (eventName) {
@@ -142,192 +129,209 @@ class PollingBlockTracker extends safe_event_emitter_1.default {
             super.removeAllListeners();
         }
         // re-add internal events
-        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_setupInternalEvents).call(this);
+        this._setupInternalEvents();
         // trigger stop check just in case
-        __classPrivateFieldGet(this, _PollingBlockTracker_onRemoveListener, "f").call(this);
+        this._onRemoveListener();
         return this;
     }
-    /**
-     * Checks for the latest block, updates the internal state,  and returns the
-     * value immediately rather than waiting for the next polling interval.
-     *
-     * @deprecated Use {@link getLatestBlock} instead.
-     * @returns A promise that resolves to the latest block number.
-     */
-    async checkForLatestBlock() {
-        await __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_updateLatestBlock).call(this);
-        return await this.getLatestBlock();
-    }
-}
-exports.PollingBlockTracker = PollingBlockTracker;
-_PollingBlockTracker_isRunning = new WeakMap(), _PollingBlockTracker_blockResetDuration = new WeakMap(), _PollingBlockTracker_usePastBlocks = new WeakMap(), _PollingBlockTracker_currentBlock = new WeakMap(), _PollingBlockTracker_blockResetTimeout = new WeakMap(), _PollingBlockTracker_pollingTimeout = new WeakMap(), _PollingBlockTracker_provider = new WeakMap(), _PollingBlockTracker_pollingInterval = new WeakMap(), _PollingBlockTracker_retryTimeout = new WeakMap(), _PollingBlockTracker_keepEventLoopActive = new WeakMap(), _PollingBlockTracker_setSkipCacheFlag = new WeakMap(), _PollingBlockTracker_internalEventListeners = new WeakMap(), _PollingBlockTracker_pendingLatestBlock = new WeakMap(), _PollingBlockTracker_pendingFetch = new WeakMap(), _PollingBlockTracker_onNewListener = new WeakMap(), _PollingBlockTracker_onRemoveListener = new WeakMap(), _PollingBlockTracker_resetCurrentBlock = new WeakMap(), _PollingBlockTracker_instances = new WeakSet(), _PollingBlockTracker_setupInternalEvents = function _PollingBlockTracker_setupInternalEvents() {
-    // first remove listeners for idempotence
-    this.removeListener('newListener', __classPrivateFieldGet(this, _PollingBlockTracker_onNewListener, "f"));
-    this.removeListener('removeListener', __classPrivateFieldGet(this, _PollingBlockTracker_onRemoveListener, "f"));
-    // then add them
-    this.on('newListener', __classPrivateFieldGet(this, _PollingBlockTracker_onNewListener, "f"));
-    this.on('removeListener', __classPrivateFieldGet(this, _PollingBlockTracker_onRemoveListener, "f"));
-}, _PollingBlockTracker_onNewListenerUnbound = function _PollingBlockTracker_onNewListenerUnbound(eventName) {
-    // `newListener` is called *before* the listener is added
-    if (blockTrackerEvents.includes(eventName)) {
-        // TODO: Handle dangling promise
-        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_maybeStart).call(this);
+    _setupInternalEvents() {
+        // first remove listeners for idempotence
+        this.removeListener('newListener', this._onNewListener);
+        this.removeListener('removeListener', this._onRemoveListener);
+        // then add them
+        this.on('newListener', this._onNewListener);
+        this.on('removeListener', this._onRemoveListener);
     }
-}, _PollingBlockTracker_onRemoveListenerUnbound = function _PollingBlockTracker_onRemoveListenerUnbound() {
-    // `removeListener` is called *after* the listener is removed
-    if (__classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_getBlockTrackerEventCount).call(this) > 0) {
-        return;
+    _onNewListener(eventName) {
+        // `newListener` is called *before* the listener is added
+        if (blockTrackerEvents.includes(eventName)) {
+            // TODO: Handle dangling promise
+            this._maybeStart();
+        }
     }
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_maybeEnd).call(this);
-}, _PollingBlockTracker_maybeStart = function _PollingBlockTracker_maybeStart() {
-    if (__classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f")) {
-        return;
+    _onRemoveListener() {
+        // `removeListener` is called *after* the listener is removed
+        if (this._getBlockTrackerEventCount() > 0) {
+            return;
+        }
+        this._maybeEnd();
     }
-    __classPrivateFieldSet(this, _PollingBlockTracker_isRunning, true, "f");
-    // cancel setting latest block to stale
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_cancelBlockResetTimeout).call(this);
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_start).call(this);
-    this.emit('_started');
-}, _PollingBlockTracker_maybeEnd = function _PollingBlockTracker_maybeEnd() {
-    if (!__classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f")) {
-        return;
+    _maybeStart() {
+        if (this._isRunning) {
+            return;
+        }
+        this._isRunning = true;
+        // cancel setting latest block to stale
+        this._cancelBlockResetTimeout();
+        this._start();
+        this.emit('_started');
     }
-    __classPrivateFieldSet(this, _PollingBlockTracker_isRunning, false, "f");
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_setupBlockResetTimeout).call(this);
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_end).call(this);
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_rejectPendingLatestBlock).call(this, new Error('Block tracker destroyed'));
-    this.emit('_ended');
-}, _PollingBlockTracker_getBlockTrackerEventCount = function _PollingBlockTracker_getBlockTrackerEventCount() {
-    return (blockTrackerEvents
-        .map((eventName) => this.listeners(eventName))
-        .flat()
-        // internal listeners are not included in the count
-        .filter((listener) => __classPrivateFieldGet(this, _PollingBlockTracker_internalEventListeners, "f").every((internalListener) => !Object.is(internalListener, listener))).length);
-}, _PollingBlockTracker_shouldUseNewBlock = function _PollingBlockTracker_shouldUseNewBlock(newBlock) {
-    const currentBlock = __classPrivateFieldGet(this, _PollingBlockTracker_currentBlock, "f");
-    if (!currentBlock) {
-        return true;
+    _maybeEnd() {
+        if (!this._isRunning) {
+            return;
+        }
+        this._isRunning = false;
+        this._setupBlockResetTimeout();
+        this._end();
+        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_rejectPendingLatestBlock).call(this, new Error('Block tracker destroyed'));
+        this.emit('_ended');
     }
-    const newBlockInt = hexToInt(newBlock);
-    const currentBlockInt = hexToInt(currentBlock);
-    return ((__classPrivateFieldGet(this, _PollingBlockTracker_usePastBlocks, "f") && newBlockInt < currentBlockInt) ||
-        newBlockInt > currentBlockInt);
-}, _PollingBlockTracker_newPotentialLatest = function _PollingBlockTracker_newPotentialLatest(newBlock) {
-    if (!__classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_shouldUseNewBlock).call(this, newBlock)) {
-        return;
+    _getBlockTrackerEventCount() {
+        return (blockTrackerEvents
+            .map((eventName) => this.listeners(eventName))
+            .flat()
+            // internal listeners are not included in the count
+            .filter((listener) => __classPrivateFieldGet(this, _PollingBlockTracker_internalEventListeners, "f").every((internalListener) => !Object.is(internalListener, listener))).length);
     }
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_setCurrentBlock).call(this, newBlock);
-}, _PollingBlockTracker_setCurrentBlock = function _PollingBlockTracker_setCurrentBlock(newBlock) {
-    const oldBlock = __classPrivateFieldGet(this, _PollingBlockTracker_currentBlock, "f");
-    __classPrivateFieldSet(this, _PollingBlockTracker_currentBlock, newBlock, "f");
-    this.emit('latest', newBlock);
-    this.emit('sync', { oldBlock, newBlock });
-}, _PollingBlockTracker_setupBlockResetTimeout = function _PollingBlockTracker_setupBlockResetTimeout() {
-    // clear any existing timeout
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_cancelBlockResetTimeout).call(this);
-    // clear latest block when stale
-    __classPrivateFieldSet(this, _PollingBlockTracker_blockResetTimeout, setTimeout(__classPrivateFieldGet(this, _PollingBlockTracker_resetCurrentBlock, "f"), __classPrivateFieldGet(this, _PollingBlockTracker_blockResetDuration, "f")), "f");
-    // nodejs - dont hold process open
-    if (__classPrivateFieldGet(this, _PollingBlockTracker_blockResetTimeout, "f").unref) {
-        __classPrivateFieldGet(this, _PollingBlockTracker_blockResetTimeout, "f").unref();
+    _shouldUseNewBlock(newBlock) {
+        const currentBlock = this._currentBlock;
+        if (!currentBlock) {
+            return true;
+        }
+        const newBlockInt = hexToInt(newBlock);
+        const currentBlockInt = hexToInt(currentBlock);
+        return ((this._usePastBlocks && newBlockInt < currentBlockInt) ||
+            newBlockInt > currentBlockInt);
     }
-}, _PollingBlockTracker_cancelBlockResetTimeout = function _PollingBlockTracker_cancelBlockResetTimeout() {
-    if (__classPrivateFieldGet(this, _PollingBlockTracker_blockResetTimeout, "f")) {
-        clearTimeout(__classPrivateFieldGet(this, _PollingBlockTracker_blockResetTimeout, "f"));
+    _newPotentialLatest(newBlock) {
+        if (!this._shouldUseNewBlock(newBlock)) {
+            return;
+        }
+        this._setCurrentBlock(newBlock);
     }
-}, _PollingBlockTracker_resetCurrentBlockUnbound = function _PollingBlockTracker_resetCurrentBlockUnbound() {
-    __classPrivateFieldSet(this, _PollingBlockTracker_currentBlock, null, "f");
-}, _PollingBlockTracker_start = function _PollingBlockTracker_start() {
-    // Intentionally not awaited as this starts the polling via a timeout chain.
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_updateAndQueue).call(this);
-}, _PollingBlockTracker_end = function _PollingBlockTracker_end() {
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_clearPollingTimeout).call(this);
-}, _PollingBlockTracker_updateLatestBlock = async function _PollingBlockTracker_updateLatestBlock() {
-    // fetch + set latest block
-    const latestBlock = await __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_fetchLatestBlock).call(this);
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_newPotentialLatest).call(this, latestBlock);
-    if (!__classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f")) {
-        // Ensure the one-time update is eventually reset once it's stale
-        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_setupBlockResetTimeout).call(this);
+    _setCurrentBlock(newBlock) {
+        const oldBlock = this._currentBlock;
+        this._currentBlock = newBlock;
+        this.emit('latest', newBlock);
+        this.emit('sync', { oldBlock, newBlock });
     }
-    // _newPotentialLatest() ensures that this._currentBlock is not null
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return __classPrivateFieldGet(this, _PollingBlockTracker_currentBlock, "f");
-}, _PollingBlockTracker_fetchLatestBlock = async function _PollingBlockTracker_fetchLatestBlock() {
-    // If there's already a pending fetch, reuse it
-    if (__classPrivateFieldGet(this, _PollingBlockTracker_pendingFetch, "f")) {
-        return await __classPrivateFieldGet(this, _PollingBlockTracker_pendingFetch, "f").promise;
+    _setupBlockResetTimeout() {
+        // clear any existing timeout
+        this._cancelBlockResetTimeout();
+        // clear latest block when stale
+        this._blockResetTimeout = setTimeout(this._resetCurrentBlock, this._blockResetDuration);
+        // nodejs - dont hold process open
+        if (this._blockResetTimeout.unref) {
+            this._blockResetTimeout.unref();
+        }
     }
-    // Create a new deferred promise for this request
-    const { promise, resolve, reject } = (0, utils_1.createDeferredPromise)({
-        suppressUnhandledRejection: true,
-    });
-    __classPrivateFieldSet(this, _PollingBlockTracker_pendingFetch, { reject, promise }, "f");
-    try {
-        const req = {
-            jsonrpc: '2.0',
-            id: createRandomId(),
-            method: 'eth_blockNumber',
-            params: [],
-        };
-        if (__classPrivateFieldGet(this, _PollingBlockTracker_setSkipCacheFlag, "f")) {
-            req.skipCache = true;
+    _cancelBlockResetTimeout() {
+        if (this._blockResetTimeout) {
+            clearTimeout(this._blockResetTimeout);
         }
-        log('Making request', req);
-        const result = await __classPrivateFieldGet(this, _PollingBlockTracker_provider, "f").request(req);
-        log('Got result', result);
-        resolve(result);
-        return result;
     }
-    catch (error) {
-        log('Encountered error fetching block', (0, utils_1.getErrorMessage)(error));
-        reject(error);
-        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_rejectPendingLatestBlock).call(this, error);
-        throw error;
+    _resetCurrentBlock() {
+        this._currentBlock = null;
     }
-    finally {
-        __classPrivateFieldSet(this, _PollingBlockTracker_pendingFetch, undefined, "f");
+    /**
+     * Checks for the latest block, updates the internal state,  and returns the
+     * value immediately rather than waiting for the next polling interval.
+     *
+     * @deprecated Use {@link getLatestBlock} instead.
+     * @returns A promise that resolves to the latest block number.
+     */
+    async checkForLatestBlock() {
+        await this._updateLatestBlock();
+        return await this.getLatestBlock();
     }
-}, _PollingBlockTracker_updateAndQueue = 
-/**
- * The core polling function that runs after each interval.
- * Updates the latest block and then queues the next update.
- */
-async function _PollingBlockTracker_updateAndQueue() {
-    let interval = __classPrivateFieldGet(this, _PollingBlockTracker_pollingInterval, "f");
-    try {
-        await __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_updateLatestBlock).call(this);
+    _start() {
+        // Intentionally not awaited as this starts the polling via a timeout chain.
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        this._updateAndQueue();
     }
-    catch (error) {
+    _end() {
+        this._clearPollingTimeout();
+    }
+    async _updateLatestBlock() {
+        // fetch + set latest block
+        const latestBlock = await this._fetchLatestBlock();
+        this._newPotentialLatest(latestBlock);
+        if (!this._isRunning) {
+            // Ensure the one-time update is eventually reset once it's stale
+            this._setupBlockResetTimeout();
+        }
+        // _newPotentialLatest() ensures that this._currentBlock is not null
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this._currentBlock;
+    }
+    async _fetchLatestBlock() {
+        // If there's already a pending fetch, reuse it
+        if (__classPrivateFieldGet(this, _PollingBlockTracker_pendingFetch, "f")) {
+            return await __classPrivateFieldGet(this, _PollingBlockTracker_pendingFetch, "f").promise;
+        }
+        // Create a new deferred promise for this request
+        const { promise, resolve, reject } = (0, utils_1.createDeferredPromise)({
+            suppressUnhandledRejection: true,
+        });
+        __classPrivateFieldSet(this, _PollingBlockTracker_pendingFetch, { reject, promise }, "f");
         try {
-            this.emit('error', error);
+            const req = {
+                jsonrpc: '2.0',
+                id: createRandomId(),
+                method: 'eth_blockNumber',
+                params: [],
+            };
+            if (this._setSkipCacheFlag) {
+                req.skipCache = true;
+            }
+            log('Making request', req);
+            const result = await this._provider.request(req);
+            log('Got result', result);
+            resolve(result);
+            return result;
         }
-        catch {
-            console.error(`Error updating latest block: ${(0, utils_1.getErrorMessage)(error)}`);
+        catch (error) {
+            log('Encountered error fetching block', (0, utils_1.getErrorMessage)(error));
+            reject(error);
+            __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_rejectPendingLatestBlock).call(this, error);
+            throw error;
+        }
+        finally {
+            __classPrivateFieldSet(this, _PollingBlockTracker_pendingFetch, undefined, "f");
         }
-        interval = __classPrivateFieldGet(this, _PollingBlockTracker_retryTimeout, "f");
-    }
-    if (!__classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f")) {
-        return;
     }
-    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_clearPollingTimeout).call(this);
-    const timeoutRef = setTimeout(() => {
-        // Intentionally not awaited as this just continues the polling loop.
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_updateAndQueue).call(this);
-    }, interval);
-    if (timeoutRef.unref && !__classPrivateFieldGet(this, _PollingBlockTracker_keepEventLoopActive, "f")) {
-        timeoutRef.unref();
+    /**
+     * The core polling function that runs after each interval.
+     * Updates the latest block and then queues the next update.
+     */
+    async _updateAndQueue() {
+        let interval = this._pollingInterval;
+        try {
+            await this._updateLatestBlock();
+        }
+        catch (error) {
+            try {
+                this.emit('error', error);
+            }
+            catch {
+                console.error(`Error updating latest block: ${(0, utils_1.getErrorMessage)(error)}`);
+            }
+            interval = this._retryTimeout;
+        }
+        if (!this._isRunning) {
+            return;
+        }
+        this._clearPollingTimeout();
+        const timeoutRef = setTimeout(() => {
+            // Intentionally not awaited as this just continues the polling loop.
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this._updateAndQueue();
+        }, interval);
+        if (timeoutRef.unref && !this._keepEventLoopActive) {
+            timeoutRef.unref();
+        }
+        this._pollingTimeout = timeoutRef;
+        this.emit('_waitingForNextIteration');
     }
-    __classPrivateFieldSet(this, _PollingBlockTracker_pollingTimeout, timeoutRef, "f");
-    this.emit('_waitingForNextIteration');
-}, _PollingBlockTracker_clearPollingTimeout = function _PollingBlockTracker_clearPollingTimeout() {
-    if (__classPrivateFieldGet(this, _PollingBlockTracker_pollingTimeout, "f")) {
-        clearTimeout(__classPrivateFieldGet(this, _PollingBlockTracker_pollingTimeout, "f"));
-        __classPrivateFieldSet(this, _PollingBlockTracker_pollingTimeout, undefined, "f");
+    _clearPollingTimeout() {
+        if (this._pollingTimeout) {
+            clearTimeout(this._pollingTimeout);
+            this._pollingTimeout = undefined;
+        }
     }
-}, _PollingBlockTracker_addInternalListener = function _PollingBlockTracker_addInternalListener(listener) {
+}
+exports.PollingBlockTracker = PollingBlockTracker;
+_PollingBlockTracker_internalEventListeners = new WeakMap(), _PollingBlockTracker_pendingLatestBlock = new WeakMap(), _PollingBlockTracker_pendingFetch = new WeakMap(), _PollingBlockTracker_instances = new WeakSet(), _PollingBlockTracker_addInternalListener = function _PollingBlockTracker_addInternalListener(listener) {
     __classPrivateFieldGet(this, _PollingBlockTracker_internalEventListeners, "f").push(listener);
 }, _PollingBlockTracker_removeInternalListener = function _PollingBlockTracker_removeInternalListener(listener) {
     __classPrivateFieldGet(this, _PollingBlockTracker_internalEventListeners, "f").splice(__classPrivateFieldGet(this, _PollingBlockTracker_internalEventListeners, "f").indexOf(listener), 1);