@metamask-previews/eth-block-tracker 15.0.0-preview-565dfca2 → 15.0.0-preview-c208c1a

package/dist/PollingBlockTracker.d.cts

@@ -13,17 +13,6 @@ export type PollingBlockTrackerOptions<Context extends ContextConstraint = Middl
 };
 export declare class PollingBlockTracker<Context extends ContextConstraint = MiddlewareContext> extends SafeEventEmitter implements BlockTracker {
     #private;
-    private _isRunning;
-    private readonly _blockResetDuration;
-    private readonly _usePastBlocks;
-    private _currentBlock;
-    private _blockResetTimeout?;
-    private _pollingTimeout?;
-    private readonly _provider;
-    private readonly _pollingInterval;
-    private readonly _retryTimeout;
-    private readonly _keepEventLoopActive;
-    private readonly _setSkipCacheFlag;
     constructor(opts?: PollingBlockTrackerOptions<Context>);
     destroy(): Promise<void>;
     isRunning(): boolean;
@@ -32,18 +21,6 @@ export declare class PollingBlockTracker<Context extends ContextConstraint = Mid
         useCache?: boolean;
     }): Promise<string>;
     removeAllListeners(eventName?: string | symbol): this;
-    private _setupInternalEvents;
-    private _onNewListener;
-    private _onRemoveListener;
-    private _maybeStart;
-    private _maybeEnd;
-    private _getBlockTrackerEventCount;
-    private _shouldUseNewBlock;
-    private _newPotentialLatest;
-    private _setCurrentBlock;
-    private _setupBlockResetTimeout;
-    private _cancelBlockResetTimeout;
-    private _resetCurrentBlock;
     /**
      * Checks for the latest block, updates the internal state,  and returns the
      * value immediately rather than waiting for the next polling interval.
@@ -52,15 +29,5 @@ export declare class PollingBlockTracker<Context extends ContextConstraint = Mid
      * @returns A promise that resolves to the latest block number.
      */
     checkForLatestBlock(): Promise<string>;
-    private _start;
-    private _end;
-    private _updateLatestBlock;
-    private _fetchLatestBlock;
-    /**
-     * The core polling function that runs after each interval.
-     * Updates the latest block and then queues the next update.
-     */
-    private _updateAndQueue;
-    _clearPollingTimeout(): void;
 }
 //# sourceMappingURL=PollingBlockTracker.d.cts.map

package/dist/PollingBlockTracker.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"PollingBlockTracker.d.cts","sourceRoot":"","sources":["../src/PollingBlockTracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,wCAAwC;AACxE,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EAClB,qCAAqC;AACtC,OAAO,gBAAgB,qCAAqC;AAK5D,OAAO,KAAK,EAAE,YAAY,EAAE,2BAAuB;AASnD,MAAM,MAAM,0BAA0B,CACpC,OAAO,SAAS,iBAAiB,GAAG,iBAAiB,IACnD;IACF,QAAQ,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACrC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAQF,qBAAa,mBAAmB,CAC5B,OAAO,SAAS,iBAAiB,GAAG,iBAAiB,CAEvD,SAAQ,gBACR,YAAW,YAAY;;IAEvB,OAAO,CAAC,UAAU,CAAU;IAE5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAE7C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IAEzC,OAAO,CAAC,aAAa,CAAgB;IAErC,OAAO,CAAC,kBAAkB,CAAC,CAAgC;IAE3D,OAAO,CAAC,eAAe,CAAC,CAAgC;IAExD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA4B;IAEtD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAE1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAU;IAE/C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAU;gBAQhC,IAAI,GAAE,0BAA0B,CAAC,OAAO,CAAM;IAgCpD,OAAO;IAMb,SAAS,IAAI,OAAO;IAIpB,eAAe,IAAI,MAAM,GAAG,IAAI;IAI1B,cAAc,CAAC,EACnB,QAAe,GAChB,GAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAuDhD,kBAAkB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAgB9C,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,0BAA0B;IAclC,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,uBAAuB;IAe/B,OAAO,CAAC,wBAAwB;IAMhC,OAAO,CAAC,kBAAkB;IAI1B;;;;;;OAMG;IACG,mBAAmB;IAKzB,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,IAAI;YAIE,kBAAkB;YAelB,iBAAiB;IAsC/B;;;OAGG;YACW,eAAe;IAoC7B,oBAAoB;CAsBrB"}
+{"version":3,"file":"PollingBlockTracker.d.cts","sourceRoot":"","sources":["../src/PollingBlockTracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,wCAAwC;AACxE,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EAClB,qCAAqC;AACtC,OAAO,gBAAgB,qCAAqC;AAK5D,OAAO,KAAK,EAAE,YAAY,EAAE,2BAAuB;AASnD,MAAM,MAAM,0BAA0B,CACpC,OAAO,SAAS,iBAAiB,GAAG,iBAAiB,IACnD;IACF,QAAQ,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACrC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAQF,qBAAa,mBAAmB,CAC5B,OAAO,SAAS,iBAAiB,GAAG,iBAAiB,CAEvD,SAAQ,gBACR,YAAW,YAAY;;gBAoCX,IAAI,GAAE,0BAA0B,CAAC,OAAO,CAAM;IA+BpD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM9B,SAAS,IAAI,OAAO;IAIpB,eAAe,IAAI,MAAM,GAAG,IAAI;IAI1B,cAAc,CAAC,EACnB,QAAe,GAChB,GAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAuDhD,kBAAkB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAoIrD;;;;;;OAMG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;CAkI7C"}

package/dist/PollingBlockTracker.d.mts

@@ -13,17 +13,6 @@ export type PollingBlockTrackerOptions<Context extends ContextConstraint = Middl
 };
 export declare class PollingBlockTracker<Context extends ContextConstraint = MiddlewareContext> extends SafeEventEmitter implements BlockTracker {
     #private;
-    private _isRunning;
-    private readonly _blockResetDuration;
-    private readonly _usePastBlocks;
-    private _currentBlock;
-    private _blockResetTimeout?;
-    private _pollingTimeout?;
-    private readonly _provider;
-    private readonly _pollingInterval;
-    private readonly _retryTimeout;
-    private readonly _keepEventLoopActive;
-    private readonly _setSkipCacheFlag;
     constructor(opts?: PollingBlockTrackerOptions<Context>);
     destroy(): Promise<void>;
     isRunning(): boolean;
@@ -32,18 +21,6 @@ export declare class PollingBlockTracker<Context extends ContextConstraint = Mid
         useCache?: boolean;
     }): Promise<string>;
     removeAllListeners(eventName?: string | symbol): this;
-    private _setupInternalEvents;
-    private _onNewListener;
-    private _onRemoveListener;
-    private _maybeStart;
-    private _maybeEnd;
-    private _getBlockTrackerEventCount;
-    private _shouldUseNewBlock;
-    private _newPotentialLatest;
-    private _setCurrentBlock;
-    private _setupBlockResetTimeout;
-    private _cancelBlockResetTimeout;
-    private _resetCurrentBlock;
     /**
      * Checks for the latest block, updates the internal state,  and returns the
      * value immediately rather than waiting for the next polling interval.
@@ -52,15 +29,5 @@ export declare class PollingBlockTracker<Context extends ContextConstraint = Mid
      * @returns A promise that resolves to the latest block number.
      */
     checkForLatestBlock(): Promise<string>;
-    private _start;
-    private _end;
-    private _updateLatestBlock;
-    private _fetchLatestBlock;
-    /**
-     * The core polling function that runs after each interval.
-     * Updates the latest block and then queues the next update.
-     */
-    private _updateAndQueue;
-    _clearPollingTimeout(): void;
 }
 //# sourceMappingURL=PollingBlockTracker.d.mts.map

package/dist/PollingBlockTracker.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"PollingBlockTracker.d.mts","sourceRoot":"","sources":["../src/PollingBlockTracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,wCAAwC;AACxE,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EAClB,qCAAqC;AACtC,OAAO,gBAAgB,qCAAqC;AAK5D,OAAO,KAAK,EAAE,YAAY,EAAE,2BAAuB;AASnD,MAAM,MAAM,0BAA0B,CACpC,OAAO,SAAS,iBAAiB,GAAG,iBAAiB,IACnD;IACF,QAAQ,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACrC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAQF,qBAAa,mBAAmB,CAC5B,OAAO,SAAS,iBAAiB,GAAG,iBAAiB,CAEvD,SAAQ,gBACR,YAAW,YAAY;;IAEvB,OAAO,CAAC,UAAU,CAAU;IAE5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAE7C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IAEzC,OAAO,CAAC,aAAa,CAAgB;IAErC,OAAO,CAAC,kBAAkB,CAAC,CAAgC;IAE3D,OAAO,CAAC,eAAe,CAAC,CAAgC;IAExD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA4B;IAEtD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAE1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAU;IAE/C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAU;gBAQhC,IAAI,GAAE,0BAA0B,CAAC,OAAO,CAAM;IAgCpD,OAAO;IAMb,SAAS,IAAI,OAAO;IAIpB,eAAe,IAAI,MAAM,GAAG,IAAI;IAI1B,cAAc,CAAC,EACnB,QAAe,GAChB,GAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAuDhD,kBAAkB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAgB9C,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,0BAA0B;IAclC,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,uBAAuB;IAe/B,OAAO,CAAC,wBAAwB;IAMhC,OAAO,CAAC,kBAAkB;IAI1B;;;;;;OAMG;IACG,mBAAmB;IAKzB,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,IAAI;YAIE,kBAAkB;YAelB,iBAAiB;IAsC/B;;;OAGG;YACW,eAAe;IAoC7B,oBAAoB;CAsBrB"}
+{"version":3,"file":"PollingBlockTracker.d.mts","sourceRoot":"","sources":["../src/PollingBlockTracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,wCAAwC;AACxE,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EAClB,qCAAqC;AACtC,OAAO,gBAAgB,qCAAqC;AAK5D,OAAO,KAAK,EAAE,YAAY,EAAE,2BAAuB;AASnD,MAAM,MAAM,0BAA0B,CACpC,OAAO,SAAS,iBAAiB,GAAG,iBAAiB,IACnD;IACF,QAAQ,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACrC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAQF,qBAAa,mBAAmB,CAC5B,OAAO,SAAS,iBAAiB,GAAG,iBAAiB,CAEvD,SAAQ,gBACR,YAAW,YAAY;;gBAoCX,IAAI,GAAE,0BAA0B,CAAC,OAAO,CAAM;IA+BpD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM9B,SAAS,IAAI,OAAO;IAIpB,eAAe,IAAI,MAAM,GAAG,IAAI;IAI1B,cAAc,CAAC,EACnB,QAAe,GAChB,GAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAuDhD,kBAAkB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAoIrD;;;;;;OAMG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;CAkI7C"}

package/dist/PollingBlockTracker.mjs

@@ -1,15 +1,15 @@
-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 _PollingBlockTracker_instances, _PollingBlockTracker_internalEventListeners, _PollingBlockTracker_pendingLatestBlock, _PollingBlockTracker_pendingFetch, _PollingBlockTracker_addInternalListener, _PollingBlockTracker_removeInternalListener, _PollingBlockTracker_rejectPendingLatestBlock;
+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 _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;
 function $importDefault(module) {
     if (module?.__esModule) {
         return module.default;
@@ -33,44 +33,57 @@ export class PollingBlockTracker extends SafeEventEmitter {
         }
         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
-        this._blockResetDuration = opts.blockResetDuration || 20 * sec;
-        this._usePastBlocks = opts.usePastBlocks || false;
+        __classPrivateFieldSet(this, _PollingBlockTracker_blockResetDuration, opts.blockResetDuration ?? 20 * sec, "f");
+        __classPrivateFieldSet(this, _PollingBlockTracker_usePastBlocks, opts.usePastBlocks ?? false, "f");
         // state
-        this._currentBlock = null;
-        this._isRunning = false;
+        __classPrivateFieldSet(this, _PollingBlockTracker_currentBlock, null, "f");
+        __classPrivateFieldSet(this, _PollingBlockTracker_isRunning, false, "f");
         // bind functions for internal use
-        this._onNewListener = this._onNewListener.bind(this);
-        this._onRemoveListener = this._onRemoveListener.bind(this);
-        this._resetCurrentBlock = this._resetCurrentBlock.bind(this);
+        __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");
         // listen for handler changes
-        this._setupInternalEvents();
+        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_setupInternalEvents).call(this);
         // config
-        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;
+        __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");
     }
     async destroy() {
-        this._cancelBlockResetTimeout();
+        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_cancelBlockResetTimeout).call(this);
         super.removeAllListeners();
-        this._maybeEnd();
+        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_maybeEnd).call(this);
     }
     isRunning() {
-        return this._isRunning;
+        return __classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f");
     }
     getCurrentBlock() {
-        return this._currentBlock;
+        return __classPrivateFieldGet(this, _PollingBlockTracker_currentBlock, "f");
     }
     async getLatestBlock({ useCache = true, } = {}) {
         // return if available
-        if (this._currentBlock && useCache) {
-            return this._currentBlock;
+        if (__classPrivateFieldGet(this, _PollingBlockTracker_currentBlock, "f") && useCache) {
+            return __classPrivateFieldGet(this, _PollingBlockTracker_currentBlock, "f");
         }
         if (__classPrivateFieldGet(this, _PollingBlockTracker_pendingLatestBlock, "f")) {
             return await __classPrivateFieldGet(this, _PollingBlockTracker_pendingLatestBlock, "f").promise;
@@ -79,7 +92,7 @@ export class PollingBlockTracker extends SafeEventEmitter {
             suppressUnhandledRejection: true,
         });
         __classPrivateFieldSet(this, _PollingBlockTracker_pendingLatestBlock, { reject, promise }, "f");
-        if (this._isRunning) {
+        if (__classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f")) {
             try {
                 // If tracker is running, wait for next block with timeout
                 const onLatestBlock = (value) => {
@@ -102,7 +115,7 @@ export class PollingBlockTracker extends SafeEventEmitter {
         else {
             // If tracker isn't running, just fetch directly
             try {
-                const latestBlock = await this._updateLatestBlock();
+                const latestBlock = await __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_updateLatestBlock).call(this);
                 resolve(latestBlock);
                 return latestBlock;
             }
@@ -116,11 +129,11 @@ export class PollingBlockTracker extends SafeEventEmitter {
                 // achieve this by delaying the unsetting of the #pendingLatestBlock promise.
                 setTimeout(() => {
                     __classPrivateFieldSet(this, _PollingBlockTracker_pendingLatestBlock, undefined, "f");
-                }, this._pollingInterval);
+                }, __classPrivateFieldGet(this, _PollingBlockTracker_pollingInterval, "f"));
             }
         }
     }
-    // dont allow module consumer to remove our internal event listeners
+    // Don't allow module consumer to remove our internal event listeners.
     removeAllListeners(eventName) {
         // perform default behavior, preserve fn arity
         if (eventName) {
@@ -130,208 +143,191 @@ export class PollingBlockTracker extends SafeEventEmitter {
             super.removeAllListeners();
         }
         // re-add internal events
-        this._setupInternalEvents();
+        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_setupInternalEvents).call(this);
         // trigger stop check just in case
-        this._onRemoveListener();
+        __classPrivateFieldGet(this, _PollingBlockTracker_onRemoveListener, "f").call(this);
         return 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);
-    }
-    _onNewListener(eventName) {
-        // `newListener` is called *before* the listener is added
-        if (blockTrackerEvents.includes(eventName)) {
-            // TODO: Handle dangling promise
-            this._maybeStart();
-        }
+    /**
+     * 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();
     }
-    _onRemoveListener() {
-        // `removeListener` is called *after* the listener is removed
-        if (this._getBlockTrackerEventCount() > 0) {
-            return;
-        }
-        this._maybeEnd();
+}
+_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);
     }
-    _maybeStart() {
-        if (this._isRunning) {
-            return;
-        }
-        this._isRunning = true;
-        // cancel setting latest block to stale
-        this._cancelBlockResetTimeout();
-        this._start();
-        this.emit('_started');
+}, _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;
     }
-    _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');
+    __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_maybeEnd).call(this);
+}, _PollingBlockTracker_maybeStart = function _PollingBlockTracker_maybeStart() {
+    if (__classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f")) {
+        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);
+    __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;
     }
-    _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);
+    __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;
     }
-    _newPotentialLatest(newBlock) {
-        if (!this._shouldUseNewBlock(newBlock)) {
-            return;
-        }
-        this._setCurrentBlock(newBlock);
+    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;
     }
-    _setCurrentBlock(newBlock) {
-        const oldBlock = this._currentBlock;
-        this._currentBlock = newBlock;
-        this.emit('latest', newBlock);
-        this.emit('sync', { oldBlock, newBlock });
+    __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();
     }
-    _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();
-        }
+}, _PollingBlockTracker_cancelBlockResetTimeout = function _PollingBlockTracker_cancelBlockResetTimeout() {
+    if (__classPrivateFieldGet(this, _PollingBlockTracker_blockResetTimeout, "f")) {
+        clearTimeout(__classPrivateFieldGet(this, _PollingBlockTracker_blockResetTimeout, "f"));
     }
-    _cancelBlockResetTimeout() {
-        if (this._blockResetTimeout) {
-            clearTimeout(this._blockResetTimeout);
-        }
+}, _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);
     }
-    _resetCurrentBlock() {
-        this._currentBlock = null;
+    // _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;
     }
-    /**
-     * 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();
+    // Create a new deferred promise for this request
+    const { promise, resolve, reject } = 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;
+        }
+        log('Making request', req);
+        const result = await __classPrivateFieldGet(this, _PollingBlockTracker_provider, "f").request(req);
+        log('Got result', result);
+        resolve(result);
+        return result;
     }
-    _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) {
+        log('Encountered error fetching block', getErrorMessage(error));
+        reject(error);
+        __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_rejectPendingLatestBlock).call(this, error);
+        throw error;
     }
-    _end() {
-        this._clearPollingTimeout();
+    finally {
+        __classPrivateFieldSet(this, _PollingBlockTracker_pendingFetch, undefined, "f");
     }
-    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;
+}, _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);
     }
-    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 } = createDeferredPromise({
-            suppressUnhandledRejection: true,
-        });
-        __classPrivateFieldSet(this, _PollingBlockTracker_pendingFetch, { reject, promise }, "f");
+    catch (error) {
         try {
-            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;
+            this.emit('error', error);
         }
-        catch (error) {
-            log('Encountered error fetching block', getErrorMessage(error));
-            reject(error);
-            __classPrivateFieldGet(this, _PollingBlockTracker_instances, "m", _PollingBlockTracker_rejectPendingLatestBlock).call(this, error);
-            throw error;
-        }
-        finally {
-            __classPrivateFieldSet(this, _PollingBlockTracker_pendingFetch, undefined, "f");
+        catch {
+            console.error(`Error updating latest block: ${getErrorMessage(error)}`);
         }
+        interval = __classPrivateFieldGet(this, _PollingBlockTracker_retryTimeout, "f");
     }
-    /**
-     * 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: ${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');
+    if (!__classPrivateFieldGet(this, _PollingBlockTracker_isRunning, "f")) {
+        return;
     }
-    _clearPollingTimeout() {
-        if (this._pollingTimeout) {
-            clearTimeout(this._pollingTimeout);
-            this._pollingTimeout = undefined;
-        }
+    __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();
     }
-}
-_PollingBlockTracker_internalEventListeners = new WeakMap(), _PollingBlockTracker_pendingLatestBlock = new WeakMap(), _PollingBlockTracker_pendingFetch = new WeakMap(), _PollingBlockTracker_instances = new WeakSet(), _PollingBlockTracker_addInternalListener = function _PollingBlockTracker_addInternalListener(listener) {
+    __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");
+    }
+}, _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);