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

package/dist/esm/xcs/autochoice.js

@@ -0,0 +1,364 @@
+import { groupBy, orderBy } from "es-toolkit";
+import { bytesToBigInt, bytesToHex } from "viem";
+import Decimal from "decimal.js";
+import { QuoteSeriousness, QuoteType, } from "./iface";
+import { ChaindataMap, convertBigIntToDecimal, convertDecimalToBigInt, CurrencyID, maxByBigInt, minByBigInt, } from "../data";
+export class AutoSelectionError extends Error {
+}
+const safetyMultiplier = new Decimal("1.025");
+export 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 = 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 = 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;
+}
+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,
+                });
+                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
+                }
+            }
+        }
+        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,
+        final,
+    });
+    if (remainder.gt(0)) {
+        throw new AutoSelectionError("Failed to accumulate enough swaps to meet requirement");
+    }
+    console.log("XCS | SS | Final:", final);
+    return final;
+}
+export async function determineDestinationSwaps(userAddress, chainID, requirement, aggregators, commonCurrencyID = CurrencyID.USDC) {
+    const chaindata = 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: QuoteType.EXACT_IN,
+        chain: chainID,
+        userAddress,
+        inputToken: requirement.tokenAddress,
+        outputToken: COT.tokenAddress,
+        inputAmount: requirement.amount,
+        seriousness: 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 = convertBigIntToDecimal(fullLiquidationQuote.quote.outputAmountLikely).mul(safetyMultiplier);
+    console.log("XCS | DDS | 1⒜", {
+        fullLiquidationQR,
+        fullLiquidationResult,
+        COT,
+    });
+    while (true) {
+        const buyQuoteResult = await aggregateAggregators([
+            {
+                type: QuoteType.EXACT_IN,
+                userAddress,
+                chain: chainID,
+                inputToken: COT.tokenAddress,
+                outputToken: requirement.tokenAddress,
+                inputAmount: convertDecimalToBigInt(curAmount),
+                seriousness: 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: convertBigIntToDecimal(buyQuote.quote.inputAmount).div(Decimal.pow(10, COT.decimals)),
+                outputAmount: requirement.amount,
+            };
+        }
+        else {
+            curAmount = curAmount.mul(safetyMultiplier); // try again with higher amount
+        }
+    }
+}
+export async function liquidateInputHoldings(userAddress, holdings, aggregators, collectionFees, commonCurrencyID = CurrencyID.USDC) {
+    console.log("XCS | LIH | 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 | 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");
+                continue;
+            }
+            fullLiquidationQuotes.push({
+                req: {
+                    userAddress,
+                    type: QuoteType.EXACT_IN,
+                    chain: chain.ChainID,
+                    inputToken: holding.tokenAddress,
+                    inputAmount: holding.amount,
+                    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,
+    };
+}
+export async function destinationSwapWithExactIn(userAddress, chainID, inputAmount, outputToken, aggregators, commonCurrencyID = CurrencyID.USDC) {
+    const chaindata = 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: QuoteType.EXACT_IN,
+            chain: chainID,
+            userAddress,
+            inputToken: COT.tokenAddress,
+            outputToken: outputToken,
+            inputAmount: inputAmount,
+            seriousness: 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: convertBigIntToDecimal(inputAmount).div(Decimal.pow(10, COT.decimals)),
+        outputAmount: fullLiquidationQuote.quote.outputAmountMinimum,
+    };
+}

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

@@ -0,0 +1,123 @@
+import axios, { AxiosError } from "axios";
+import { bytesToHex, getAddress } from "viem";
+import { QuoteType, } from "./iface";
+import { Universe } from "../proto/definition";
+import { encodeChainID36 } from "../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]) => [bytesToHex(encodeChainID36(Universe.ETHEREUM, v)), k]));
+export 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.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(bytesToHex(r.chain.toBytes()));
+            if (chainName == null) {
+                return null;
+            }
+            let respPromise;
+            const inputTokenAddr = getAddress(bytesToHex(r.inputToken.subarray(12)));
+            const outputTokenAddr = getAddress(bytesToHex(r.outputToken.subarray(12)));
+            const userAddrHex = getAddress(bytesToHex(r.userAddress.subarray(12)));
+            switch (r.type) {
+                case 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 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 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;
+                }
+            }
+        });
+    }
+}

package/dist/esm/xcs/iface.js

@@ -0,0 +1,10 @@
+export var QuoteType;
+(function (QuoteType) {
+    QuoteType[QuoteType["EXACT_IN"] = 0] = "EXACT_IN";
+    QuoteType[QuoteType["EXACT_OUT"] = 1] = "EXACT_OUT";
+})(QuoteType || (QuoteType = {}));
+export var QuoteSeriousness;
+(function (QuoteSeriousness) {
+    QuoteSeriousness[QuoteSeriousness["PRICE_SURVEY"] = 0] = "PRICE_SURVEY";
+    QuoteSeriousness[QuoteSeriousness["SERIOUS"] = 1] = "SERIOUS";
+})(QuoteSeriousness || (QuoteSeriousness = {}));

package/dist/esm/xcs/index.js

@@ -0,0 +1,5 @@
+export * from './iface';
+export * from './lifi-agg';
+export * from './yieldyak-agg';
+export * from './bebop-agg';
+export * from './autochoice';

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

@@ -0,0 +1,99 @@
+import axios, { AxiosError } from "axios";
+import { bytesToHex, getAddress } from "viem";
+import { QuoteType, } from "./iface";
+import { Universe } from "../proto/definition";
+export class LiFiAggregator {
+    static BASE_URL_V1 = "https://li.quest/v1";
+    static COMMON_OPTIONS = {
+        denyExchanges: "openocean",
+        slippage: "0.01",
+    };
+    axios;
+    constructor(apiKey) {
+        this.axios = axios.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 !== Universe.ETHEREUM) {
+                return null;
+            }
+            let respPromise;
+            const chIDStr = r.chain.chainID.toString();
+            const inputTokenAddr = getAddress(bytesToHex(r.inputToken.subarray(12)));
+            const outputTokenAddr = getAddress(bytesToHex(r.outputToken.subarray(12)));
+            const userAddrHex = getAddress(bytesToHex(r.userAddress.subarray(12)));
+            switch (r.type) {
+                case 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 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 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;
+                }
+            }
+        });
+    }
+}