@across-protocol/sdk 4.3.111-alpha.3 → 4.3.111

package/dist/esm/clients/SpokePoolClient/SpokePoolClient.js

@@ -1,10 +1,11 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
 import { utils as ethersUtils } from "ethers";
 import { bnZero, EvmAddress, MAX_BIG_INT, assign, getRelayEventKey, isDefined, isSlowFill, validateFillForDeposit, chainIsEvm, chainIsProd, toAddressType, unpackDepositEvent, unpackFillEvent, } from "../../utils";
 import { duplicateEvent, sortEventsAscendingInPlace } from "../../utils/EventUtils";
 import { CHAIN_IDs, ZERO_ADDRESS } from "../../constants";
 import { BaseAbstractClient } from "../BaseAbstractClient";
 import { getRefundInformationFromFill } from "../BundleDataClient";
-export const knownEventNames = [
+export var knownEventNames = [
     "EnabledDepositRoute",
     "TokensBridged",
     "RelayedRootBundle",
@@ -24,27 +25,8 @@ export const knownEventNames = [
  * SpokePoolClient is a client for the SpokePool contract. It is responsible for querying the SpokePool contract
  * for events and storing them in memory. It also provides some convenience methods for querying the stored events.
  */
-export class SpokePoolClient extends BaseAbstractClient {
-    logger;
-    hubPoolClient;
-    chainId;
-    deploymentBlock;
-    currentTime = 0;
-    duplicateDepositHashes = {};
-    depositHashesToFills = {};
-    speedUps = {};
-    slowFillRequests = {};
-    depositRoutes = {};
-    tokensBridged = [];
-    rootBundleRelays = [];
-    relayerRefundExecutions = [];
-    claimedRelayerRefunds = [];
-    bridgedToHubPool = [];
-    configStoreClient;
-    invalidFills = new Set();
-    depositHashes = {};
-    spokePoolAddress;
-    fills = {};
+var SpokePoolClient = /** @class */ (function (_super) {
+    __extends(SpokePoolClient, _super);
     /**
      * Creates a new SpokePoolClient.
      * @param logger A logger instance.
@@ -53,26 +35,42 @@ export class SpokePoolClient extends BaseAbstractClient {
      * @param deploymentBlock The block number that the SpokePool contract was deployed at.
      * @param eventSearchConfig An optional EventSearchConfig object that controls how far back in history the client will search for events. If not provided, the client will only search for events from the deployment block.
      */
-    constructor(logger, 
+    function SpokePoolClient(logger, 
     // Can be excluded. This disables some deposit validation.
-    hubPoolClient, chainId, deploymentBlock, eventSearchConfig = { from: 0, maxLookBack: 0 }) {
-        super(eventSearchConfig);
-        this.logger = logger;
-        this.hubPoolClient = hubPoolClient;
-        this.chainId = chainId;
-        this.deploymentBlock = deploymentBlock;
-        this.firstHeightToSearch = eventSearchConfig.from;
-        this.latestHeightSearched = 0;
-        this.configStoreClient = hubPoolClient?.configStoreClient;
+    hubPoolClient, chainId, deploymentBlock, eventSearchConfig) {
+        if (eventSearchConfig === void 0) { eventSearchConfig = { from: 0, maxLookBack: 0 }; }
+        var _this = _super.call(this, eventSearchConfig) || this;
+        _this.logger = logger;
+        _this.hubPoolClient = hubPoolClient;
+        _this.chainId = chainId;
+        _this.deploymentBlock = deploymentBlock;
+        _this.currentTime = 0;
+        _this.duplicateDepositHashes = {};
+        _this.depositHashesToFills = {};
+        _this.speedUps = {};
+        _this.slowFillRequests = {};
+        _this.depositRoutes = {};
+        _this.tokensBridged = [];
+        _this.rootBundleRelays = [];
+        _this.relayerRefundExecutions = [];
+        _this.claimedRelayerRefunds = [];
+        _this.bridgedToHubPool = [];
+        _this.invalidFills = new Set();
+        _this.depositHashes = {};
+        _this.fills = {};
+        _this.firstHeightToSearch = eventSearchConfig.from;
+        _this.latestHeightSearched = 0;
+        _this.configStoreClient = hubPoolClient === null || hubPoolClient === void 0 ? void 0 : hubPoolClient.configStoreClient;
+        return _this;
     }
     /**
      * Retrieves a list of unique deposits from the SpokePool contract destined for the given destination chain ID.
      * @param destinationChainId The destination chain ID.
      * @returns A list of deposits.
      */
-    getDepositsForDestinationChain(destinationChainId) {
-        return Object.values(this.depositHashes).filter((deposit) => deposit.destinationChainId === destinationChainId);
-    }
+    SpokePoolClient.prototype.getDepositsForDestinationChain = function (destinationChainId) {
+        return Object.values(this.depositHashes).filter(function (deposit) { return deposit.destinationChainId === destinationChainId; });
+    };
     /**
      * Retrieves a list of duplicate deposits matching the given deposit's deposit hash.
      * @notice A duplicate is considered any deposit sent after the original deposit with the same deposit hash.
@@ -80,10 +78,11 @@ export class SpokePoolClient extends BaseAbstractClient {
      * @returns A list of duplicate deposits. Does NOT include the original deposit
      * unless the original deposit is a duplicate.
      */
-    _getDuplicateDeposits(deposit) {
-        const depositHash = getRelayEventKey(deposit);
-        return this.duplicateDepositHashes[depositHash] ?? [];
-    }
+    SpokePoolClient.prototype._getDuplicateDeposits = function (deposit) {
+        var _a;
+        var depositHash = getRelayEventKey(deposit);
+        return (_a = this.duplicateDepositHashes[depositHash]) !== null && _a !== void 0 ? _a : [];
+    };
     /**
      * Returns a list of all deposits including any duplicate ones. Designed only to be used in use cases where
      * all deposits are required, regardless of duplicates. For example, the Dataworker can use this to refund
@@ -91,197 +90,204 @@ export class SpokePoolClient extends BaseAbstractClient {
      * @param destinationChainId
      * @returns A list of deposits
      */
-    getDepositsForDestinationChainWithDuplicates(destinationChainId) {
-        const deposits = this.getDepositsForDestinationChain(destinationChainId);
-        const duplicateDeposits = deposits.reduce((acc, deposit) => {
-            const duplicates = this._getDuplicateDeposits(deposit);
+    SpokePoolClient.prototype.getDepositsForDestinationChainWithDuplicates = function (destinationChainId) {
+        var _this = this;
+        var deposits = this.getDepositsForDestinationChain(destinationChainId);
+        var duplicateDeposits = deposits.reduce(function (acc, deposit) {
+            var duplicates = _this._getDuplicateDeposits(deposit);
             return acc.concat(duplicates);
         }, []);
         return sortEventsAscendingInPlace(deposits.concat(duplicateDeposits.flat()));
-    }
+    };
     /**
      * Retrieves a list of deposits from the SpokePool contract that are associated with this spoke pool.
      * @returns A list of deposits.
      * @note This method returns all deposits, regardless of destination chain ID in sorted order.
      */
-    getDeposits(filter) {
-        let deposits = Object.values(this.depositHashes);
+    SpokePoolClient.prototype.getDeposits = function (filter) {
+        var deposits = Object.values(this.depositHashes);
         if (isDefined(filter)) {
-            const { fromBlock, toBlock } = filter;
-            deposits = deposits.filter(({ blockNumber }) => blockNumber >= fromBlock && toBlock >= blockNumber);
+            var fromBlock_1 = filter.fromBlock, toBlock_1 = filter.toBlock;
+            deposits = deposits.filter(function (_a) {
+                var blockNumber = _a.blockNumber;
+                return blockNumber >= fromBlock_1 && toBlock_1 >= blockNumber;
+            });
         }
         return sortEventsAscendingInPlace(deposits);
-    }
+    };
     /**
      * Retrieves a list of the tokens that have been bridged.
      * @returns A list of tokens.
      */
-    getTokensBridged() {
+    SpokePoolClient.prototype.getTokensBridged = function () {
         return this.tokensBridged;
-    }
+    };
     /**
      * Retrieves a mapping of tokens and their associated destination chain IDs that can be bridged.
      * @returns A mapping of tokens and their associated destination chain IDs in a nested mapping.
      */
-    getDepositRoutes() {
+    SpokePoolClient.prototype.getDepositRoutes = function () {
         return this.depositRoutes;
-    }
+    };
     /**
      * Retrieves a list of fills from the SpokePool contract.
      * @returns A list of fills.
      */
-    getFills() {
+    SpokePoolClient.prototype.getFills = function () {
         return sortEventsAscendingInPlace(Object.values(this.fills).flat());
-    }
+    };
     /**
      * Retrieves a list of fills from a specific origin chain ID.
      * @param originChainId The origin chain ID.
      * @returns A list of fills.
      */
-    getFillsForOriginChain(originChainId) {
+    SpokePoolClient.prototype.getFillsForOriginChain = function (originChainId) {
         return this.fills[originChainId] || [];
-    }
+    };
     /**
      * Retrieves a list of fills from a specific relayer address.
      * @param relayer The relayer address.
      * @returns A list of fills.
      */
-    getFillsForRelayer(relayer) {
-        return this.getFills().filter((fill) => fill.relayer.eq(relayer));
-    }
+    SpokePoolClient.prototype.getFillsForRelayer = function (relayer) {
+        return this.getFills().filter(function (fill) { return fill.relayer.eq(relayer); });
+    };
     /**
      * Retrieves a list of fills from a given block range.
      * @param startingBlock The starting block number.
      * @param endingBlock The ending block number.
      * @returns A list of fills.
      */
-    getFillsWithBlockInRange(startingBlock, endingBlock) {
-        return this.getFills().filter((fill) => fill.blockNumber >= startingBlock && fill.blockNumber <= endingBlock);
-    }
+    SpokePoolClient.prototype.getFillsWithBlockInRange = function (startingBlock, endingBlock) {
+        return this.getFills().filter(function (fill) { return fill.blockNumber >= startingBlock && fill.blockNumber <= endingBlock; });
+    };
     /**
      * Retrieves a list of root bundle relays from the SpokePool contract.
      * @returns A list of root bundle relays.
      */
-    getRootBundleRelays() {
+    SpokePoolClient.prototype.getRootBundleRelays = function () {
         return this.rootBundleRelays;
-    }
+    };
     /**
      * Retrieves the ID of the latest root bundle.
      * @returns The ID of the latest root bundle. This will be 0 if no root bundles have been relayed.
      */
-    getLatestRootBundleId() {
+    SpokePoolClient.prototype.getLatestRootBundleId = function () {
+        var _a;
         return this.rootBundleRelays.length > 0
-            ? this.rootBundleRelays[this.rootBundleRelays.length - 1]?.rootBundleId + 1
+            ? ((_a = this.rootBundleRelays[this.rootBundleRelays.length - 1]) === null || _a === void 0 ? void 0 : _a.rootBundleId) + 1
             : 0;
-    }
+    };
     /**
      * Retrieves a list of relayer refund executions from the SpokePool contract.
      * @returns A list of relayer refund executions.
      */
-    getRelayerRefundExecutions() {
+    SpokePoolClient.prototype.getRelayerRefundExecutions = function () {
         return this.relayerRefundExecutions;
-    }
+    };
     /**
      * Retrieves a list of claimed relayer refunds from the SpokePool contract.
      * @returns A list of claimed relayer refunds.
      */
-    getClaimedRelayerRefunds() {
+    SpokePoolClient.prototype.getClaimedRelayerRefunds = function () {
         return this.claimedRelayerRefunds;
-    }
+    };
     /**
      * Retrieves a list of bridged to hub pool events from the SpokePool contract.
      * @returns A list of bridged to hub pool events.
      */
-    getBridgedToHubPoolEvents() {
+    SpokePoolClient.prototype.getBridgedToHubPoolEvents = function () {
         return this.bridgedToHubPool;
-    }
+    };
     /**
      * Appends a speed up signature to a specific deposit.
      * @param deposit The deposit to append the speed up signature to.
      * @returns A new deposit instance with the speed up signature appended to the deposit.
      */
-    appendMaxSpeedUpSignatureToDeposit(deposit) {
-        const { depositId, depositor } = deposit;
+    SpokePoolClient.prototype.appendMaxSpeedUpSignatureToDeposit = function (deposit) {
+        var _a;
+        var depositId = deposit.depositId, depositor = deposit.depositor;
         // Note: we know depositor cannot be more than 20 bytes since this is guaranteed by contracts.
         // Additionally, speed ups can only be done on EVM networks.
-        const speedups = this.speedUps[depositor.toEvmAddress()]?.[depositId.toString()];
+        var speedups = (_a = this.speedUps[depositor.toEvmAddress()]) === null || _a === void 0 ? void 0 : _a[depositId.toString()];
         if (!isDefined(speedups) || speedups.length === 0) {
             return deposit;
         }
-        const maxSpeedUp = speedups.reduce((prev, current) => prev.updatedOutputAmount.lt(current.updatedOutputAmount) ? prev : current);
+        var maxSpeedUp = speedups.reduce(function (prev, current) {
+            return prev.updatedOutputAmount.lt(current.updatedOutputAmount) ? prev : current;
+        });
         // We assume that the depositor authorises SpeedUps in isolation of each other, which keeps the relayer
         // logic simple: find the SpeedUp with the lowest updatedOutputAmount, and use all of its fields.
         if (maxSpeedUp.updatedOutputAmount.gte(deposit.outputAmount)) {
             return deposit;
         }
         // Return deposit with updated params from the speedup with the lowest updated output amount.
-        const updatedDeposit = {
-            ...deposit,
-            speedUpSignature: maxSpeedUp.depositorSignature,
-            updatedOutputAmount: maxSpeedUp.updatedOutputAmount,
-            updatedRecipient: maxSpeedUp.updatedRecipient,
-            updatedMessage: maxSpeedUp.updatedMessage,
-        };
+        var updatedDeposit = __assign(__assign({}, deposit), { speedUpSignature: maxSpeedUp.depositorSignature, updatedOutputAmount: maxSpeedUp.updatedOutputAmount, updatedRecipient: maxSpeedUp.updatedRecipient, updatedMessage: maxSpeedUp.updatedMessage });
         return updatedDeposit;
-    }
+    };
     /**
      * Find a deposit based on its deposit ID.
      * @notice If evaluating a fill, be sure to verify it against the resulting deposit.
      * @param depositId The unique ID of the deposit being queried.
      * @returns The corresponding deposit if found, undefined otherwise.
      */
-    getDeposit(depositId) {
-        return Object.values(this.depositHashes).find(({ depositId: _depositId }) => _depositId.eq(depositId));
-    }
+    SpokePoolClient.prototype.getDeposit = function (depositId) {
+        return Object.values(this.depositHashes).find(function (_a) {
+            var _depositId = _a.depositId;
+            return _depositId.eq(depositId);
+        });
+    };
     /**
      * Retrieves a list of slow fill requests from the SpokePool contract.
      * @returns A list of slow fill requests.
      */
-    getSlowFillRequests() {
+    SpokePoolClient.prototype.getSlowFillRequests = function () {
         return sortEventsAscendingInPlace(Object.values(this.slowFillRequests));
-    }
+    };
     /**
      * Find a SlowFillRequested event based on its deposit RelayData.
      * @param relayData RelayData field for the SlowFill request.
      * @returns The corresponding SlowFillRequest event if found, otherwise undefined.
      */
-    getSlowFillRequest(relayData) {
-        const hash = getRelayEventKey({ ...relayData, destinationChainId: this.chainId });
+    SpokePoolClient.prototype.getSlowFillRequest = function (relayData) {
+        var hash = getRelayEventKey(__assign(__assign({}, relayData), { destinationChainId: this.chainId }));
         return this.slowFillRequests[hash];
-    }
+    };
     /**
      * Retrieves a list of slow fill requests for deposits from a specific origin chain ID.
      * @param originChainId The origin chain ID.
      * @returns A list of slow fill requests.
      */
-    getSlowFillRequestsForOriginChain(originChainId) {
-        return Object.values(this.slowFillRequests).filter((e) => e.originChainId === originChainId);
-    }
+    SpokePoolClient.prototype.getSlowFillRequestsForOriginChain = function (originChainId) {
+        return Object.values(this.slowFillRequests).filter(function (e) { return e.originChainId === originChainId; });
+    };
     /**
      * Retrieves speed up requests grouped by depositor and depositId.
      * @returns A mapping of depositor addresses to deposit ids with their corresponding speed up requests.
      */
-    getSpeedUps() {
+    SpokePoolClient.prototype.getSpeedUps = function () {
         return this.speedUps;
-    }
+    };
     /**
      * Find a corresponding deposit for a given fill.
      * @param fill The fill to find a corresponding deposit for.
      * @returns The corresponding deposit if found, undefined otherwise.
      */
-    getDepositForFill(fill) {
-        const deposit = this.depositHashes[getRelayEventKey(fill)];
-        const match = validateFillForDeposit(fill, deposit);
+    SpokePoolClient.prototype.getDepositForFill = function (fill) {
+        var deposit = this.depositHashes[getRelayEventKey(fill)];
+        var match = validateFillForDeposit(fill, deposit);
         return match.valid ? deposit : undefined;
-    }
-    getFillsForDeposit(deposit) {
-        return this.depositHashesToFills[this.getDepositHash(deposit)] ?? [];
-    }
-    isDepositFilled(deposit) {
-        const depositHash = this.getDepositHash(deposit);
-        const fills = this.depositHashesToFills[depositHash] ?? [];
-        return fills.some((fill) => validateFillForDeposit(fill, deposit).valid);
-    }
+    };
+    SpokePoolClient.prototype.getFillsForDeposit = function (deposit) {
+        var _a;
+        return (_a = this.depositHashesToFills[this.getDepositHash(deposit)]) !== null && _a !== void 0 ? _a : [];
+    };
+    SpokePoolClient.prototype.isDepositFilled = function (deposit) {
+        var _a;
+        var depositHash = this.getDepositHash(deposit);
+        var fills = (_a = this.depositHashesToFills[depositHash]) !== null && _a !== void 0 ? _a : [];
+        return fills.some(function (fill) { return validateFillForDeposit(fill, deposit).valid; });
+    };
     // @TODO: Remove this method after refactoring relayer repo.
     /**
      * Find the unfilled amount for a given deposit. This is the full deposit amount minus the total filled amount.
@@ -290,27 +296,25 @@ export class SpokePoolClient extends BaseAbstractClient {
      * @param invalidFills The invalid fills that have been applied to this deposit.
      * @returns The unfilled amount.
      */
-    getValidUnfilledAmountForDeposit(deposit) {
-        const { outputAmount, originChainId } = deposit;
-        const fillsForDeposit = this.depositHashesToFills[this.getDepositHash(deposit)];
+    SpokePoolClient.prototype.getValidUnfilledAmountForDeposit = function (deposit) {
+        var _this = this;
+        var outputAmount = deposit.outputAmount, originChainId = deposit.originChainId;
+        var fillsForDeposit = this.depositHashesToFills[this.getDepositHash(deposit)];
         // If no fills then the full amount is remaining.
         if (fillsForDeposit === undefined || fillsForDeposit.length === 0) {
             return { unfilledAmount: outputAmount, fillCount: 0, invalidFills: [] };
         }
-        const { validFills, invalidFills, unrepayableFills } = fillsForDeposit.reduce((groupedFills, fill) => {
+        var _a = fillsForDeposit.reduce(function (groupedFills, fill) {
             if (validateFillForDeposit(fill, deposit).valid) {
-                const fillRepaymentData = {
-                    ...fill,
-                    fromLiteChain: deposit.fromLiteChain,
-                };
-                const { chainToSendRefundTo: repaymentChainId } = getRefundInformationFromFill(fillRepaymentData, this.hubPoolClient, this.hubPoolClient.latestHeightSearched);
+                var fillRepaymentData = __assign(__assign({}, fill), { fromLiteChain: deposit.fromLiteChain });
+                var repaymentChainId = getRefundInformationFromFill(fillRepaymentData, _this.hubPoolClient, _this.hubPoolClient.latestHeightSearched).chainToSendRefundTo;
                 // In order to keep this function sync, we can't call verifyFillRepayment so we'll log any fills where
                 // the filler-specified repayment chain and repayment address is not a valid repayment upon
                 // first glance. In other words, the repayment address is not a valid EVM address or the repayment chain
                 // is not a valid EVM chain. In the case where the repayment address is not a valid EVM address, the dataworker
                 // might be able to overwrite the repayment address to the msg.sender on the fill txn, but to keep this
                 // functioon synchronous, we can't make that decision now. So this function might log some false positives.
-                if (this.hubPoolClient && !isSlowFill(fill) && !fill.relayer.isValidOn(repaymentChainId)) {
+                if (_this.hubPoolClient && !isSlowFill(fill) && !fill.relayer.isValidOn(repaymentChainId)) {
                     groupedFills.unrepayableFills.push(fill);
                 }
                 // This fill is still valid and means that the deposit cannot be filled on-chain anymore, but it
@@ -321,29 +325,29 @@ export class SpokePoolClient extends BaseAbstractClient {
                 groupedFills.invalidFills.push(fill);
             }
             return groupedFills;
-        }, { validFills: [], invalidFills: [], unrepayableFills: [] });
-        const logLevel = chainIsProd(originChainId) ? "warn" : "debug";
-        const unrepayableFillsForDeposit = unrepayableFills.filter((x) => x.depositId.eq(deposit.depositId));
+        }, { validFills: [], invalidFills: [], unrepayableFills: [] }), validFills = _a.validFills, invalidFills = _a.invalidFills, unrepayableFills = _a.unrepayableFills;
+        var logLevel = chainIsProd(originChainId) ? "warn" : "debug";
+        var unrepayableFillsForDeposit = unrepayableFills.filter(function (x) { return x.depositId.eq(deposit.depositId); });
         if (unrepayableFillsForDeposit.length > 0) {
             this.logger[logLevel]({
                 at: "SpokePoolClient",
                 chainId: this.chainId,
                 message: "Unrepayable fills found where we need to switch repayment address and or chain",
-                deposit,
-                unrepayableFills: Object.fromEntries(unrepayableFillsForDeposit.map((x) => [x.relayer.toNative(), x])),
+                deposit: deposit,
+                unrepayableFills: Object.fromEntries(unrepayableFillsForDeposit.map(function (x) { return [x.relayer.toNative(), x]; })),
                 notificationPath: "across-unrepayable-fills",
             });
         }
         // If all fills are invalid we can consider this unfilled.
         if (validFills.length === 0) {
-            return { unfilledAmount: outputAmount, fillCount: 0, invalidFills };
+            return { unfilledAmount: outputAmount, fillCount: 0, invalidFills: invalidFills };
         }
         return {
             unfilledAmount: bnZero,
             fillCount: validFills.length,
-            invalidFills,
+            invalidFills: invalidFills,
         };
-    }
+    };
     /**
      * Formulate a hash for a given deposit or fill
      * @param event The deposit or fill to formulate a hash for.
@@ -351,19 +355,20 @@ export class SpokePoolClient extends BaseAbstractClient {
      * @note This hash is used to match deposits and fills together.
      * @note This hash takes the form of: `${depositId}-${originChainId}`.
      */
-    getDepositHash(event) {
-        return `${event.depositId.toString()}-${event.originChainId}`;
-    }
-    canResolveZeroAddressOutputToken(deposit) {
-        if (!this.hubPoolClient?.l2TokenHasPoolRebalanceRoute(deposit.inputToken, deposit.originChainId, deposit.quoteBlockNumber)) {
+    SpokePoolClient.prototype.getDepositHash = function (event) {
+        return "".concat(event.depositId.toString(), "-").concat(event.originChainId);
+    };
+    SpokePoolClient.prototype.canResolveZeroAddressOutputToken = function (deposit) {
+        var _a, _b;
+        if (!((_a = this.hubPoolClient) === null || _a === void 0 ? void 0 : _a.l2TokenHasPoolRebalanceRoute(deposit.inputToken, deposit.originChainId, deposit.quoteBlockNumber))) {
             return false;
         }
-        const l1Token = this.hubPoolClient?.getL1TokenForL2TokenAtBlock(deposit.inputToken, deposit.originChainId, deposit.quoteBlockNumber);
+        var l1Token = (_b = this.hubPoolClient) === null || _b === void 0 ? void 0 : _b.getL1TokenForL2TokenAtBlock(deposit.inputToken, deposit.originChainId, deposit.quoteBlockNumber);
         if (!l1Token) {
             return false;
         }
         return this.hubPoolClient.l2TokenEnabledForL1TokenAtBlock(l1Token, deposit.destinationChainId, deposit.quoteBlockNumber);
-    }
+    };
     /**
      * A wrapper over the `_update` method that handles errors and logs. This method additionally calls into the
      * HubPoolClient to update the state of this client with data from the HubPool contract.
@@ -372,285 +377,307 @@ export class SpokePoolClient extends BaseAbstractClient {
      * @note This method is the primary method for updating the state of this client externally.
      * @see _update
      */
-    async update(eventsToQuery = this._queryableEventNames()) {
-        const duplicateEvents = [];
-        if (this.hubPoolClient !== null && !this.hubPoolClient.isUpdated) {
-            throw new Error("HubPoolClient not updated");
-        }
-        const update = await this._update(eventsToQuery);
-        if (!update.success) {
-            return;
-        }
-        const { events: queryResults, currentTime, searchEndBlock } = update;
-        if (eventsToQuery.includes("TokensBridged")) {
-            for (const _event of queryResults[eventsToQuery.indexOf("TokensBridged")]) {
-                const event = _event;
-                this.tokensBridged.push({
-                    ...event,
-                    l2TokenAddress: toAddressType(event.l2TokenAddress, this.chainId),
-                });
-            }
-        }
-        // Performs the indexing of a deposit-like spoke pool event.
-        const queryDepositEvents = async (eventName) => {
-            const depositEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((event) => unpackDepositEvent(event, this.chainId));
-            // For each deposit, resolve its quoteTimestamp to a block number on the HubPool.
-            // Don't bother filtering for uniqueness; the HubPoolClient handles this efficienctly.
-            const quoteBlockNumbers = await this.getBlockNumbers(depositEvents.map((e) => e.quoteTimestamp));
-            for (const event of depositEvents) {
-                const quoteBlockNumber = quoteBlockNumbers[Number(event.quoteTimestamp)];
-                // Derive and append the common properties that are not part of the onchain event.
-                const outputToken = event.outputToken.isZeroAddress()
-                    ? this.getDestinationTokenForDeposit({ ...event, quoteBlockNumber })
-                    : event.outputToken;
-                const deposit = {
-                    ...event,
-                    outputToken,
-                    quoteBlockNumber,
-                    fromLiteChain: this.isOriginLiteChain(event),
-                    toLiteChain: this.isDestinationLiteChain(event),
-                };
-                if (this.depositHashes[getRelayEventKey(deposit)] !== undefined) {
-                    // Sanity check that this event is not a duplicate, even though the relay data hash is a duplicate.
-                    const allDeposits = this._getDuplicateDeposits(deposit).concat(this.depositHashes[getRelayEventKey(deposit)]);
-                    if (allDeposits.some((e) => duplicateEvent(deposit, e))) {
-                        duplicateEvents.push(event);
-                        continue;
-                    }
-                    assign(this.duplicateDepositHashes, [getRelayEventKey(deposit)], [deposit]);
-                    continue;
+    SpokePoolClient.prototype.update = function () {
+        return __awaiter(this, arguments, void 0, function (eventsToQuery) {
+            var duplicateEvents, update, queryResults, currentTime, searchEndBlock, _i, _a, _event, event_1, queryDepositEvents, _b, _c, event_2, querySpeedUpDepositEvents, queryRequestedSlowFillEvents, queryFilledRelayEvents, enableDepositsEvents, _d, enableDepositsEvents_1, event_3, relayedRootBundleEvents, _e, relayedRootBundleEvents_1, event_4, refundEvents, _f, refundEvents_1, _event, event_5, claimedRelayerRefundEvents, _g, claimedRelayerRefundEvents_1, event_6, bridgedToHubPoolEvents, _h, bridgedToHubPoolEvents_1, event_7;
+            var _this = this;
+            var _j, _k;
+            if (eventsToQuery === void 0) { eventsToQuery = this._queryableEventNames(); }
+            return __generator(this, function (_l) {
+                switch (_l.label) {
+                    case 0:
+                        duplicateEvents = [];
+                        if (this.hubPoolClient !== null && !this.hubPoolClient.isUpdated) {
+                            throw new Error("HubPoolClient not updated");
+                        }
+                        return [4 /*yield*/, this._update(eventsToQuery)];
+                    case 1:
+                        update = _l.sent();
+                        if (!update.success) {
+                            return [2 /*return*/];
+                        }
+                        queryResults = update.events, currentTime = update.currentTime, searchEndBlock = update.searchEndBlock;
+                        if (eventsToQuery.includes("TokensBridged")) {
+                            for (_i = 0, _a = queryResults[eventsToQuery.indexOf("TokensBridged")]; _i < _a.length; _i++) {
+                                _event = _a[_i];
+                                event_1 = _event;
+                                this.tokensBridged.push(__assign(__assign({}, event_1), { l2TokenAddress: toAddressType(event_1.l2TokenAddress, this.chainId) }));
+                            }
+                        }
+                        queryDepositEvents = function (eventName) { return __awaiter(_this, void 0, void 0, function () {
+                            var depositEvents, quoteBlockNumbers, _loop_1, this_1, _i, depositEvents_1, event_8;
+                            var _this = this;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        depositEvents = ((_a = queryResults[eventsToQuery.indexOf(eventName)]) !== null && _a !== void 0 ? _a : []).map(function (event) {
+                                            return unpackDepositEvent(event, _this.chainId);
+                                        });
+                                        return [4 /*yield*/, this.getBlockNumbers(depositEvents.map(function (e) { return e.quoteTimestamp; }))];
+                                    case 1:
+                                        quoteBlockNumbers = _b.sent();
+                                        _loop_1 = function (event_8) {
+                                            var quoteBlockNumber = quoteBlockNumbers[Number(event_8.quoteTimestamp)];
+                                            // Derive and append the common properties that are not part of the onchain event.
+                                            var outputToken = event_8.outputToken.isZeroAddress()
+                                                ? this_1.getDestinationTokenForDeposit(__assign(__assign({}, event_8), { quoteBlockNumber: quoteBlockNumber }))
+                                                : event_8.outputToken;
+                                            var deposit = __assign(__assign({}, event_8), { outputToken: outputToken, quoteBlockNumber: quoteBlockNumber, fromLiteChain: this_1.isOriginLiteChain(event_8), toLiteChain: this_1.isDestinationLiteChain(event_8) });
+                                            if (this_1.depositHashes[getRelayEventKey(deposit)] !== undefined) {
+                                                // Sanity check that this event is not a duplicate, even though the relay data hash is a duplicate.
+                                                var allDeposits = this_1._getDuplicateDeposits(deposit).concat(this_1.depositHashes[getRelayEventKey(deposit)]);
+                                                if (allDeposits.some(function (e) { return duplicateEvent(deposit, e); })) {
+                                                    duplicateEvents.push(event_8);
+                                                    return "continue";
+                                                }
+                                                assign(this_1.duplicateDepositHashes, [getRelayEventKey(deposit)], [deposit]);
+                                                return "continue";
+                                            }
+                                            assign(this_1.depositHashes, [getRelayEventKey(deposit)], deposit);
+                                        };
+                                        this_1 = this;
+                                        for (_i = 0, depositEvents_1 = depositEvents; _i < depositEvents_1.length; _i++) {
+                                            event_8 = depositEvents_1[_i];
+                                            _loop_1(event_8);
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        _b = 0, _c = ["FundsDeposited"];
+                        _l.label = 2;
+                    case 2:
+                        if (!(_b < _c.length)) return [3 /*break*/, 5];
+                        event_2 = _c[_b];
+                        if (!eventsToQuery.includes(event_2)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, queryDepositEvents(event_2)];
+                    case 3:
+                        _l.sent();
+                        _l.label = 4;
+                    case 4:
+                        _b++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        querySpeedUpDepositEvents = function (eventName) {
+                            var _a;
+                            var speedUpEvents = ((_a = queryResults[eventsToQuery.indexOf(eventName)]) !== null && _a !== void 0 ? _a : [])
+                                .map(function (_event) {
+                                var event = _event;
+                                var invalid = [event.depositor, event.updatedRecipient].some(function (addr) { return !EvmAddress.validate(ethersUtils.arrayify(addr)); });
+                                if (invalid) {
+                                    return;
+                                }
+                                return __assign(__assign({}, event), { depositor: EvmAddress.from(event.depositor), updatedRecipient: EvmAddress.from(event.updatedRecipient) });
+                            })
+                                .filter(isDefined);
+                            for (var _i = 0, speedUpEvents_1 = speedUpEvents; _i < speedUpEvents_1.length; _i++) {
+                                var event_9 = speedUpEvents_1[_i];
+                                var speedUp = __assign(__assign({}, event_9), { originChainId: _this.chainId });
+                                assign(_this.speedUps, [speedUp.depositor.toEvmAddress(), speedUp.depositId.toString()], [speedUp]);
+                                // Find deposit hash matching this speed up event and update the deposit data associated with the hash,
+                                // if the hash+data exists. nb. Relying on depositId alone can produce collisions on deterministic deposit IDs.
+                                var deposit = _this.getDeposit(speedUp.depositId);
+                                // SpeedUp requests are only supported EVM -> EVM.
+                                if (isDefined(deposit) && chainIsEvm(deposit.destinationChainId) && deposit.depositor.eq(speedUp.depositor)) {
+                                    // We can assume all deposits in this lookback window are loaded in-memory already so if the depositHash
+                                    // is not mapped to a deposit, then we can throw away the speedup as it can't be applied to anything.
+                                    var eventKey = getRelayEventKey(deposit);
+                                    _this.depositHashes[eventKey] = _this.appendMaxSpeedUpSignatureToDeposit(deposit);
+                                }
+                            }
+                        };
+                        // Update deposits with speed up requests from depositor.
+                        ["RequestedSpeedUpDeposit"].forEach(function (event) {
+                            if (eventsToQuery.includes(event)) {
+                                querySpeedUpDepositEvents(event);
+                            }
+                        });
+                        queryRequestedSlowFillEvents = function (eventName) {
+                            var _a, _b;
+                            var _c;
+                            var destinationChainId = _this.chainId;
+                            var slowFillRequests = ((_a = queryResults[eventsToQuery.indexOf(eventName)]) !== null && _a !== void 0 ? _a : []).map(function (_event) {
+                                var event = _event;
+                                return __assign(__assign({}, event), { destinationChainId: destinationChainId, depositor: toAddressType(event.depositor, event.originChainId), recipient: toAddressType(event.recipient, destinationChainId), inputToken: toAddressType(event.inputToken, event.originChainId), outputToken: toAddressType(event.outputToken, destinationChainId), exclusiveRelayer: toAddressType(event.exclusiveRelayer, destinationChainId) });
+                            });
+                            for (var _i = 0, slowFillRequests_1 = slowFillRequests; _i < slowFillRequests_1.length; _i++) {
+                                var slowFillRequest = slowFillRequests_1[_i];
+                                var depositHash = getRelayEventKey(slowFillRequest);
+                                // Sanity check that this event is not a duplicate.
+                                if (_this.slowFillRequests[depositHash] !== undefined) {
+                                    duplicateEvents.push(slowFillRequest);
+                                    continue;
+                                }
+                                (_b = (_c = _this.slowFillRequests)[depositHash]) !== null && _b !== void 0 ? _b : (_c[depositHash] = slowFillRequest);
+                            }
+                        };
+                        ["RequestedSlowFill"].forEach(function (event) {
+                            if (eventsToQuery.includes(event)) {
+                                queryRequestedSlowFillEvents(event);
+                            }
+                        });
+                        queryFilledRelayEvents = function (eventName) {
+                            var _a, _b;
+                            var fillEvents = ((_a = queryResults[eventsToQuery.indexOf(eventName)]) !== null && _a !== void 0 ? _a : []).map(function (event) {
+                                return unpackFillEvent(event, _this.chainId);
+                            });
+                            if (fillEvents.length > 0) {
+                                _this.log("debug", "Using ".concat(fillEvents.length, " newly queried ").concat(eventName, " events for chain ").concat(_this.chainId), {
+                                    earliestEvent: fillEvents[0].blockNumber,
+                                });
+                            }
+                            var _loop_2 = function (fill) {
+                                // Sanity check that this event is not a duplicate.
+                                var duplicateFill = (_b = _this.fills[fill.originChainId]) === null || _b === void 0 ? void 0 : _b.find(function (f) { return duplicateEvent(fill, f); });
+                                if (duplicateFill) {
+                                    duplicateEvents.push(fill);
+                                    return "continue";
+                                }
+                                assign(_this.fills, [fill.originChainId], [fill]);
+                                assign(_this.depositHashesToFills, [_this.getDepositHash(fill)], [fill]);
+                            };
+                            // @note The type assertions here suppress errors that might arise due to incomplete types. For now, verify via
+                            // test that the types are complete. A broader change in strategy for safely unpacking events will be introduced.
+                            for (var _i = 0, fillEvents_1 = fillEvents; _i < fillEvents_1.length; _i++) {
+                                var fill = fillEvents_1[_i];
+                                _loop_2(fill);
+                            }
+                        };
+                        // Update observed fills with ingested event data.
+                        ["FilledRelay"].forEach(function (event) {
+                            if (eventsToQuery.includes(event)) {
+                                queryFilledRelayEvents(event);
+                            }
+                        });
+                        if (eventsToQuery.includes("EnabledDepositRoute")) {
+                            enableDepositsEvents = queryResults[eventsToQuery.indexOf("EnabledDepositRoute")].map(function (_event) {
+                                var event = _event;
+                                return __assign(__assign({}, event), { originToken: toAddressType(event.originToken, CHAIN_IDs.MAINNET) });
+                            });
+                            for (_d = 0, enableDepositsEvents_1 = enableDepositsEvents; _d < enableDepositsEvents_1.length; _d++) {
+                                event_3 = enableDepositsEvents_1[_d];
+                                assign(this.depositRoutes, [event_3.originToken.toBytes32(), event_3.destinationChainId], event_3.enabled);
+                            }
+                        }
+                        if (eventsToQuery.includes("RelayedRootBundle")) {
+                            relayedRootBundleEvents = queryResults[eventsToQuery.indexOf("RelayedRootBundle")];
+                            for (_e = 0, relayedRootBundleEvents_1 = relayedRootBundleEvents; _e < relayedRootBundleEvents_1.length; _e++) {
+                                event_4 = relayedRootBundleEvents_1[_e];
+                                this.rootBundleRelays.push(event_4);
+                            }
+                        }
+                        if (eventsToQuery.includes("ExecutedRelayerRefundRoot")) {
+                            refundEvents = queryResults[eventsToQuery.indexOf("ExecutedRelayerRefundRoot")];
+                            for (_f = 0, refundEvents_1 = refundEvents; _f < refundEvents_1.length; _f++) {
+                                _event = refundEvents_1[_f];
+                                event_5 = _event;
+                                this.relayerRefundExecutions.push(__assign(__assign({}, event_5), { l2TokenAddress: toAddressType(event_5.l2TokenAddress, this.chainId), refundAddresses: event_5.refundAddresses.map(function (addr) { return toAddressType(addr, _this.chainId); }) }));
+                            }
+                        }
+                        if (eventsToQuery.includes("ClaimedRelayerRefund")) {
+                            claimedRelayerRefundEvents = ((_j = queryResults[eventsToQuery.indexOf("ClaimedRelayerRefund")]) !== null && _j !== void 0 ? _j : []);
+                            for (_g = 0, claimedRelayerRefundEvents_1 = claimedRelayerRefundEvents; _g < claimedRelayerRefundEvents_1.length; _g++) {
+                                event_6 = claimedRelayerRefundEvents_1[_g];
+                                this.claimedRelayerRefunds.push(__assign(__assign({}, event_6), { amount: event_6.amount || event_6.claimAmount }));
+                            }
+                        }
+                        if (eventsToQuery.includes("BridgedToHubPool")) {
+                            bridgedToHubPoolEvents = ((_k = queryResults[eventsToQuery.indexOf("BridgedToHubPool")]) !== null && _k !== void 0 ? _k : []);
+                            for (_h = 0, bridgedToHubPoolEvents_1 = bridgedToHubPoolEvents; _h < bridgedToHubPoolEvents_1.length; _h++) {
+                                event_7 = bridgedToHubPoolEvents_1[_h];
+                                this.bridgedToHubPool.push(event_7);
+                            }
+                        }
+                        if (duplicateEvents.length > 0) {
+                            this.log("debug", "Duplicate events listed", {
+                                duplicateEvents: duplicateEvents,
+                            });
+                            this.log("error", "Duplicate events detected, check debug logs");
+                        }
+                        // Next iteration should start off from where this one ended.
+                        this.currentTime = currentTime;
+                        this.latestHeightSearched = searchEndBlock;
+                        this.firstHeightToSearch = searchEndBlock + 1;
+                        this.eventSearchConfig.to = undefined; // Caller can re-set on subsequent updates if necessary
+                        this.isUpdated = true;
+                        this.log("debug", "SpokePool client for chain ".concat(this.chainId, " updated!"), {
+                            nextFirstHeightToSearch: this.firstHeightToSearch,
+                        });
+                        return [2 /*return*/];
                 }
-                assign(this.depositHashes, [getRelayEventKey(deposit)], deposit);
-            }
-        };
-        for (const event of ["FundsDeposited"]) {
-            if (eventsToQuery.includes(event)) {
-                await queryDepositEvents(event);
-            }
-        }
-        // Performs indexing of a "speed up deposit"-like event.
-        const querySpeedUpDepositEvents = (eventName) => {
-            const speedUpEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? [])
-                .map((_event) => {
-                const event = _event;
-                const invalid = [event.depositor, event.updatedRecipient].some((addr) => !EvmAddress.validate(ethersUtils.arrayify(addr)));
-                if (invalid) {
-                    return;
-                }
-                return {
-                    ...event,
-                    depositor: EvmAddress.from(event.depositor),
-                    updatedRecipient: EvmAddress.from(event.updatedRecipient),
-                };
-            })
-                .filter(isDefined);
-            for (const event of speedUpEvents) {
-                const speedUp = {
-                    ...event,
-                    originChainId: this.chainId,
-                };
-                assign(this.speedUps, [speedUp.depositor.toEvmAddress(), speedUp.depositId.toString()], [speedUp]);
-                // Find deposit hash matching this speed up event and update the deposit data associated with the hash,
-                // if the hash+data exists. nb. Relying on depositId alone can produce collisions on deterministic deposit IDs.
-                const deposit = this.getDeposit(speedUp.depositId);
-                // SpeedUp requests are only supported EVM -> EVM.
-                if (isDefined(deposit) && chainIsEvm(deposit.destinationChainId) && deposit.depositor.eq(speedUp.depositor)) {
-                    // We can assume all deposits in this lookback window are loaded in-memory already so if the depositHash
-                    // is not mapped to a deposit, then we can throw away the speedup as it can't be applied to anything.
-                    const eventKey = getRelayEventKey(deposit);
-                    this.depositHashes[eventKey] = this.appendMaxSpeedUpSignatureToDeposit(deposit);
-                }
-            }
-        };
-        // Update deposits with speed up requests from depositor.
-        ["RequestedSpeedUpDeposit"].forEach((event) => {
-            if (eventsToQuery.includes(event)) {
-                querySpeedUpDepositEvents(event);
-            }
-        });
-        // Performs indexing of "requested slow fill"-like events.
-        const queryRequestedSlowFillEvents = (eventName) => {
-            const destinationChainId = this.chainId;
-            const slowFillRequests = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
-                const event = _event;
-                return {
-                    ...event,
-                    destinationChainId,
-                    depositor: toAddressType(event.depositor, event.originChainId),
-                    recipient: toAddressType(event.recipient, destinationChainId),
-                    inputToken: toAddressType(event.inputToken, event.originChainId),
-                    outputToken: toAddressType(event.outputToken, destinationChainId),
-                    exclusiveRelayer: toAddressType(event.exclusiveRelayer, destinationChainId),
-                };
-            });
-            for (const slowFillRequest of slowFillRequests) {
-                const depositHash = getRelayEventKey(slowFillRequest);
-                // Sanity check that this event is not a duplicate.
-                if (this.slowFillRequests[depositHash] !== undefined) {
-                    duplicateEvents.push(slowFillRequest);
-                    continue;
-                }
-                this.slowFillRequests[depositHash] ??= slowFillRequest;
-            }
-        };
-        ["RequestedSlowFill"].forEach((event) => {
-            if (eventsToQuery.includes(event)) {
-                queryRequestedSlowFillEvents(event);
-            }
-        });
-        // Performs indexing of filled relay-like events.
-        const queryFilledRelayEvents = (eventName) => {
-            const fillEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((event) => unpackFillEvent(event, this.chainId));
-            if (fillEvents.length > 0) {
-                this.log("debug", `Using ${fillEvents.length} newly queried ${eventName} events for chain ${this.chainId}`, {
-                    earliestEvent: fillEvents[0].blockNumber,
-                });
-            }
-            // @note The type assertions here suppress errors that might arise due to incomplete types. For now, verify via
-            // test that the types are complete. A broader change in strategy for safely unpacking events will be introduced.
-            for (const fill of fillEvents) {
-                // Sanity check that this event is not a duplicate.
-                const duplicateFill = this.fills[fill.originChainId]?.find((f) => duplicateEvent(fill, f));
-                if (duplicateFill) {
-                    duplicateEvents.push(fill);
-                    continue;
-                }
-                assign(this.fills, [fill.originChainId], [fill]);
-                assign(this.depositHashesToFills, [this.getDepositHash(fill)], [fill]);
-            }
-        };
-        // Update observed fills with ingested event data.
-        ["FilledRelay"].forEach((event) => {
-            if (eventsToQuery.includes(event)) {
-                queryFilledRelayEvents(event);
-            }
-        });
-        if (eventsToQuery.includes("EnabledDepositRoute")) {
-            const enableDepositsEvents = queryResults[eventsToQuery.indexOf("EnabledDepositRoute")].map((_event) => {
-                const event = _event;
-                return {
-                    ...event,
-                    originToken: toAddressType(event.originToken, CHAIN_IDs.MAINNET),
-                };
-            });
-            for (const event of enableDepositsEvents) {
-                assign(this.depositRoutes, [event.originToken.toBytes32(), event.destinationChainId], event.enabled);
-            }
-        }
-        if (eventsToQuery.includes("RelayedRootBundle")) {
-            const relayedRootBundleEvents = queryResults[eventsToQuery.indexOf("RelayedRootBundle")];
-            for (const event of relayedRootBundleEvents) {
-                this.rootBundleRelays.push(event);
-            }
-        }
-        if (eventsToQuery.includes("ExecutedRelayerRefundRoot")) {
-            const refundEvents = queryResults[eventsToQuery.indexOf("ExecutedRelayerRefundRoot")];
-            for (const _event of refundEvents) {
-                const event = _event;
-                this.relayerRefundExecutions.push({
-                    ...event,
-                    l2TokenAddress: toAddressType(event.l2TokenAddress, this.chainId),
-                    refundAddresses: event.refundAddresses.map((addr) => toAddressType(addr, this.chainId)),
-                });
-            }
-        }
-        if (eventsToQuery.includes("ClaimedRelayerRefund")) {
-            const claimedRelayerRefundEvents = (queryResults[eventsToQuery.indexOf("ClaimedRelayerRefund")] ??
-                []);
-            for (const event of claimedRelayerRefundEvents) {
-                this.claimedRelayerRefunds.push({
-                    ...event,
-                    amount: event.amount || event.claimAmount, // Note: This field is named differently in EVM and SVM
-                });
-            }
-        }
-        if (eventsToQuery.includes("BridgedToHubPool")) {
-            const bridgedToHubPoolEvents = (queryResults[eventsToQuery.indexOf("BridgedToHubPool")] ??
-                []);
-            for (const event of bridgedToHubPoolEvents) {
-                this.bridgedToHubPool.push(event);
-            }
-        }
-        if (duplicateEvents.length > 0) {
-            this.log("debug", "Duplicate events listed", {
-                duplicateEvents,
             });
-            this.log("error", "Duplicate events detected, check debug logs");
-        }
-        // Next iteration should start off from where this one ended.
-        this.currentTime = currentTime;
-        this.latestHeightSearched = searchEndBlock;
-        this.firstHeightToSearch = searchEndBlock + 1;
-        this.eventSearchConfig.to = undefined; // Caller can re-set on subsequent updates if necessary
-        this.isUpdated = true;
-        this.log("debug", `SpokePool client for chain ${this.chainId} updated!`, {
-            nextFirstHeightToSearch: this.firstHeightToSearch,
         });
-    }
+    };
     /**
      * Resolve a given timestamp to a block number on the HubPool chain via the HubPoolClient.
      * @param timestamp A single timestamp to be resolved via the HubPoolClient.
      * @returns The block number on the HubPool chain corresponding to the supplied timestamp.
      */
-    getBlockNumber(timestamp) {
-        return this.hubPoolClient?.getBlockNumber(timestamp) ?? Promise.resolve(MAX_BIG_INT.toNumber());
-    }
+    SpokePoolClient.prototype.getBlockNumber = function (timestamp) {
+        var _a, _b;
+        return (_b = (_a = this.hubPoolClient) === null || _a === void 0 ? void 0 : _a.getBlockNumber(timestamp)) !== null && _b !== void 0 ? _b : Promise.resolve(MAX_BIG_INT.toNumber());
+    };
     /**
      * For an array of timestamps, resolve each timestamp to a block number on the HubPool chain via the HubPoolClient.
      * @param timestamps Array of timestamps to be resolved to a block number via the HubPoolClient.
      * @returns A mapping of quoteTimestamp -> HubPool block number.
      */
-    getBlockNumbers(timestamps) {
-        return (this.hubPoolClient?.getBlockNumbers(timestamps) ??
-            Promise.resolve(Object.fromEntries(timestamps.map((timestamp) => [timestamp, MAX_BIG_INT.toNumber()]))));
-    }
+    SpokePoolClient.prototype.getBlockNumbers = function (timestamps) {
+        var _a, _b;
+        return ((_b = (_a = this.hubPoolClient) === null || _a === void 0 ? void 0 : _a.getBlockNumbers(timestamps)) !== null && _b !== void 0 ? _b : Promise.resolve(Object.fromEntries(timestamps.map(function (timestamp) { return [timestamp, MAX_BIG_INT.toNumber()]; }))));
+    };
     /**
      * Retrieves the destination token for a given deposit.
      * @param deposit The deposit to retrieve the destination token for.
      * @returns The destination token.
      */
-    getDestinationTokenForDeposit(deposit) {
+    SpokePoolClient.prototype.getDestinationTokenForDeposit = function (deposit) {
         if (!this.canResolveZeroAddressOutputToken(deposit)) {
             return toAddressType(ZERO_ADDRESS, CHAIN_IDs.MAINNET);
         }
         // L1 token should be resolved if we get here:
-        const l1Token = this.hubPoolClient.getL1TokenForL2TokenAtBlock(deposit.inputToken, deposit.originChainId, deposit.quoteBlockNumber);
-        const counterpartToken = this.hubPoolClient.getL2TokenForL1TokenAtBlock(l1Token, deposit.destinationChainId, deposit.quoteBlockNumber);
-        return counterpartToken ?? toAddressType(ZERO_ADDRESS, CHAIN_IDs.MAINNET);
-    }
+        var l1Token = this.hubPoolClient.getL1TokenForL2TokenAtBlock(deposit.inputToken, deposit.originChainId, deposit.quoteBlockNumber);
+        var counterpartToken = this.hubPoolClient.getL2TokenForL1TokenAtBlock(l1Token, deposit.destinationChainId, deposit.quoteBlockNumber);
+        return counterpartToken !== null && counterpartToken !== void 0 ? counterpartToken : toAddressType(ZERO_ADDRESS, CHAIN_IDs.MAINNET);
+    };
     /**
      * Performs a log for a specific level, message and data.
      * @param level The log level.
      * @param message The log message.
      * @param data Optional data to log.
      */
-    log(level, message, data) {
-        this.logger[level]({ at: "SpokePoolClient", chainId: this.chainId, message, ...data });
-    }
+    SpokePoolClient.prototype.log = function (level, message, data) {
+        this.logger[level](__assign({ at: "SpokePoolClient", chainId: this.chainId, message: message }, data));
+    };
     /**
      * Retrieves the current time from the SpokePool contract.
      * @returns The current time, which will be 0 if there has been no update() yet.
      */
-    getCurrentTime() {
+    SpokePoolClient.prototype.getCurrentTime = function () {
         return this.currentTime;
-    }
+    };
     /**
      * Determines whether a deposit originates from a lite chain.
      * @param deposit The deposit to evaluate.
      * @returns True if the deposit originates from a lite chain, false otherwise. If the hub pool client is not defined,
      *          this method will return false.
      */
-    isOriginLiteChain(deposit) {
-        return this.configStoreClient?.isChainLiteChainAtTimestamp(deposit.originChainId, deposit.quoteTimestamp) ?? false;
-    }
+    SpokePoolClient.prototype.isOriginLiteChain = function (deposit) {
+        var _a, _b;
+        return (_b = (_a = this.configStoreClient) === null || _a === void 0 ? void 0 : _a.isChainLiteChainAtTimestamp(deposit.originChainId, deposit.quoteTimestamp)) !== null && _b !== void 0 ? _b : false;
+    };
     /**
      * Determines whether the deposit destination chain is a lite chain.
      * @param deposit The deposit to evaluate.
      * @returns True if the deposit is destined to a lite chain, false otherwise. If the hub pool client is not defined,
      *          this method will return false.
      */
-    isDestinationLiteChain(deposit) {
-        return (this.configStoreClient?.isChainLiteChainAtTimestamp(deposit.destinationChainId, deposit.quoteTimestamp) ?? false);
-    }
-}
+    SpokePoolClient.prototype.isDestinationLiteChain = function (deposit) {
+        var _a, _b;
+        return ((_b = (_a = this.configStoreClient) === null || _a === void 0 ? void 0 : _a.isChainLiteChainAtTimestamp(deposit.destinationChainId, deposit.quoteTimestamp)) !== null && _b !== void 0 ? _b : false);
+    };
+    return SpokePoolClient;
+}(BaseAbstractClient));
+export { SpokePoolClient };
 //# sourceMappingURL=SpokePoolClient.js.map