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

package/dist/esm/relayFeeCalculator/relayFeeCalculator.js

@@ -1,12 +1,37 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import assert from "assert";
 import { DEFAULT_SIMULATED_RELAYER_ADDRESS, DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM, TOKEN_SYMBOLS_MAP, } from "../constants";
 import { BigNumber, MAX_BIG_INT, bnZero, fixedPointAdjustment, getTokenInfo, isDefined, max, min, nativeToToken, percent, toBN, toBNWei, compareAddressesSimple, ConvertDecimals, chainIsSvm, EvmAddress, SvmAddress, toAddressType, } from "../utils";
-export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];
-export const DEFAULT_LOGGER = {
-    debug: (...args) => console.debug(args),
-    info: (...args) => console.info(args),
-    warn: (...args) => console.warn(args),
-    error: (...args) => console.error(args),
+export var expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];
+export var DEFAULT_LOGGER = {
+    debug: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return console.debug(args);
+    },
+    info: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return console.info(args);
+    },
+    warn: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return console.warn(args);
+    },
+    error: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return console.error(args);
+    },
 };
 export function getDefaultRelayer(chainId) {
     return isDefined(chainId) && chainIsSvm(chainId)
@@ -14,18 +39,9 @@ export function getDefaultRelayer(chainId) {
         : EvmAddress.from(DEFAULT_SIMULATED_RELAYER_ADDRESS);
 }
 // Small amount to simulate filling with. Should be low enough to guarantee a successful fill.
-const safeOutputAmount = toBN(100);
-export class RelayFeeCalculator {
-    queries;
-    gasDiscountPercent;
-    capitalDiscountPercent;
-    feeLimitPercent;
-    nativeTokenDecimals;
-    capitalCostsConfig;
-    // For logging if set. This function should accept 2 args - severity (INFO, WARN, ERROR) and the logs data, which will
-    // be an object.
-    logger;
-    constructor(config, logger, destinationChainId) {
+var safeOutputAmount = toBN(100);
+var RelayFeeCalculator = /** @class */ (function () {
+    function RelayFeeCalculator(config, logger, destinationChainId) {
         assert(config, "config must be provided");
         if ("queries" in config) {
             this.queries = config.queries;
@@ -42,7 +58,8 @@ export class RelayFeeCalculator {
         assert(this.gasDiscountPercent >= 0 && this.gasDiscountPercent <= 100, "gasDiscountPercent must be between 0 and 100 percent");
         assert(this.capitalDiscountPercent >= 0 && this.capitalDiscountPercent <= 100, "capitalDiscountPercent must be between 0 and 100 percent");
         assert(this.feeLimitPercent >= 0 && this.feeLimitPercent <= 100, "feeLimitPercent must be between 0 and 100 percent");
-        this.capitalCostsConfig = Object.fromEntries(Object.entries(config.capitalCostsConfig).map(([token, capitalCosts]) => {
+        this.capitalCostsConfig = Object.fromEntries(Object.entries(config.capitalCostsConfig).map(function (_a) {
+            var token = _a[0], capitalCosts = _a[1];
             return [token.toUpperCase(), RelayFeeCalculator.validateAndTransformCapitalCostsConfigOverride(capitalCosts)];
         }));
         assert(Object.keys(this.capitalCostsConfig).length > 0, "capitalCostsConfig must have at least one entry");
@@ -60,25 +77,26 @@ export class RelayFeeCalculator {
      * CapitalCostConfig, then we need to convert it to a CapitalCostConfigOverride with the default config set with no route
      * overrides.
      */
-    static capitalCostConfigIsOverride(config) {
+    RelayFeeCalculator.capitalCostConfigIsOverride = function (config) {
         return config.default !== undefined;
-    }
+    };
     /**
      * Validates a CapitalCostConfigOverride or a CapitalCostConfig.
      * @param capitalCosts CapitalCostConfig or CapitalCostConfigOverride
      * @returns CapitalCostConfigOverride
      */
-    static validateAndTransformCapitalCostsConfigOverride(capitalCosts) {
+    RelayFeeCalculator.validateAndTransformCapitalCostsConfigOverride = function (capitalCosts) {
         // We need to first convert the config to a baseline type. This is because the config can be either a CapitalCostConfig
         // or a CapitalCostConfigOverride. If it's a CapitalCostConfig, then we need to convert it to a CapitalCostConfigOverride with
         // the default config set with no route overrides.
-        const config = this.capitalCostConfigIsOverride(capitalCosts)
+        var config = this.capitalCostConfigIsOverride(capitalCosts)
             ? capitalCosts
             : { default: capitalCosts };
         // Validate the default config.
         this.validateCapitalCostsConfig(config.default);
         // Iterate over all the route overrides and validate them.
-        for (const toChainIdRoutes of Object.values(config.routeOverrides || {})) {
+        for (var _i = 0, _a = Object.values(config.routeOverrides || {}); _i < _a.length; _i++) {
+            var toChainIdRoutes = _a[_i];
             Object.values(toChainIdRoutes).forEach(this.validateCapitalCostsConfig);
         }
         // Validate origin chain overrides
@@ -86,18 +104,18 @@ export class RelayFeeCalculator {
         // Validate destination chain overrides
         Object.values(config.destinationChainOverrides || {}).forEach(this.validateCapitalCostsConfig);
         return config;
-    }
+    };
     /**
      * Validates a CapitalCostConfig.
      * @param capitalCosts CapitalCostConfig
      */
-    static validateCapitalCostsConfig(capitalCosts) {
+    RelayFeeCalculator.validateCapitalCostsConfig = function (capitalCosts) {
         assert(toBN(capitalCosts.upperBound).lt(toBNWei("1")), "upper bound must be < 100%");
         assert(capitalCosts.decimals > 0 && capitalCosts.decimals <= 18, "invalid decimals");
-    }
-    getTokenPrice(tokenSymbol) {
+    };
+    RelayFeeCalculator.prototype.getTokenPrice = function (tokenSymbol) {
         return this.queries.getTokenPrice(tokenSymbol);
-    }
+    };
     /**
      * Calculate the gas fee as a % of the amount to relay.
      * @param deposit A valid deposit object to reason about
@@ -117,73 +135,98 @@ export class RelayFeeCalculator {
      *       a message & recipient contract is provided as this function may not simulate with
      *       the correct parameters to see a full fill.
      */
-    async gasFeePercent(deposit, outputAmount, outputTokenInfo, simulateZeroFill = false, relayerAddress = getDefaultRelayer(deposit.destinationChainId), _tokenPrice, gasPrice, gasLimit, _tokenGasCost, transport) {
-        if (toBN(outputAmount).eq(bnZero))
-            return MAX_BIG_INT;
-        // Reduce the output amount to simulate a full fill with a lower value to estimate
-        // the fill cost accurately without risking a failure due to insufficient balance.
-        const simulatedAmount = simulateZeroFill ? safeOutputAmount : toBN(outputAmount);
-        deposit = { ...deposit, outputAmount: simulatedAmount };
-        const getGasCosts = this.queries
-            .getGasCosts(deposit, relayerAddress, { gasPrice, gasUnits: gasLimit, transport })
-            .then(({ tokenGasCost }) => tokenGasCost)
-            .catch((error) => {
-            this.logger.error({
-                at: "sdk/gasFeePercent",
-                message: "Error while fetching gas costs",
-                error,
-                simulateZeroFill,
-                deposit,
+    RelayFeeCalculator.prototype.gasFeePercent = function (deposit_1, outputAmount_1, outputTokenInfo_1) {
+        return __awaiter(this, arguments, void 0, function (deposit, outputAmount, outputTokenInfo, simulateZeroFill, relayerAddress, _tokenPrice, gasPrice, gasLimit, _tokenGasCost, transport) {
+            var simulatedAmount, getGasCosts, _a, tokenGasCost, tokenPrice, gasFeesInToken;
+            var _this = this;
+            if (simulateZeroFill === void 0) { simulateZeroFill = false; }
+            if (relayerAddress === void 0) { relayerAddress = getDefaultRelayer(deposit.destinationChainId); }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (toBN(outputAmount).eq(bnZero))
+                            return [2 /*return*/, MAX_BIG_INT];
+                        simulatedAmount = simulateZeroFill ? safeOutputAmount : toBN(outputAmount);
+                        deposit = __assign(__assign({}, deposit), { outputAmount: simulatedAmount });
+                        getGasCosts = this.queries
+                            .getGasCosts(deposit, relayerAddress, { gasPrice: gasPrice, gasUnits: gasLimit, transport: transport })
+                            .then(function (_a) {
+                            var tokenGasCost = _a.tokenGasCost;
+                            return tokenGasCost;
+                        })
+                            .catch(function (error) {
+                            _this.logger.error({
+                                at: "sdk/gasFeePercent",
+                                message: "Error while fetching gas costs",
+                                error: error,
+                                simulateZeroFill: simulateZeroFill,
+                                deposit: deposit,
+                            });
+                            throw error;
+                        });
+                        return [4 /*yield*/, Promise.all([
+                                _tokenGasCost ? Promise.resolve(_tokenGasCost) : getGasCosts,
+                                this.resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit),
+                            ])];
+                    case 1:
+                        _a = _b.sent(), tokenGasCost = _a[0], tokenPrice = _a[1];
+                        gasFeesInToken = nativeToToken(tokenGasCost, tokenPrice, outputTokenInfo.decimals, this.nativeTokenDecimals);
+                        return [2 /*return*/, percent(gasFeesInToken, outputAmount.toString())];
+                }
             });
-            throw error;
         });
-        const [tokenGasCost, tokenPrice] = await Promise.all([
-            _tokenGasCost ? Promise.resolve(_tokenGasCost) : getGasCosts,
-            this.resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit),
-        ]);
-        const gasFeesInToken = nativeToToken(tokenGasCost, tokenPrice, outputTokenInfo.decimals, this.nativeTokenDecimals);
-        return percent(gasFeesInToken, outputAmount.toString());
-    }
+    };
     /**
      * Calculate the auxiliary native token fee as a % of the amount to relay.
      * Treats auxiliary native outlay as value forwarded to user, reported separately.
      */
-    async auxNativeFeePercent(deposit, outputAmount, outputTokenInfo, _tokenPrice) {
-        if (toBN(outputAmount).eq(bnZero))
-            return MAX_BIG_INT;
-        let auxNativeCost = bnZero;
-        try {
-            auxNativeCost = this.queries.getAuxiliaryNativeTokenCost(deposit);
-        }
-        catch (error) {
-            this.logger.error({
-                at: "sdk/auxNativeFeePercent",
-                message: "Error while fetching auxiliary native token cost",
-                error,
-                destinationChainId: deposit.destinationChainId,
-                inputToken: deposit.inputToken,
+    RelayFeeCalculator.prototype.auxNativeFeePercent = function (deposit, outputAmount, outputTokenInfo, _tokenPrice) {
+        return __awaiter(this, void 0, void 0, function () {
+            var auxNativeCost, tokenPrice, auxFeesInToken;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (toBN(outputAmount).eq(bnZero))
+                            return [2 /*return*/, MAX_BIG_INT];
+                        auxNativeCost = bnZero;
+                        try {
+                            auxNativeCost = this.queries.getAuxiliaryNativeTokenCost(deposit);
+                        }
+                        catch (error) {
+                            this.logger.error({
+                                at: "sdk/auxNativeFeePercent",
+                                message: "Error while fetching auxiliary native token cost",
+                                error: error,
+                                destinationChainId: deposit.destinationChainId,
+                                inputToken: deposit.inputToken,
+                            });
+                            throw error;
+                        }
+                        return [4 /*yield*/, this.resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit)];
+                    case 1:
+                        tokenPrice = _a.sent();
+                        auxFeesInToken = nativeToToken(auxNativeCost, tokenPrice, outputTokenInfo.decimals, this.nativeTokenDecimals);
+                        return [2 /*return*/, percent(auxFeesInToken, outputAmount)];
+                }
             });
-            throw error;
-        }
-        const tokenPrice = await this.resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit);
-        const auxFeesInToken = nativeToToken(auxNativeCost, tokenPrice, outputTokenInfo.decimals, this.nativeTokenDecimals);
-        return percent(auxFeesInToken, outputAmount);
-    }
+        });
+    };
     // Note: these variables are unused now, but may be needed in future versions of this function that are more complex.
-    capitalFeePercent(_outputAmount, _tokenSymbol, _originRoute, _destinationRoute) {
+    RelayFeeCalculator.prototype.capitalFeePercent = function (_outputAmount, _tokenSymbol, _originRoute, _destinationRoute) {
+        var _a, _b, _c, _d, _e, _f;
         // If amount is 0, then the capital fee % should be the max 100%
         if (toBN(_outputAmount).eq(toBN(0)))
             return MAX_BIG_INT;
         // V0: Ensure that there is a capital fee available for the token.
         // If not, then we should throw an error because this is indicative
         // of a misconfiguration.
-        const tokenCostConfig = this.capitalCostsConfig[_tokenSymbol.toUpperCase()];
+        var tokenCostConfig = this.capitalCostsConfig[_tokenSymbol.toUpperCase()];
         if (!isDefined(tokenCostConfig)) {
             this.logger.error({
                 at: "sdk/capitalFeePercent",
-                message: `No capital fee available for token ${_tokenSymbol}`,
+                message: "No capital fee available for token ".concat(_tokenSymbol),
             });
-            throw new Error(`No capital cost config available for token ${_tokenSymbol}`);
+            throw new Error("No capital cost config available for token ".concat(_tokenSymbol));
         }
         // V1: Charge fee that scales with size. This will charge a fee % based on a linear fee curve with a "kink" at a
         // cutoff in the same units as _amountToRelay. Before the kink, the fee % will increase linearly from a lower
@@ -195,77 +238,85 @@ export class RelayFeeCalculator {
             // 2. Destination chain overrides
             // 3. Origin chain overrides
             // 4. Default config
-            const routeOverride = tokenCostConfig?.routeOverrides?.[_originRoute || ""]?.[_destinationRoute || ""];
-            const destinationChainOverride = tokenCostConfig?.destinationChainOverrides?.[_destinationRoute || ""];
-            const originChainOverride = tokenCostConfig?.originChainOverrides?.[_originRoute || ""];
-            const config = routeOverride ?? destinationChainOverride ?? originChainOverride ?? tokenCostConfig.default;
+            var routeOverride = (_b = (_a = tokenCostConfig === null || tokenCostConfig === void 0 ? void 0 : tokenCostConfig.routeOverrides) === null || _a === void 0 ? void 0 : _a[_originRoute || ""]) === null || _b === void 0 ? void 0 : _b[_destinationRoute || ""];
+            var destinationChainOverride = (_c = tokenCostConfig === null || tokenCostConfig === void 0 ? void 0 : tokenCostConfig.destinationChainOverrides) === null || _c === void 0 ? void 0 : _c[_destinationRoute || ""];
+            var originChainOverride = (_d = tokenCostConfig === null || tokenCostConfig === void 0 ? void 0 : tokenCostConfig.originChainOverrides) === null || _d === void 0 ? void 0 : _d[_originRoute || ""];
+            var config = (_f = (_e = routeOverride !== null && routeOverride !== void 0 ? routeOverride : destinationChainOverride) !== null && _e !== void 0 ? _e : originChainOverride) !== null && _f !== void 0 ? _f : tokenCostConfig.default;
             // Check and log warnings for configuration conflicts
             this.warnIfConfigConflicts(_tokenSymbol, _originRoute || "", _destinationRoute || "", routeOverride, destinationChainOverride, originChainOverride);
             // Scale amount "y" to 18 decimals.
-            const y = toBN(_outputAmount).mul(toBNWei("1", 18 - config.decimals));
+            var y = toBN(_outputAmount).mul(toBNWei("1", 18 - config.decimals));
             // At a minimum, the fee will be equal to lower bound fee * y
-            const minCharge = toBN(config.lowerBound).mul(y).div(fixedPointAdjustment);
+            var minCharge = toBN(config.lowerBound).mul(y).div(fixedPointAdjustment);
             // Charge an increasing marginal fee % up to min(cutoff, y). If y is very close to the cutoff, the fee %
             // will be equal to half the sum of (upper bound + lower bound).
-            const yTriangle = min(config.cutoff, y);
+            var yTriangle = min(config.cutoff, y);
             // triangleSlope is slope of fee curve from lower bound to upper bound. If cutoff is 0, slope is 0.
             // triangleCharge is interval of curve from 0 to y for curve = triangleSlope * y
-            const triangleSlope = toBN(config.cutoff).eq(toBN(0))
+            var triangleSlope = toBN(config.cutoff).eq(toBN(0))
                 ? toBN(0)
                 : toBN(config.upperBound).sub(config.lowerBound).mul(fixedPointAdjustment).div(config.cutoff);
-            const triangleHeight = triangleSlope.mul(yTriangle).div(fixedPointAdjustment);
-            const triangleCharge = triangleHeight.mul(yTriangle).div(toBNWei(2));
+            var triangleHeight = triangleSlope.mul(yTriangle).div(fixedPointAdjustment);
+            var triangleCharge = triangleHeight.mul(yTriangle).div(toBNWei(2));
             // For any amounts above the cutoff, the marginal fee % will not increase but will be fixed at the upper bound
             // value.
-            const yRemainder = max(toBN(0), y.sub(config.cutoff));
-            const remainderCharge = yRemainder.mul(toBN(config.upperBound).sub(config.lowerBound)).div(fixedPointAdjustment);
+            var yRemainder = max(toBN(0), y.sub(config.cutoff));
+            var remainderCharge = yRemainder.mul(toBN(config.upperBound).sub(config.lowerBound)).div(fixedPointAdjustment);
             return minCharge.add(triangleCharge).add(remainderCharge).mul(fixedPointAdjustment).div(y);
         }
-    }
+    };
     /**
      * Checks for configuration conflicts across all token symbols and their associated chain configurations.
      * This method examines the capital costs configuration for each token and identifies any overlapping
      * or conflicting configurations between route overrides, destination chain overrides, and origin chain overrides.
      * If conflicts are found, warnings will be logged via the warnIfConfigConflicts method.
      */
-    checkAllConfigConflicts() {
-        for (const [tokenSymbol, tokenConfig] of Object.entries(this.capitalCostsConfig)) {
+    RelayFeeCalculator.prototype.checkAllConfigConflicts = function () {
+        var _a, _b, _c, _d;
+        var _loop_1 = function (tokenSymbol, tokenConfig) {
             // Get all origin chains that have specific configurations
-            const originChains = new Set(Object.keys(tokenConfig.originChainOverrides || {}));
+            var originChains = new Set(Object.keys(tokenConfig.originChainOverrides || {}));
             // Get all destination chains that have specific configurations
-            const destChains = new Set(Object.keys(tokenConfig.destinationChainOverrides || {}));
+            var destChains = new Set(Object.keys(tokenConfig.destinationChainOverrides || {}));
             // Add all chains from route overrides
             if (tokenConfig.routeOverrides) {
-                Object.keys(tokenConfig.routeOverrides).forEach((originChain) => {
+                Object.keys(tokenConfig.routeOverrides).forEach(function (originChain) {
                     originChains.add(originChain);
-                    Object.keys(tokenConfig.routeOverrides[originChain]).forEach((destChain) => {
+                    Object.keys(tokenConfig.routeOverrides[originChain]).forEach(function (destChain) {
                         destChains.add(destChain);
                     });
                 });
             }
             // If there are no specific chain configurations, just check the default case
             if (originChains.size === 0 && destChains.size === 0) {
-                continue;
+                return "continue";
             }
             // Check for conflicts between all combinations of origin and destination chains
-            for (const originChain of Array.from(originChains)) {
-                for (const destChain of Array.from(destChains)) {
-                    const routeOverride = tokenConfig.routeOverrides?.[originChain]?.[destChain];
-                    const destinationChainOverride = tokenConfig.destinationChainOverrides?.[destChain];
-                    const originChainOverride = tokenConfig.originChainOverrides?.[originChain];
-                    this.warnIfConfigConflicts(tokenSymbol, originChain, destChain, routeOverride, destinationChainOverride, originChainOverride);
+            for (var _g = 0, _h = Array.from(originChains); _g < _h.length; _g++) {
+                var originChain = _h[_g];
+                for (var _j = 0, _k = Array.from(destChains); _j < _k.length; _j++) {
+                    var destChain = _k[_j];
+                    var routeOverride = (_b = (_a = tokenConfig.routeOverrides) === null || _a === void 0 ? void 0 : _a[originChain]) === null || _b === void 0 ? void 0 : _b[destChain];
+                    var destinationChainOverride = (_c = tokenConfig.destinationChainOverrides) === null || _c === void 0 ? void 0 : _c[destChain];
+                    var originChainOverride = (_d = tokenConfig.originChainOverrides) === null || _d === void 0 ? void 0 : _d[originChain];
+                    this_1.warnIfConfigConflicts(tokenSymbol, originChain, destChain, routeOverride, destinationChainOverride, originChainOverride);
                 }
             }
+        };
+        var this_1 = this;
+        for (var _i = 0, _e = Object.entries(this.capitalCostsConfig); _i < _e.length; _i++) {
+            var _f = _e[_i], tokenSymbol = _f[0], tokenConfig = _f[1];
+            _loop_1(tokenSymbol, tokenConfig);
         }
-    }
+    };
     /**
      * Log a warning if multiple configuration types apply to the same route
      * @private
      */
-    warnIfConfigConflicts(tokenSymbol, originChain, destChain, routeOverride, destinationChainOverride, originChainOverride) {
-        const overrideCount = [routeOverride, destinationChainOverride, originChainOverride].filter(Boolean).length;
+    RelayFeeCalculator.prototype.warnIfConfigConflicts = function (tokenSymbol, originChain, destChain, routeOverride, destinationChainOverride, originChainOverride) {
+        var overrideCount = [routeOverride, destinationChainOverride, originChainOverride].filter(Boolean).length;
         if (overrideCount > 1) {
-            const configUsed = routeOverride
+            var configUsed = routeOverride
                 ? "route override"
                 : destinationChainOverride
                     ? "destination chain override"
@@ -274,14 +325,14 @@ export class RelayFeeCalculator {
                         : "default override";
             this.logger.warn({
                 at: "RelayFeeCalculator",
-                message: `Multiple configurations found for token ${tokenSymbol} from chain ${originChain} to chain ${destChain}`,
-                configUsed,
-                routeOverride,
-                destinationChainOverride,
-                originChainOverride,
+                message: "Multiple configurations found for token ".concat(tokenSymbol, " from chain ").concat(originChain, " to chain ").concat(destChain),
+                configUsed: configUsed,
+                routeOverride: routeOverride,
+                destinationChainOverride: destinationChainOverride,
+                originChainOverride: originChainOverride,
             });
         }
-    }
+    };
     /**
      * Retrieves the relayer fee details for a deposit.
      * @param deposit A valid deposit object to reason about
@@ -297,110 +348,147 @@ export class RelayFeeCalculator {
      * @param gasUnits Optional gas units to use for the simulation
      * @returns A resulting `RelayerFeeDetails` object
      */
-    async relayerFeeDetails(deposit, outputAmount, simulateZeroFill = false, relayerAddress = getDefaultRelayer(deposit.destinationChainId), _tokenPrice, gasPrice, gasUnits, tokenGasCost) {
-        // If the amount to relay is not provided, then we
-        // should use the full deposit amount.
-        outputAmount ??= deposit.outputAmount;
-        const { inputTokenInfo, outputTokenInfo } = this.resolveInOutTokenInfos(deposit);
-        const tokenPrice = await this.resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit);
-        const { tokenGasCost: _tokenGasCost, nativeGasCost: _nativeGasCost } = tokenGasCost && gasUnits
-            ? { tokenGasCost, nativeGasCost: BigNumber.from(gasUnits) }
-            : await this.queries
-                .getGasCosts(deposit, relayerAddress, { gasPrice, gasUnits })
-                .then(({ tokenGasCost, nativeGasCost }) => ({ tokenGasCost, nativeGasCost }))
-                .catch((error) => {
-                this.logger.error({
-                    at: "sdk/relayerFeeDetails",
-                    message: "Error while fetching gas costs",
-                    error,
-                    simulateZeroFill,
-                    deposit,
-                });
-                throw error;
+    RelayFeeCalculator.prototype.relayerFeeDetails = function (deposit_1, outputAmount_1) {
+        return __awaiter(this, arguments, void 0, function (deposit, outputAmount, simulateZeroFill, relayerAddress, _tokenPrice, gasPrice, gasUnits, tokenGasCost) {
+            var _a, inputTokenInfo, outputTokenInfo, tokenPrice, _b, _tokenGasCost, _nativeGasCost, _c, gasFeePercent, outToInDecimals, gasFeeTotal, capitalFeePercent, capitalFeeTotal, auxNativeFeePercent, auxNativeFeeTotal, auxNativeDiscountPercent, relayFeePercent, relayFeeTotal, maxGasFeePercent, minDeposit, isAmountTooLow;
+            var _this = this;
+            if (simulateZeroFill === void 0) { simulateZeroFill = false; }
+            if (relayerAddress === void 0) { relayerAddress = getDefaultRelayer(deposit.destinationChainId); }
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        // If the amount to relay is not provided, then we
+                        // should use the full deposit amount.
+                        outputAmount !== null && outputAmount !== void 0 ? outputAmount : (outputAmount = deposit.outputAmount);
+                        _a = this.resolveInOutTokenInfos(deposit), inputTokenInfo = _a.inputTokenInfo, outputTokenInfo = _a.outputTokenInfo;
+                        return [4 /*yield*/, this.resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit)];
+                    case 1:
+                        tokenPrice = _d.sent();
+                        if (!(tokenGasCost && gasUnits)) return [3 /*break*/, 2];
+                        _c = { tokenGasCost: tokenGasCost, nativeGasCost: BigNumber.from(gasUnits) };
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.queries
+                            .getGasCosts(deposit, relayerAddress, { gasPrice: gasPrice, gasUnits: gasUnits })
+                            .then(function (_a) {
+                            var tokenGasCost = _a.tokenGasCost, nativeGasCost = _a.nativeGasCost;
+                            return ({ tokenGasCost: tokenGasCost, nativeGasCost: nativeGasCost });
+                        })
+                            .catch(function (error) {
+                            _this.logger.error({
+                                at: "sdk/relayerFeeDetails",
+                                message: "Error while fetching gas costs",
+                                error: error,
+                                simulateZeroFill: simulateZeroFill,
+                                deposit: deposit,
+                            });
+                            throw error;
+                        })];
+                    case 3:
+                        _c = _d.sent();
+                        _d.label = 4;
+                    case 4:
+                        _b = _c, _tokenGasCost = _b.tokenGasCost, _nativeGasCost = _b.nativeGasCost;
+                        return [4 /*yield*/, this.gasFeePercent(deposit, outputAmount, outputTokenInfo, simulateZeroFill, relayerAddress, tokenPrice, gasPrice, _nativeGasCost, _tokenGasCost)];
+                    case 5:
+                        gasFeePercent = _d.sent();
+                        outToInDecimals = ConvertDecimals(outputTokenInfo.decimals, inputTokenInfo.decimals);
+                        gasFeeTotal = gasFeePercent.mul(outToInDecimals(outputAmount.toString())).div(fixedPointAdjustment);
+                        capitalFeePercent = this.capitalFeePercent(outputAmount, inputTokenInfo.symbol, deposit.originChainId.toString(), deposit.destinationChainId.toString());
+                        capitalFeeTotal = capitalFeePercent.mul(outToInDecimals(outputAmount.toString())).div(fixedPointAdjustment);
+                        return [4 /*yield*/, this.auxNativeFeePercent(deposit, outputAmount, outputTokenInfo, tokenPrice)];
+                    case 6:
+                        auxNativeFeePercent = _d.sent();
+                        auxNativeFeeTotal = auxNativeFeePercent
+                            .mul(outToInDecimals(outputAmount.toString()))
+                            .div(fixedPointAdjustment);
+                        auxNativeDiscountPercent = this.gasDiscountPercent;
+                        relayFeePercent = gasFeePercent.add(capitalFeePercent).add(auxNativeFeePercent);
+                        relayFeeTotal = gasFeeTotal.add(capitalFeeTotal).add(auxNativeFeeTotal);
+                        maxGasFeePercent = max(toBNWei(this.feeLimitPercent / 100)
+                            .sub(capitalFeePercent)
+                            .sub(auxNativeFeePercent), toBN(0));
+                        if (maxGasFeePercent.eq(toBN(0))) {
+                            minDeposit = MAX_BIG_INT;
+                            isAmountTooLow = true;
+                        }
+                        else {
+                            minDeposit = gasFeeTotal.mul(fixedPointAdjustment).div(maxGasFeePercent);
+                            isAmountTooLow = toBN(outputAmount).lt(minDeposit);
+                        }
+                        return [2 /*return*/, {
+                                amountToRelay: outputAmount.toString(),
+                                tokenSymbol: inputTokenInfo.symbol,
+                                gasFeePercent: gasFeePercent.toString(),
+                                gasFeeTotal: gasFeeTotal.toString(),
+                                gasUnits: _nativeGasCost.toString(),
+                                gasDiscountPercent: this.gasDiscountPercent,
+                                auxNativeFeePercent: auxNativeFeePercent.toString(),
+                                auxNativeFeeTotal: auxNativeFeeTotal.toString(),
+                                auxNativeDiscountPercent: auxNativeDiscountPercent,
+                                capitalFeePercent: capitalFeePercent.toString(),
+                                capitalFeeTotal: capitalFeeTotal.toString(),
+                                capitalDiscountPercent: this.capitalDiscountPercent,
+                                relayFeePercent: relayFeePercent.toString(),
+                                relayFeeTotal: relayFeeTotal.toString(),
+                                feeLimitPercent: this.feeLimitPercent,
+                                maxGasFeePercent: maxGasFeePercent.toString(),
+                                minDeposit: minDeposit.toString(),
+                                isAmountTooLow: isAmountTooLow,
+                            }];
+                }
             });
-        const gasFeePercent = await this.gasFeePercent(deposit, outputAmount, outputTokenInfo, simulateZeroFill, relayerAddress, tokenPrice, gasPrice, _nativeGasCost, _tokenGasCost);
-        const outToInDecimals = ConvertDecimals(outputTokenInfo.decimals, inputTokenInfo.decimals);
-        const gasFeeTotal = gasFeePercent.mul(outToInDecimals(outputAmount.toString())).div(fixedPointAdjustment);
-        const capitalFeePercent = this.capitalFeePercent(outputAmount, inputTokenInfo.symbol, deposit.originChainId.toString(), deposit.destinationChainId.toString());
-        const capitalFeeTotal = capitalFeePercent.mul(outToInDecimals(outputAmount.toString())).div(fixedPointAdjustment);
-        const auxNativeFeePercent = await this.auxNativeFeePercent(deposit, outputAmount, outputTokenInfo, tokenPrice);
-        const auxNativeFeeTotal = auxNativeFeePercent
-            .mul(outToInDecimals(outputAmount.toString()))
-            .div(fixedPointAdjustment);
-        const auxNativeDiscountPercent = this.gasDiscountPercent;
-        const relayFeePercent = gasFeePercent.add(capitalFeePercent).add(auxNativeFeePercent);
-        const relayFeeTotal = gasFeeTotal.add(capitalFeeTotal).add(auxNativeFeeTotal);
-        // We don't want the relayer to incur an excessive gas fee charge as a % of the deposited total. The maximum
-        // gas fee % charged is equal to the remaining fee % leftover after subtracting the capital fee % and aux fee %
-        // from the fee limit %. We then compute the minimum deposited amount required to not exceed the maximum
-        // gas fee %: maxGasFeePercent = gasFeeTotal / minDeposit. Refactor this to figure out the minDeposit:
-        // minDeposit = gasFeeTotal / maxGasFeePercent, and subsequently determine
-        // isAmountTooLow = amountToRelay < minDeposit.
-        const maxGasFeePercent = max(toBNWei(this.feeLimitPercent / 100)
-            .sub(capitalFeePercent)
-            .sub(auxNativeFeePercent), toBN(0));
-        // If maxGasFee % is 0, then the min deposit should be infinite because there is no deposit amount that would
-        // incur a non zero gas fee % charge. In this case, isAmountTooLow should always be true.
-        let minDeposit, isAmountTooLow;
-        if (maxGasFeePercent.eq(toBN(0))) {
-            minDeposit = MAX_BIG_INT;
-            isAmountTooLow = true;
-        }
-        else {
-            minDeposit = gasFeeTotal.mul(fixedPointAdjustment).div(maxGasFeePercent);
-            isAmountTooLow = toBN(outputAmount).lt(minDeposit);
-        }
-        return {
-            amountToRelay: outputAmount.toString(),
-            tokenSymbol: inputTokenInfo.symbol,
-            gasFeePercent: gasFeePercent.toString(),
-            gasFeeTotal: gasFeeTotal.toString(),
-            gasUnits: _nativeGasCost.toString(),
-            gasDiscountPercent: this.gasDiscountPercent,
-            auxNativeFeePercent: auxNativeFeePercent.toString(),
-            auxNativeFeeTotal: auxNativeFeeTotal.toString(),
-            auxNativeDiscountPercent,
-            capitalFeePercent: capitalFeePercent.toString(),
-            capitalFeeTotal: capitalFeeTotal.toString(),
-            capitalDiscountPercent: this.capitalDiscountPercent,
-            relayFeePercent: relayFeePercent.toString(),
-            relayFeeTotal: relayFeeTotal.toString(),
-            feeLimitPercent: this.feeLimitPercent,
-            maxGasFeePercent: maxGasFeePercent.toString(),
-            minDeposit: minDeposit.toString(),
-            isAmountTooLow,
-        };
-    }
-    resolveInOutTokenInfos(deposit, tokenMapping = TOKEN_SYMBOLS_MAP) {
-        const { inputToken, destinationChainId, originChainId } = deposit;
+        });
+    };
+    RelayFeeCalculator.prototype.resolveInOutTokenInfos = function (deposit, tokenMapping) {
+        if (tokenMapping === void 0) { tokenMapping = TOKEN_SYMBOLS_MAP; }
+        var inputToken = deposit.inputToken, destinationChainId = deposit.destinationChainId, originChainId = deposit.originChainId;
         // It's fine if we resolve a destination token which is not the "canonical" L1 token (e.g. USDB for DAI or USDC.e for USDC), since `getTokenInfo` will re-map
         // the output token to the canonical version. What matters here is that we find an entry in the token map which has defined addresses for BOTH the origin
         // and destination chain. This prevents the call to `getTokenInfo` to mistakenly return token info for a token which has a defined address on origin and an
         // undefined address on destination.
-        const destinationChainTokenDetails = Object.values(tokenMapping).find((details) => compareAddressesSimple(details.addresses[originChainId], inputToken.toNative()) &&
-            isDefined(details.addresses[destinationChainId]));
-        const outputToken = deposit.outputToken.isZeroAddress()
+        var destinationChainTokenDetails = Object.values(tokenMapping).find(function (details) {
+            return compareAddressesSimple(details.addresses[originChainId], inputToken.toNative()) &&
+                isDefined(details.addresses[destinationChainId]);
+        });
+        var outputToken = deposit.outputToken.isZeroAddress()
             ? toAddressType(destinationChainTokenDetails.addresses[destinationChainId], destinationChainId)
             : deposit.outputToken;
-        const outputTokenInfo = getTokenInfo(outputToken, destinationChainId, tokenMapping);
-        const inputTokenInfo = getTokenInfo(inputToken, originChainId, tokenMapping);
+        var outputTokenInfo = getTokenInfo(outputToken, destinationChainId, tokenMapping);
+        var inputTokenInfo = getTokenInfo(inputToken, originChainId, tokenMapping);
         if (!isDefined(outputTokenInfo) || !isDefined(inputTokenInfo)) {
-            throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
+            throw new Error("Could not find token information for ".concat(inputToken, " or ").concat(outputToken));
         }
-        return { inputTokenInfo, outputTokenInfo };
-    }
-    async resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit) {
-        return (_tokenPrice ??
-            (await this.queries.getTokenPrice(outputTokenInfo.symbol).catch((error) => {
-                this.logger.error({
-                    at: "sdk/resolveTokenPrice",
-                    message: "Error while fetching token price",
-                    error,
-                    destinationChainId: deposit.destinationChainId,
-                    inputToken: deposit.inputToken,
-                });
-                throw error;
-            })));
-    }
-}
+        return { inputTokenInfo: inputTokenInfo, outputTokenInfo: outputTokenInfo };
+    };
+    RelayFeeCalculator.prototype.resolveTokenPrice = function (outputTokenInfo, _tokenPrice, deposit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(_tokenPrice !== null && _tokenPrice !== void 0)) return [3 /*break*/, 1];
+                        _a = _tokenPrice;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.queries.getTokenPrice(outputTokenInfo.symbol).catch(function (error) {
+                            _this.logger.error({
+                                at: "sdk/resolveTokenPrice",
+                                message: "Error while fetching token price",
+                                error: error,
+                                destinationChainId: deposit.destinationChainId,
+                                inputToken: deposit.inputToken,
+                            });
+                            throw error;
+                        })];
+                    case 2:
+                        _a = (_b.sent());
+                        _b.label = 3;
+                    case 3: return [2 /*return*/, (_a)];
+                }
+            });
+        });
+    };
+    return RelayFeeCalculator;
+}());
+export { RelayFeeCalculator };
 //# sourceMappingURL=relayFeeCalculator.js.map