@avail-project/ca-common 1.0.1 → 2.0.0

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

@@ -6,11 +6,13 @@ 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 decimal_js_1 = tslib_1.__importDefault(require("decimal.js"));
 class LiFiAggregator {
     static BASE_URL_V1 = "https://li.quest/v1";
     static COMMON_OPTIONS = {
         denyExchanges: "openocean",
         slippage: "0.01",
+        skipSimulation: true,
     };
     axios;
     constructor(apiKey) {
@@ -19,6 +21,7 @@ class LiFiAggregator {
             headers: {
                 "x-lifi-api-key": apiKey,
             },
+            timeout: 10_000,
         });
     }
     async getQuotes(requests) {
@@ -80,12 +83,38 @@ class LiFiAggregator {
                 }
                 throw e;
             }
+            const { estimate, transactionRequest: { to, value, data }, action: { fromToken, toToken }, } = resp.data;
+            const inputAmountInDecimal = new decimal_js_1.default(estimate.fromAmount)
+                .div(decimal_js_1.default.pow(10, fromToken.decimals))
+                .toFixed(fromToken.decimals);
+            const outputAmountInDecimal = new decimal_js_1.default(estimate.toAmountMin)
+                .div(decimal_js_1.default.pow(10, toToken.decimals))
+                .toFixed(toToken.decimals);
             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,
+                input: {
+                    amount: inputAmountInDecimal,
+                    amountRaw: BigInt(estimate.fromAmount),
+                    contractAddress: inputTokenAddr,
+                    decimals: fromToken.decimals,
+                    value: decimal_js_1.default.mul(inputAmountInDecimal, fromToken.priceUSD).toNumber(),
+                    symbol: fromToken.symbol,
+                },
+                output: {
+                    amount: outputAmountInDecimal,
+                    amountRaw: BigInt(estimate.toAmountMin),
+                    contractAddress: outputTokenAddr,
+                    decimals: toToken.decimals,
+                    value: decimal_js_1.default.mul(outputAmountInDecimal, toToken.priceUSD).toNumber(),
+                    symbol: toToken.symbol,
+                },
+                txData: {
+                    approvalAddress: estimate.approvalAddress,
+                    tx: {
+                        to,
+                        value,
+                        data,
+                    },
+                },
             };
         }));
         return list.map((item) => {

package/dist/esm/xcs/autochoice.js

@@ -1,5 +1,5 @@
-import { groupBy, orderBy } from "es-toolkit";
-import { bytesToBigInt, bytesToHex } from "viem";
+import { groupBy } from "es-toolkit";
+import { bytesToHex } from "viem";
 import Decimal from "decimal.js";
 import { QuoteSeriousness, QuoteType, } from "./iface";
 import { ChaindataMap, convertBigIntToDecimal, convertDecimalToBigInt, CurrencyID, maxByBigInt, minByBigInt, } from "../data";
@@ -25,7 +25,7 @@ export async function aggregateAggregators(requests, aggregators, mode) {
     switch (mode) {
         case 0 /* AggregateAggregatorsMode.MaximizeOutput */: {
             for (let i = 0; i < requests.length; i++) {
-                const best = maxByBigInt(responses.map((ra) => ({ quote: ra.quotes[i], aggregator: ra.agg })), (r) => r.quote?.outputAmountMinimum ?? 0n);
+                const best = maxByBigInt(responses.map((ra) => ({ quote: ra.quotes[i], aggregator: ra.agg })), (r) => r.quote?.output.amountRaw ?? 0n);
                 if (best != null) {
                     final[i] = best;
                 }
@@ -40,7 +40,9 @@ export async function aggregateAggregators(requests, aggregators, mode) {
         }
         case 1 /* AggregateAggregatorsMode.MinimizeInput */: {
             for (let i = 0; i < requests.length; i++) {
-                const best = minByBigInt(responses.map((ra) => ({ quote: ra.quotes[i], aggregator: ra.agg })), (r) => r.quote?.inputAmount ?? 0n);
+                const best = minByBigInt(responses.map((ra) => ({ quote: ra.quotes[i], aggregator: ra.agg })), 
+                // Default null quotes to MAX so they never win as the minimum
+                (r) => r.quote?.input.amountRaw ?? BigInt(Number.MAX_SAFE_INTEGER));
                 if (best != null) {
                     final[i] = best;
                 }
@@ -98,7 +100,7 @@ cots = [(1 COT, 1), (1 COT, 4)]
 */
 export async function autoSelectSourcesV2(userAddress, holdings, outputRequired, aggregators, commonCurrencyID = CurrencyID.USDC) {
     // Assumption: Holding is already sorted in usage priority
-    console.log("XCS | SSV2:", {
+    console.debug("XCS | SSV2:", {
         holdings,
         outputRequired: outputRequired.toFixed(),
     });
@@ -111,14 +113,14 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
         }
         const correspondingCurrency = chain.Currencies.find((cur) => cur.currencyID === commonCurrencyID);
         if (correspondingCurrency == null) {
-            console.log("XCS | SS | Skipping because correspondingCurrency is null", {
+            console.debug("XCS | SS | Skipping because correspondingCurrency is null", {
                 chain,
                 correspondingCurrency,
             });
             continue;
         }
         if (Buffer.compare(holding.tokenAddress, correspondingCurrency.tokenAddress) === 0) {
-            const normalizedAmount = new Decimal(holding.amount).div(Decimal.pow(10, correspondingCurrency.decimals));
+            const normalizedAmount = new Decimal(holding.amountRaw).div(Decimal.pow(10, correspondingCurrency.decimals));
             cotList.push({
                 amount: normalizedAmount,
                 idx,
@@ -134,7 +136,7 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
                     type: QuoteType.EXACT_IN,
                     chain: chain.ChainID,
                     inputToken: holding.tokenAddress,
-                    inputAmount: holding.amount,
+                    inputAmount: holding.amountRaw,
                     outputToken: correspondingCurrency.tokenAddress,
                     seriousness: QuoteSeriousness.PRICE_SURVEY,
                 },
@@ -172,10 +174,10 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
                     if (remainder.lte(0))
                         break;
                 }
-                console.log("XCS | SS | Early return with continuous COTs:", {
+                console.debug("XCS | SS | Early return with continuous COTs:", {
                     cots: usedCOTs,
                 });
-                return { quotes: [], usedCOTs };
+                return { quoteResponses: [], usedCOTs };
             }
         }
     }
@@ -200,7 +202,7 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
     // Sort by original index to maintain priority
     processingQueue.sort((a, b) => a.idx - b.idx);
     const responses = await aggregateAggregators(fullLiquidationQuotes.map((fq) => fq.req), aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
-    console.log("XCS | SS | Responses:", responses);
+    console.debug("AutoSelectSources:Quotes", responses);
     const final = [];
     const usedCOTs = [];
     let remainder = outputRequired;
@@ -219,7 +221,7 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
                 cur: cotData.currency,
             });
             remainder = remainder.minus(amountToUse);
-            console.log("XCS | SS | Used COT", {
+            console.debug("selection:cot", {
                 idx: cotData.idx,
                 amountToUse: amountToUse.toFixed(),
                 remainder: remainder.toFixed(),
@@ -228,30 +230,32 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
         else {
             // Process non-COT holding - use existing quote logic
             const { quoteData, responseIdx } = item;
-            const { quote: resp, aggregator: agg } = responses[responseIdx];
+            const { quote: resp, aggregator } = responses[responseIdx];
             if (resp == null) {
                 continue;
             }
-            console.log("XCS | SS | 1", {
-                i: responseIdx,
-                idx: quoteData.idx,
-                remainder,
-                q: quoteData,
-                resp,
-                agg,
+            console.debug("selection:quote", {
+                remainder: remainder.toFixed(),
+                input: resp.input,
+                output: resp.output,
             });
             const divisor = Decimal.pow(10, quoteData.cur.decimals);
-            const oamD = Decimal.div(resp.outputAmountMinimum, divisor);
+            const oamD = new Decimal(resp.output.amount);
             if (oamD.gt(remainder)) {
-                const indicativePrice = Decimal.div(resp.inputAmount, resp.outputAmountMinimum);
-                const userBal = new Decimal(quoteData.originalHolding.amount);
+                const indicativePrice = Decimal.div(resp.input.amountRaw, resp.output.amountRaw);
+                const userBal = new Decimal(quoteData.originalHolding.amountRaw);
                 // remainder is the output we want, so the input amount is remainder × indicativePrice
                 let expectedInput = Decimal.min(remainder.mul(divisor).mul(indicativePrice).mul(safetyMultiplier), userBal);
+                let attempts = 0;
                 while (true) {
-                    console.log("XCS | SS | 2⒜", {
-                        indicativePrice,
-                        expectedInput,
-                        userBal,
+                    if (++attempts > 10) {
+                        throw new AutoSelectionError("Partial quote did not converge");
+                    }
+                    console.debug("partial_quote_loop", {
+                        indicativePrice: indicativePrice.toFixed(),
+                        expectedInput: expectedInput.toFixed(),
+                        userBal: userBal.toFixed(),
+                        remainder: remainder.toFixed(),
                     });
                     const adequateQuoteResult = await aggregateAggregators([
                         {
@@ -261,21 +265,23 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
                         },
                     ], aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
                     if (adequateQuoteResult.length !== 1) {
-                        throw new AutoSelectionError("???");
+                        throw new AutoSelectionError("Unexpected response length from aggregateAggregators");
                     }
                     const adequateQuote = adequateQuoteResult[0];
                     if (adequateQuote.quote == null) {
                         throw new AutoSelectionError("Couldn't get buy quote");
                     }
-                    console.log("XCS | SS | 2⒜⑴", {
-                        adequateQuote,
+                    const quote = adequateQuote.quote;
+                    console.log("partial_quote", {
+                        quote,
                     });
-                    const oam2D = Decimal.div(adequateQuote.quote.outputAmountMinimum, divisor);
+                    const oam2D = new Decimal(adequateQuote.quote.output.amount);
                     if (oam2D.gte(remainder)) {
                         final.push({
-                            ...quoteData,
-                            quote: adequateQuote.quote,
-                            agg: adequateQuote.aggregator,
+                            quote,
+                            aggregator: adequateQuote.aggregator,
+                            holding: quoteData.originalHolding,
+                            chainID: Number(quoteData.req.chain.chainID),
                         });
                         remainder = remainder.minus(oam2D);
                         break;
@@ -289,168 +295,29 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
                 }
             }
             else {
-                console.log("XCS | SS | 2⒝", resp);
+                console.debug("full_quote", resp);
                 final.push({
-                    ...quoteData,
                     quote: resp,
-                    agg,
-                });
-                remainder = remainder.minus(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:", { quotes: final, cots: usedCOTs });
-    return { quotes: final, usedCOTs };
-}
-export async function autoSelectSources(userAddress, holdings, outputRequired, aggregators, collectionFees, commonCurrencyID = CurrencyID.USDC) {
-    console.log("XCS | SS | Holdings:", holdings);
-    const groupedByChainID = groupBy(holdings, (h) => bytesToHex(h.chainID.toBytes()));
-    const fullLiquidationQuotes = [];
-    for (const holdings of Object.values(groupedByChainID)) {
-        const chain = 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 ? 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: QuoteType.EXACT_IN,
-                    chain: chain.ChainID,
-                    inputToken: holding.tokenAddress,
-                    inputAmount: holding.amount,
-                    outputToken: correspondingCurrency.tokenAddress,
-                    seriousness: QuoteSeriousness.PRICE_SURVEY,
-                },
-                // necessary for various purposes
-                cfee,
-                originalHolding: holding,
-                cur: correspondingCurrency,
-            });
-        }
-    }
-    // const groupedByChainID = groupBy(quoteOutputs, h => h.chainIDHex)
-    const quotesByValue = 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.pow(10, q.cur.decimals);
-        const oamD = convertBigIntToDecimal(resp.outputAmountMinimum).div(divisor);
-        if (oamD.gt(remainder)) {
-            const indicativePrice = convertBigIntToDecimal(resp.inputAmount).div(convertBigIntToDecimal(resp.outputAmountMinimum));
-            const userBal = convertBigIntToDecimal(q.originalHolding.amount);
-            // remainder is the output we want, so the input amount is remainder × indicativePrice
-            let expectedInput = Decimal.min(remainder.mul(divisor).mul(indicativePrice).mul(safetyMultiplier), userBal);
-            while (true) {
-                console.log("XCS | SS | 2⒜", {
-                    indicativePrice,
-                    expectedInput,
-                    userBal,
+                    holding: quoteData.originalHolding,
+                    aggregator,
+                    chainID: Number(quoteData.req.chain.chainID),
                 });
-                const adequateQuoteResult = await aggregateAggregators([
-                    {
-                        ...q.req,
-                        seriousness: QuoteSeriousness.SERIOUS,
-                        inputAmount: 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 = 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.min(expectedInput.mul(safetyMultiplier), userBal); // try again with higher amount
-                }
+                remainder = remainder.minus(resp.output.amount);
             }
         }
-        else {
-            console.log("XCS | SS | 2⒝", resp);
-            final.push({
-                ...q,
-                quote: resp,
-                agg,
-            });
-            remainder = remainder.minus(convertBigIntToDecimal(resp.outputAmountMinimum).div(divisor));
-        }
     }
-    console.log("XCS | SS | 3⒜", {
-        remainder,
+    console.debug("quotes_and_remainder", {
+        remainder: remainder.toFixed(),
         final,
     });
     if (remainder.gt(0)) {
-        throw new AutoSelectionError("Failed to accumulate enough swaps to meet requirement");
+        throw new AutoSelectionError("NOT_ENOUGH_SWAP_FOR_REQUIREMENT");
     }
-    console.log("XCS | SS | Final:", final);
-    return final;
+    console.log("final_quotes", { quotes: final, cots: usedCOTs });
+    return { quoteResponses: final, usedCOTs };
 }
-export async function determineDestinationSwaps(userAddress, chainID, requirement, aggregators, commonCurrencyID = CurrencyID.USDC) {
-    const chaindata = ChaindataMap.get(chainID);
+export async function determineDestinationSwaps(userAddress, requirement, aggregators, commonCurrencyID = CurrencyID.USDC) {
+    const chaindata = ChaindataMap.get(requirement.chainID);
     if (chaindata == null) {
         throw new AutoSelectionError("Chain not found");
     }
@@ -462,33 +329,32 @@ export async function determineDestinationSwaps(userAddress, chainID, requiremen
     // what happens if we happen to sell the requirement for the COT, what would the amount be?
     const fullLiquidationQR = {
         type: QuoteType.EXACT_IN,
-        chain: chainID,
+        chain: requirement.chainID,
         userAddress,
         inputToken: requirement.tokenAddress,
         outputToken: COT.tokenAddress,
-        inputAmount: requirement.amount,
+        inputAmount: requirement.amountRaw,
         seriousness: QuoteSeriousness.PRICE_SURVEY,
     };
     const fullLiquidationResult = await aggregateAggregators([fullLiquidationQR], aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
     if (fullLiquidationResult.length !== 1) {
-        throw new AutoSelectionError("???");
+        throw new AutoSelectionError("Unexpected response length from aggregateAggregators");
     }
     const fullLiquidationQuote = fullLiquidationResult[0];
     if (fullLiquidationQuote.quote == null) {
         throw new AutoSelectionError("Couldn't get full liquidation quote");
     }
-    let curAmount = convertBigIntToDecimal(fullLiquidationQuote.quote.outputAmountLikely).mul(safetyMultiplier);
-    console.log("XCS | DDS | 1⒜", {
-        fullLiquidationQR,
-        fullLiquidationResult,
-        COT,
-    });
+    let curAmount = convertBigIntToDecimal(fullLiquidationQuote.quote.output.amountRaw).mul(safetyMultiplier);
+    let attempts = 0;
     while (true) {
+        if (++attempts > 10) {
+            throw new AutoSelectionError("Destination swap quote did not converge");
+        }
         const buyQuoteResult = await aggregateAggregators([
             {
                 type: QuoteType.EXACT_IN,
                 userAddress,
-                chain: chainID,
+                chain: requirement.chainID,
                 inputToken: COT.tokenAddress,
                 outputToken: requirement.tokenAddress,
                 inputAmount: convertDecimalToBigInt(curAmount),
@@ -496,21 +362,22 @@ export async function determineDestinationSwaps(userAddress, chainID, requiremen
             },
         ], aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
         if (buyQuoteResult.length !== 1) {
-            throw new AutoSelectionError("???");
+            throw new AutoSelectionError("Unexpected response length from aggregateAggregators");
         }
         const buyQuote = buyQuoteResult[0];
         if (buyQuote.quote == null) {
             throw new AutoSelectionError("Couldn't get buy quote");
         }
-        console.log("XCS | DDS | 2⒜ iteration", {
+        console.debug("XCS | DDS | 2⒜ iteration", {
             buyQuote,
             curAmount,
         });
-        if (buyQuote.quote.outputAmountMinimum >= requirement.amount) {
+        if (buyQuote.quote.output.amountRaw >= requirement.amountRaw) {
             return {
-                ...buyQuote,
-                inputAmount: convertBigIntToDecimal(buyQuote.quote.inputAmount).div(Decimal.pow(10, COT.decimals)),
-                outputAmount: requirement.amount,
+                chainID: Number(requirement.chainID.chainID),
+                quote: buyQuote.quote,
+                aggregator: buyQuote.aggregator,
+                holding: requirement,
             };
         }
         else {
@@ -518,8 +385,8 @@ export async function determineDestinationSwaps(userAddress, chainID, requiremen
         }
     }
 }
-export async function liquidateInputHoldings(userAddress, holdings, aggregators, collectionFees, commonCurrencyID = CurrencyID.USDC) {
-    console.log("XCS | LIH | Holdings:", holdings);
+export async function liquidateInputHoldings(userAddress, holdings, aggregators, commonCurrencyID = CurrencyID.USDC) {
+    console.debug("XCS | LIH | Holdings:", holdings);
     const groupedByChainID = groupBy(holdings, (h) => bytesToHex(h.chainID.toBytes()));
     const fullLiquidationQuotes = [];
     for (const holdings of Object.values(groupedByChainID)) {
@@ -529,20 +396,12 @@ export async function liquidateInputHoldings(userAddress, holdings, aggregators,
         }
         const correspondingCurrency = chain.Currencies.find((cur) => cur.currencyID === commonCurrencyID);
         if (correspondingCurrency == null) {
-            console.log("XCS | LIH | Skipping because correspondingCurrency is null", {
+            console.debug("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 ? 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");
@@ -554,48 +413,44 @@ export async function liquidateInputHoldings(userAddress, holdings, aggregators,
                     type: QuoteType.EXACT_IN,
                     chain: chain.ChainID,
                     inputToken: holding.tokenAddress,
-                    inputAmount: holding.amount,
+                    inputAmount: holding.amountRaw,
                     outputToken: correspondingCurrency.tokenAddress,
                     seriousness: 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(r.quote.outputAmountMinimum ?? 0n).div(Decimal.pow(10, r.cur.decimals)));
-    }, new Decimal(0));
-    return {
-        quotes: validResponses,
-        total,
-    };
+    console.debug("XCS | LIH | Responses:", responses);
+    const quotes = [];
+    for (const [i, response] of responses.entries()) {
+        if (response.quote !== null) {
+            quotes.push({
+                quote: response.quote,
+                aggregator: response.aggregator,
+                holding: fullLiquidationQuotes[i].originalHolding,
+                chainID: Number(fullLiquidationQuotes[i].req.chain.chainID),
+            });
+        }
+    }
+    return quotes;
 }
-export async function destinationSwapWithExactIn(userAddress, chainID, inputAmount, outputToken, aggregators, commonCurrencyID = CurrencyID.USDC) {
-    const chaindata = ChaindataMap.get(chainID);
+export async function destinationSwapWithExactIn(userAddress, omniChainID, inputAmount, outputToken, aggregators, inputCurrency = CurrencyID.USDC) {
+    const chaindata = ChaindataMap.get(omniChainID);
     if (chaindata == null) {
         throw new AutoSelectionError("Chain not found");
     }
-    const COT = chaindata.Currencies.find((cur) => cur.currencyID === commonCurrencyID);
+    const COT = chaindata.Currencies.find((cur) => cur.currencyID === inputCurrency);
     if (COT == null) {
         throw new AutoSelectionError("COT not present on the destination chain");
     }
     const fullLiquidationResult = await aggregateAggregators([
         {
             type: QuoteType.EXACT_IN,
-            chain: chainID,
+            chain: omniChainID,
             userAddress,
             inputToken: COT.tokenAddress,
             outputToken: outputToken,
@@ -604,15 +459,20 @@ export async function destinationSwapWithExactIn(userAddress, chainID, inputAmou
         },
     ], aggregators, 0 /* AggregateAggregatorsMode.MaximizeOutput */);
     if (fullLiquidationResult.length !== 1) {
-        throw new AutoSelectionError("???");
+        throw new AutoSelectionError("Unexpected response length from aggregateAggregators");
     }
     const fullLiquidationQuote = fullLiquidationResult[0];
     if (fullLiquidationQuote.quote == null) {
         throw new AutoSelectionError("Couldn't get full liquidation quote");
     }
     return {
-        ...fullLiquidationQuote,
-        inputAmount: convertBigIntToDecimal(inputAmount).div(Decimal.pow(10, COT.decimals)),
-        outputAmount: fullLiquidationQuote.quote.outputAmountMinimum,
+        chainID: Number(omniChainID.chainID),
+        quote: fullLiquidationQuote.quote,
+        aggregator: fullLiquidationQuote.aggregator,
+        holding: {
+            amountRaw: inputAmount,
+            chainID: omniChainID,
+            tokenAddress: COT.tokenAddress,
+        },
     };
 }