@avail-project/ca-common 1.0.0-beta.1

package/dist/cjs/xcs/autochoice.js

@@ -0,0 +1,374 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoSelectionError = void 0;
+exports.aggregateAggregators = aggregateAggregators;
+exports.autoSelectSources = autoSelectSources;
+exports.determineDestinationSwaps = determineDestinationSwaps;
+exports.liquidateInputHoldings = liquidateInputHoldings;
+exports.destinationSwapWithExactIn = destinationSwapWithExactIn;
+const tslib_1 = require("tslib");
+const es_toolkit_1 = require("es-toolkit");
+const viem_1 = require("viem");
+const decimal_js_1 = tslib_1.__importDefault(require("decimal.js"));
+const iface_1 = require("./iface");
+const data_1 = require("../data");
+class AutoSelectionError extends Error {
+}
+exports.AutoSelectionError = AutoSelectionError;
+const safetyMultiplier = new decimal_js_1.default("1.025");
+async function aggregateAggregators(requests, aggregators, mode) {
+    const responses = await Promise.all(aggregators.map(async (agg) => {
+        let quotes;
+        try {
+            quotes = await agg.getQuotes(requests);
+        }
+        catch (e) {
+            console.log("XCS | Failed to get quote from", agg, "in aggregateAggregators.", requests, "with:", e);
+            quotes = new Array(requests.length).fill(null);
+        }
+        return {
+            quotes,
+            agg,
+        };
+    }));
+    const final = new Array(requests.length);
+    switch (mode) {
+        case 0 /* AggregateAggregatorsMode.MaximizeOutput */: {
+            for (let i = 0; i < requests.length; i++) {
+                const best = (0, data_1.maxByBigInt)(responses.map((ra) => ({ quote: ra.quotes[i], aggregator: ra.agg })), (r) => r.quote?.outputAmountMinimum ?? 0n);
+                if (best != null) {
+                    final[i] = best;
+                }
+                else {
+                    final[i] = {
+                        quote: null,
+                        aggregator: aggregators[0],
+                    };
+                }
+            }
+            break;
+        }
+        case 1 /* AggregateAggregatorsMode.MinimizeInput */: {
+            for (let i = 0; i < requests.length; i++) {
+                const best = (0, data_1.minByBigInt)(responses.map((ra) => ({ quote: ra.quotes[i], aggregator: ra.agg })), (r) => r.quote?.inputAmount ?? 0n);
+                if (best != null) {
+                    final[i] = best;
+                }
+                else {
+                    final[i] = {
+                        quote: null,
+                        aggregator: aggregators[0],
+                    };
+                }
+            }
+            break;
+        }
+    }
+    return final;
+}
+async function autoSelectSources(userAddress, holdings, outputRequired, aggregators, collectionFees, commonCurrencyID = data_1.CurrencyID.USDC) {
+    console.log("XCS | SS | Holdings:", holdings);
+    const groupedByChainID = (0, es_toolkit_1.groupBy)(holdings, (h) => (0, viem_1.bytesToHex)(h.chainID.toBytes()));
+    const fullLiquidationQuotes = [];
+    for (const holdings of Object.values(groupedByChainID)) {
+        const chain = data_1.ChaindataMap.get(holdings[0].chainID);
+        if (chain == null) {
+            throw new AutoSelectionError("Chain not found");
+        }
+        const correspondingCurrency = chain.Currencies.find((cur) => cur.currencyID === commonCurrencyID);
+        if (correspondingCurrency == null) {
+            console.log("XCS | SS | Skipping because correspondingCurrency is null", {
+                chain,
+                correspondingCurrency,
+            });
+            continue;
+        }
+        const cfeeTuple = collectionFees.find((cf) => {
+            return (cf.universe === chain.Universe &&
+                Buffer.compare(cf.chainID, chain.ChainID32) === 0 &&
+                // output token is the CA one
+                Buffer.compare(cf.tokenAddress, correspondingCurrency.tokenAddress) ===
+                    0);
+        });
+        const cfee = cfeeTuple != null ? (0, viem_1.bytesToBigInt)(cfeeTuple.fee) : 0n;
+        for (const holding of holdings) {
+            if (Buffer.compare(holding.tokenAddress, correspondingCurrency.tokenAddress) === 0) {
+                console.log("XCS | SS | Disqualifying", holding, "because holding.tokenAddress = CA asset");
+                continue;
+            }
+            fullLiquidationQuotes.push({
+                req: {
+                    userAddress,
+                    type: iface_1.QuoteType.EXACT_IN,
+                    chain: chain.ChainID,
+                    inputToken: holding.tokenAddress,
+                    inputAmount: holding.amount,
+                    outputToken: correspondingCurrency.tokenAddress,
+                    seriousness: iface_1.QuoteSeriousness.PRICE_SURVEY,
+                },
+                // necessary for various purposes
+                cfee,
+                originalHolding: holding,
+                cur: correspondingCurrency,
+            });
+        }
+    }
+    // const groupedByChainID = groupBy(quoteOutputs, h => h.chainIDHex)
+    const quotesByValue = (0, es_toolkit_1.orderBy)(fullLiquidationQuotes, [
+        (quoteOut) => quoteOut.cfee,
+        (quoteOut) => quoteOut.originalHolding.value, // once optimized for collections, we select the biggest asset we hold
+    ], ["asc", "desc"]);
+    const responses = await aggregateAggregators(quotesByValue.map((fq) => fq.req), aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
+    console.log("XCS | SS | Responses:", responses);
+    const final = [];
+    let remainder = outputRequired; // assuming all that chains have the same amount of fixed point places
+    for (let i = 0; i < quotesByValue.length; i++) {
+        if (remainder.lte(0)) {
+            break;
+        }
+        const q = quotesByValue[i];
+        const { quote: resp, aggregator: agg } = responses[i];
+        if (resp == null) {
+            continue;
+        }
+        console.log("XCS | SS | 1", {
+            i,
+            remainder,
+            q,
+            resp,
+            agg,
+        });
+        const divisor = decimal_js_1.default.pow(10, q.cur.decimals);
+        const oamD = (0, data_1.convertBigIntToDecimal)(resp.outputAmountMinimum).div(divisor);
+        if (oamD.gt(remainder)) {
+            const indicativePrice = (0, data_1.convertBigIntToDecimal)(resp.inputAmount).div((0, data_1.convertBigIntToDecimal)(resp.outputAmountMinimum));
+            const userBal = (0, data_1.convertBigIntToDecimal)(q.originalHolding.amount);
+            // remainder is the output we want, so the input amount is remainder × indicativePrice
+            let expectedInput = decimal_js_1.default.min(remainder.mul(divisor).mul(indicativePrice).mul(safetyMultiplier), userBal);
+            while (true) {
+                console.log("XCS | SS | 2⒜", {
+                    indicativePrice,
+                    expectedInput,
+                    userBal,
+                });
+                const adequateQuoteResult = await aggregateAggregators([
+                    {
+                        ...q.req,
+                        seriousness: iface_1.QuoteSeriousness.SERIOUS,
+                        inputAmount: (0, data_1.convertDecimalToBigInt)(expectedInput),
+                    },
+                ], aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
+                if (adequateQuoteResult.length !== 1) {
+                    throw new AutoSelectionError("???");
+                }
+                const adequateQuote = adequateQuoteResult[0];
+                if (adequateQuote.quote == null) {
+                    throw new AutoSelectionError("Couldn't get buy quote");
+                }
+                console.log("XCS | SS | 2⒜⑴", {
+                    adequateQuote,
+                });
+                const oam2D = (0, data_1.convertBigIntToDecimal)(adequateQuote.quote.outputAmountMinimum).div(divisor);
+                if (oam2D.gte(remainder)) {
+                    final.push({
+                        ...q,
+                        quote: adequateQuote.quote,
+                        agg: adequateQuote.aggregator,
+                    });
+                    remainder = remainder.minus(oam2D);
+                    break;
+                }
+                else if (expectedInput.eq(userBal)) {
+                    throw new AutoSelectionError("Holding was supposedly enough to meet the full requirement but ceased to be so subsequently");
+                }
+                else {
+                    expectedInput = decimal_js_1.default.min(expectedInput.mul(safetyMultiplier), userBal); // try again with higher amount
+                }
+            }
+        }
+        else {
+            console.log("XCS | SS | 2⒝", resp);
+            final.push({
+                ...q,
+                quote: resp,
+                agg,
+            });
+            remainder = remainder.minus((0, data_1.convertBigIntToDecimal)(resp.outputAmountMinimum).div(divisor));
+        }
+    }
+    console.log("XCS | SS | 3⒜", {
+        remainder,
+        final,
+    });
+    if (remainder.gt(0)) {
+        throw new AutoSelectionError("Failed to accumulate enough swaps to meet requirement");
+    }
+    console.log("XCS | SS | Final:", final);
+    return final;
+}
+async function determineDestinationSwaps(userAddress, chainID, requirement, aggregators, commonCurrencyID = data_1.CurrencyID.USDC) {
+    const chaindata = data_1.ChaindataMap.get(chainID);
+    if (chaindata == null) {
+        throw new AutoSelectionError("Chain not found");
+    }
+    const COT = chaindata.Currencies.find((cur) => cur.currencyID === commonCurrencyID);
+    if (COT == null) {
+        throw new AutoSelectionError("COT not present on the destination chain");
+    }
+    // what happens if we happen to sell the requirement for the COT, what would the amount be?
+    const fullLiquidationQR = {
+        type: iface_1.QuoteType.EXACT_IN,
+        chain: chainID,
+        userAddress,
+        inputToken: requirement.tokenAddress,
+        outputToken: COT.tokenAddress,
+        inputAmount: requirement.amount,
+        seriousness: iface_1.QuoteSeriousness.PRICE_SURVEY,
+    };
+    const fullLiquidationResult = await aggregateAggregators([fullLiquidationQR], aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
+    if (fullLiquidationResult.length !== 1) {
+        throw new AutoSelectionError("???");
+    }
+    const fullLiquidationQuote = fullLiquidationResult[0];
+    if (fullLiquidationQuote.quote == null) {
+        throw new AutoSelectionError("Couldn't get full liquidation quote");
+    }
+    let curAmount = (0, data_1.convertBigIntToDecimal)(fullLiquidationQuote.quote.outputAmountLikely).mul(safetyMultiplier);
+    console.log("XCS | DDS | 1⒜", {
+        fullLiquidationQR,
+        fullLiquidationResult,
+        COT,
+    });
+    while (true) {
+        const buyQuoteResult = await aggregateAggregators([
+            {
+                type: iface_1.QuoteType.EXACT_IN,
+                userAddress,
+                chain: chainID,
+                inputToken: COT.tokenAddress,
+                outputToken: requirement.tokenAddress,
+                inputAmount: (0, data_1.convertDecimalToBigInt)(curAmount),
+                seriousness: iface_1.QuoteSeriousness.SERIOUS,
+            },
+        ], aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
+        if (buyQuoteResult.length !== 1) {
+            throw new AutoSelectionError("???");
+        }
+        const buyQuote = buyQuoteResult[0];
+        if (buyQuote.quote == null) {
+            throw new AutoSelectionError("Couldn't get buy quote");
+        }
+        console.log("XCS | DDS | 2⒜ iteration", {
+            buyQuote,
+            curAmount,
+        });
+        if (buyQuote.quote.outputAmountMinimum >= requirement.amount) {
+            return {
+                ...buyQuote,
+                inputAmount: (0, data_1.convertBigIntToDecimal)(buyQuote.quote.inputAmount).div(decimal_js_1.default.pow(10, COT.decimals)),
+                outputAmount: requirement.amount,
+            };
+        }
+        else {
+            curAmount = curAmount.mul(safetyMultiplier); // try again with higher amount
+        }
+    }
+}
+async function liquidateInputHoldings(userAddress, holdings, aggregators, collectionFees, commonCurrencyID = data_1.CurrencyID.USDC) {
+    console.log("XCS | LIH | Holdings:", holdings);
+    const groupedByChainID = (0, es_toolkit_1.groupBy)(holdings, (h) => (0, viem_1.bytesToHex)(h.chainID.toBytes()));
+    const fullLiquidationQuotes = [];
+    for (const holdings of Object.values(groupedByChainID)) {
+        const chain = data_1.ChaindataMap.get(holdings[0].chainID);
+        if (chain == null) {
+            throw new AutoSelectionError("Chain not found");
+        }
+        const correspondingCurrency = chain.Currencies.find((cur) => cur.currencyID === commonCurrencyID);
+        if (correspondingCurrency == null) {
+            console.log("XCS | LIH | Skipping because correspondingCurrency is null", {
+                chain,
+                correspondingCurrency,
+            });
+            continue;
+        }
+        const cfeeTuple = collectionFees.find((cf) => {
+            return (cf.universe === chain.Universe &&
+                Buffer.compare(cf.chainID, chain.ChainID32) === 0 &&
+                // output token is the CA one
+                Buffer.compare(cf.tokenAddress, correspondingCurrency.tokenAddress) ===
+                    0);
+        });
+        const cfee = cfeeTuple != null ? (0, viem_1.bytesToBigInt)(cfeeTuple.fee) : 0n;
+        for (const holding of holdings) {
+            if (Buffer.compare(holding.tokenAddress, correspondingCurrency.tokenAddress) === 0) {
+                console.log("XCS | LIH | Disqualifying", holding, "because holding.tokenAddress = CA asset");
+                continue;
+            }
+            fullLiquidationQuotes.push({
+                req: {
+                    userAddress,
+                    type: iface_1.QuoteType.EXACT_IN,
+                    chain: chain.ChainID,
+                    inputToken: holding.tokenAddress,
+                    inputAmount: holding.amount,
+                    outputToken: correspondingCurrency.tokenAddress,
+                    seriousness: iface_1.QuoteSeriousness.SERIOUS,
+                },
+                // necessary for various purposes
+                cfee,
+                originalHolding: holding,
+                cur: correspondingCurrency,
+            });
+        }
+    }
+    const responses = await aggregateAggregators(fullLiquidationQuotes.map((fq) => fq.req), aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
+    console.log("XCS | LIH | Responses:", responses);
+    const validResponses = responses
+        .filter((r) => r.quote !== null)
+        .map((r, i) => ({
+        ...r,
+        ...fullLiquidationQuotes[i],
+        agg: r.aggregator,
+        quote: r.quote,
+    }));
+    const total = validResponses.reduce((acc, r) => {
+        return acc.add(new decimal_js_1.default(r.quote.outputAmountMinimum ?? 0n).div(decimal_js_1.default.pow(10, r.cur.decimals)));
+    }, new decimal_js_1.default(0));
+    return {
+        quotes: validResponses,
+        total,
+    };
+}
+async function destinationSwapWithExactIn(userAddress, chainID, inputAmount, outputToken, aggregators, commonCurrencyID = data_1.CurrencyID.USDC) {
+    const chaindata = data_1.ChaindataMap.get(chainID);
+    if (chaindata == null) {
+        throw new AutoSelectionError("Chain not found");
+    }
+    const COT = chaindata.Currencies.find((cur) => cur.currencyID === commonCurrencyID);
+    if (COT == null) {
+        throw new AutoSelectionError("COT not present on the destination chain");
+    }
+    const fullLiquidationResult = await aggregateAggregators([
+        {
+            type: iface_1.QuoteType.EXACT_IN,
+            chain: chainID,
+            userAddress,
+            inputToken: COT.tokenAddress,
+            outputToken: outputToken,
+            inputAmount: inputAmount,
+            seriousness: iface_1.QuoteSeriousness.SERIOUS,
+        },
+    ], aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
+    if (fullLiquidationResult.length !== 1) {
+        throw new AutoSelectionError("???");
+    }
+    const fullLiquidationQuote = fullLiquidationResult[0];
+    if (fullLiquidationQuote.quote == null) {
+        throw new AutoSelectionError("Couldn't get full liquidation quote");
+    }
+    return {
+        ...fullLiquidationQuote,
+        inputAmount: (0, data_1.convertBigIntToDecimal)(inputAmount).div(decimal_js_1.default.pow(10, COT.decimals)),
+        outputAmount: fullLiquidationQuote.quote.outputAmountMinimum,
+    };
+}

package/dist/cjs/xcs/bebop-agg.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BebopAggregator = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importStar(require("axios"));
+const viem_1 = require("viem");
+const iface_1 = require("./iface");
+const definition_1 = require("../proto/definition");
+const data_1 = require("../data");
+// https://api.bebop.xyz/{jam|pmm}/chains
+const ChainNameMapping = new Map(Object.entries({
+    ethereum: 1,
+    arbitrum: 42161,
+    optimism: 10,
+    base: 8453,
+    taiko: 167000,
+    bsc: 56,
+    monadtestnet: 10143,
+    megaethtestnet: 6342,
+    berachain: 80094,
+    polygon: 137,
+    zksync: 324,
+    blast: 81457,
+    mode: 34443,
+    scroll: 534352,
+    superseed: 5330,
+}).map(([k, v]) => [(0, viem_1.bytesToHex)((0, data_1.encodeChainID36)(definition_1.Universe.ETHEREUM, v)), k]));
+class BebopAggregator {
+    static BASE_URL = "https://api.bebop.xyz/router";
+    static COMMON_OPTIONS = {
+        approval_type: "Standard",
+        skip_validation: "true",
+        gasless: false,
+    };
+    axios;
+    constructor(apiKey) {
+        this.axios = axios_1.default.create({
+            baseURL: BebopAggregator.BASE_URL,
+            headers: {
+                "Source-Auth": apiKey,
+            },
+            params: {
+                source: "arcana",
+            },
+        });
+    }
+    async getQuotes(requests) {
+        const list = await Promise.allSettled(requests.map(async (r) => {
+            const chainName = ChainNameMapping.get((0, viem_1.bytesToHex)(r.chain.toBytes()));
+            if (chainName == null) {
+                return null;
+            }
+            let respPromise;
+            const inputTokenAddr = (0, viem_1.getAddress)((0, viem_1.bytesToHex)(r.inputToken.subarray(12)));
+            const outputTokenAddr = (0, viem_1.getAddress)((0, viem_1.bytesToHex)(r.outputToken.subarray(12)));
+            const userAddrHex = (0, viem_1.getAddress)((0, viem_1.bytesToHex)(r.userAddress.subarray(12)));
+            switch (r.type) {
+                case iface_1.QuoteType.EXACT_IN: {
+                    respPromise = this.axios({
+                        method: "GET",
+                        url: `/${chainName}/v1/quote`,
+                        params: {
+                            sell_tokens: inputTokenAddr,
+                            buy_tokens: outputTokenAddr,
+                            taker_address: userAddrHex,
+                            sell_amounts: r.inputAmount.toString(),
+                            ...BebopAggregator.COMMON_OPTIONS,
+                        },
+                    });
+                    break;
+                }
+                case iface_1.QuoteType.EXACT_OUT: {
+                    respPromise = this.axios({
+                        method: "GET",
+                        url: `/${chainName}/v1/quote`,
+                        params: {
+                            sell_tokens: inputTokenAddr,
+                            buy_tokens: outputTokenAddr,
+                            taker_address: userAddrHex,
+                            buy_amounts: r.outputAmount.toString(),
+                            ...BebopAggregator.COMMON_OPTIONS,
+                        },
+                    });
+                    break;
+                }
+            }
+            let resp;
+            try {
+                resp = await respPromise;
+            }
+            catch (e) {
+                if (e instanceof axios_1.AxiosError && e.isAxiosError) {
+                    if (e.response?.status === 404 &&
+                        e.response.data.code === 1002 &&
+                        e.response.data.message ===
+                            "No available quotes for the requested transfer") {
+                        return null;
+                    }
+                }
+                throw e;
+            }
+            const bestRoute = resp.data.routes?.at(0);
+            if (bestRoute == null) {
+                return null;
+            }
+            const buyT = bestRoute.quote.buyTokens[outputTokenAddr];
+            return {
+                type: r.type,
+                inputAmount: BigInt(bestRoute.quote.sellTokens[inputTokenAddr].amount),
+                outputAmountMinimum: BigInt(buyT.minimumAmount),
+                outputAmountLikely: BigInt(buyT.amount),
+                originalResponse: bestRoute,
+            };
+        }));
+        return list.map((item) => {
+            switch (item.status) {
+                case "fulfilled": {
+                    return item.value;
+                }
+                case "rejected": {
+                    console.error("Caught error in fetching Bebop quotes:", item.reason);
+                    return null;
+                }
+            }
+        });
+    }
+}
+exports.BebopAggregator = BebopAggregator;

package/dist/cjs/xcs/iface.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuoteSeriousness = exports.QuoteType = void 0;
+var QuoteType;
+(function (QuoteType) {
+    QuoteType[QuoteType["EXACT_IN"] = 0] = "EXACT_IN";
+    QuoteType[QuoteType["EXACT_OUT"] = 1] = "EXACT_OUT";
+})(QuoteType || (exports.QuoteType = QuoteType = {}));
+var QuoteSeriousness;
+(function (QuoteSeriousness) {
+    QuoteSeriousness[QuoteSeriousness["PRICE_SURVEY"] = 0] = "PRICE_SURVEY";
+    QuoteSeriousness[QuoteSeriousness["SERIOUS"] = 1] = "SERIOUS";
+})(QuoteSeriousness || (exports.QuoteSeriousness = QuoteSeriousness = {}));

package/dist/cjs/xcs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./iface"), exports);
+tslib_1.__exportStar(require("./lifi-agg"), exports);
+tslib_1.__exportStar(require("./yieldyak-agg"), exports);
+tslib_1.__exportStar(require("./bebop-agg"), exports);
+tslib_1.__exportStar(require("./autochoice"), exports);

package/dist/cjs/xcs/lifi-agg.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiFiAggregator = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importStar(require("axios"));
+const viem_1 = require("viem");
+const iface_1 = require("./iface");
+const definition_1 = require("../proto/definition");
+class LiFiAggregator {
+    static BASE_URL_V1 = "https://li.quest/v1";
+    static COMMON_OPTIONS = {
+        denyExchanges: "openocean",
+        slippage: "0.01",
+    };
+    axios;
+    constructor(apiKey) {
+        this.axios = axios_1.default.create({
+            baseURL: LiFiAggregator.BASE_URL_V1,
+            headers: {
+                "x-lifi-api-key": apiKey,
+            },
+        });
+    }
+    async getQuotes(requests) {
+        const list = await Promise.allSettled(requests.map(async (r) => {
+            if (r.chain.universe !== definition_1.Universe.ETHEREUM) {
+                return null;
+            }
+            let respPromise;
+            const chIDStr = r.chain.chainID.toString();
+            const inputTokenAddr = (0, viem_1.getAddress)((0, viem_1.bytesToHex)(r.inputToken.subarray(12)));
+            const outputTokenAddr = (0, viem_1.getAddress)((0, viem_1.bytesToHex)(r.outputToken.subarray(12)));
+            const userAddrHex = (0, viem_1.getAddress)((0, viem_1.bytesToHex)(r.userAddress.subarray(12)));
+            switch (r.type) {
+                case iface_1.QuoteType.EXACT_IN: {
+                    respPromise = this.axios({
+                        method: "GET",
+                        url: "/quote",
+                        params: {
+                            fromChain: chIDStr,
+                            toChain: chIDStr,
+                            fromToken: inputTokenAddr,
+                            toToken: outputTokenAddr,
+                            fromAddress: userAddrHex,
+                            fromAmount: r.inputAmount.toString(),
+                            ...LiFiAggregator.COMMON_OPTIONS,
+                        },
+                    });
+                    break;
+                }
+                case iface_1.QuoteType.EXACT_OUT: {
+                    respPromise = this.axios({
+                        method: "GET",
+                        url: "/quote/toAmount",
+                        params: {
+                            fromChain: chIDStr,
+                            toChain: chIDStr,
+                            fromToken: inputTokenAddr,
+                            toToken: outputTokenAddr,
+                            fromAddress: userAddrHex,
+                            toAmount: r.outputAmount.toString(),
+                            ...LiFiAggregator.COMMON_OPTIONS,
+                        },
+                    });
+                    break;
+                }
+            }
+            let resp;
+            try {
+                resp = await respPromise;
+            }
+            catch (e) {
+                if (e instanceof axios_1.AxiosError && e.isAxiosError) {
+                    if (e.response?.status === 404 &&
+                        e.response.data.code === 1002 &&
+                        e.response.data.message ===
+                            "No available quotes for the requested transfer") {
+                        return null;
+                    }
+                }
+                throw e;
+            }
+            return {
+                type: r.type,
+                inputAmount: BigInt(resp.data.estimate.fromAmount),
+                outputAmountMinimum: BigInt(resp.data.estimate.toAmountMin),
+                outputAmountLikely: BigInt(resp.data.estimate.toAmount),
+                originalResponse: resp.data,
+            };
+        }));
+        return list.map((item) => {
+            switch (item.status) {
+                case "fulfilled": {
+                    return item.value;
+                }
+                case "rejected": {
+                    console.error("Caught error in fetching LiFi quotes:", item.reason);
+                    return null;
+                }
+            }
+        });
+    }
+}
+exports.LiFiAggregator = LiFiAggregator;