@avail-project/ca-common 2.3.0 → 3.0.0

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

@@ -1,151 +0,0 @@
-import axios, { AxiosError } from "axios";
-import { bytesToHex, getAddress } from "viem";
-import { QuoteType, } from "./iface";
-import { Universe } from "../proto/definition";
-import { encodeChainID36 } from "../data";
-import Decimal from "decimal.js";
-// https://api.bebop.xyz/{jam|pmm}/chains
-const ChainNameMapping = new Map(Object.entries({
-    ethereum: 1,
-    arbitrum: 42161,
-    optimism: 10,
-    base: 8453,
-    bsc: 56,
-    avalanche: 43114,
-    polygon: 137,
-    scroll: 534352,
-    hyperevm: 999,
-}).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",
-            },
-            timeout: 10_000,
-        });
-    }
-    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)));
-            const receiverAddrHex = r.receiverAddress != null
-                ? getAddress(bytesToHex(r.receiverAddress.subarray(12)))
-                : userAddrHex;
-            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,
-                            receiver_address: receiverAddrHex,
-                            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,
-                            receiver_address: receiverAddrHex,
-                            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];
-            const sellT = bestRoute.quote.sellTokens[inputTokenAddr];
-            const outputAmountInDecimal = new Decimal(buyT.minimumAmount)
-                .div(Decimal.pow(10, buyT.decimals))
-                .toFixed(buyT.decimals);
-            const inputAmountInDecimal = new Decimal(sellT.amount)
-                .div(Decimal.pow(10, sellT.decimals))
-                .toFixed(sellT.decimals);
-            return {
-                expiry: bestRoute.quote.expiry,
-                input: {
-                    amount: inputAmountInDecimal,
-                    amountRaw: BigInt(sellT.amount),
-                    contractAddress: inputTokenAddr,
-                    decimals: sellT.decimals,
-                    value: Decimal.mul(inputAmountInDecimal, sellT.priceUsd ?? 0).toNumber(),
-                    symbol: sellT.symbol,
-                },
-                output: {
-                    amount: outputAmountInDecimal,
-                    amountRaw: BigInt(buyT.minimumAmount),
-                    contractAddress: outputTokenAddr,
-                    decimals: buyT.decimals,
-                    value: Decimal.mul(outputAmountInDecimal, buyT.priceUsd ?? 0).toNumber(),
-                    symbol: buyT.symbol,
-                },
-                txData: {
-                    approvalAddress: bestRoute.quote.approvalTarget,
-                    tx: {
-                        to: bestRoute.quote.tx.to,
-                        value: bestRoute.quote.tx.value,
-                        data: bestRoute.quote.tx.data,
-                    },
-                },
-            };
-        }));
-        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/fibrous-agg.js

@@ -1,150 +0,0 @@
-import axios, { AxiosError } from "axios";
-import Decimal from "decimal.js";
-import { bytesToHex, encodeFunctionData, getAddress, toHex, zeroAddress, } from "viem";
-import { ChainIDKeyedMap, OmniversalChainID } from "../data";
-import { FibrousRouterABI } from "../evmabi";
-import { Universe } from "../proto/definition";
-import { QuoteType, } from "./iface";
-const ChainNameMapping = new ChainIDKeyedMap([
-    // [new OmniversalChainID(Universe.ETHEREUM, 8453), "base"], // Disabled because of few liquidity issues
-    [new OmniversalChainID(Universe.ETHEREUM, 999), "hyperevm"],
-    [new OmniversalChainID(Universe.ETHEREUM, 143), "monad"],
-    [new OmniversalChainID(Universe.ETHEREUM, 4114), "citrea"],
-]);
-export class FibrousAggregator {
-    static BASE_URL = "https://api.fibrous.finance";
-    axios;
-    slippage;
-    excludeProtocols;
-    constructor(options = {}) {
-        const { apiKey, slippage = 0.5, excludeProtocols = "3" } = options;
-        this.slippage = slippage;
-        this.excludeProtocols = excludeProtocols;
-        this.axios = axios.create({
-            baseURL: FibrousAggregator.BASE_URL,
-            headers: apiKey != null ? { "X-API-Key": apiKey } : undefined,
-            timeout: 10_000,
-        });
-    }
-    async getQuotes(requests) {
-        const list = await Promise.allSettled(requests.map(async (r) => {
-            if (r.type === QuoteType.EXACT_OUT) {
-                return null;
-            }
-            if (r.chain.universe !== Universe.ETHEREUM) {
-                return null;
-            }
-            const chainName = ChainNameMapping.get(r.chain);
-            if (chainName == null) {
-                return null;
-            }
-            const inputTokenAddr = getAddress(bytesToHex(r.inputToken.subarray(12)));
-            const outputTokenAddr = getAddress(bytesToHex(r.outputToken.subarray(12)));
-            const userAddrHex = getAddress(bytesToHex(r.userAddress.subarray(12)));
-            const receiverAddrHex = r.receiverAddress != null
-                ? getAddress(bytesToHex(r.receiverAddress.subarray(12)))
-                : userAddrHex;
-            let resp;
-            try {
-                resp = await this.axios({
-                    method: "GET",
-                    url: `/${chainName}/v2/routeAndCallData`,
-                    params: {
-                        amount: r.inputAmount.toString(),
-                        tokenInAddress: inputTokenAddr,
-                        tokenOutAddress: outputTokenAddr,
-                        slippage: this.slippage,
-                        destination: receiverAddrHex,
-                        excludeProtocols: this.excludeProtocols,
-                    },
-                });
-            }
-            catch (e) {
-                if (e instanceof AxiosError && e.isAxiosError) {
-                    return null;
-                }
-                throw e;
-            }
-            if (!resp.data.route.success) {
-                return null;
-            }
-            if (resp.data.calldata.swap_parameters.length === 0) {
-                return null;
-            }
-            const inputAmountInDecimal = new Decimal(resp.data.route.inputAmount)
-                .div(Decimal.pow(10, resp.data.route.inputToken.decimals))
-                .toFixed(resp.data.route.inputToken.decimals);
-            const outputAmountInDecimal = new Decimal(resp.data.calldata.route.min_received)
-                .div(Decimal.pow(10, resp.data.route.outputToken.decimals))
-                .toFixed(resp.data.route.outputToken.decimals);
-            const routerAddress = getAddress(resp.data.router_address);
-            const isNativeInput = resp.data.calldata.route.swap_type === 0;
-            const quote = {
-                originalResponse: resp.data,
-                input: {
-                    amount: inputAmountInDecimal,
-                    amountRaw: BigInt(resp.data.route.inputAmount),
-                    contractAddress: inputTokenAddr,
-                    decimals: resp.data.route.inputToken.decimals,
-                    value: Decimal.mul(inputAmountInDecimal, resp.data.route.inputToken.price ?? 0).toNumber(),
-                    symbol: resp.data.route.inputToken.symbol ??
-                        resp.data.route.inputToken.name,
-                },
-                output: {
-                    amount: outputAmountInDecimal,
-                    amountRaw: BigInt(resp.data.calldata.route.min_received),
-                    contractAddress: outputTokenAddr,
-                    decimals: resp.data.route.outputToken.decimals,
-                    value: Decimal.mul(outputAmountInDecimal, resp.data.route.outputToken.price ?? 0).toNumber(),
-                    symbol: resp.data.route.outputToken.symbol ??
-                        resp.data.route.outputToken.name,
-                },
-                txData: {
-                    approvalAddress: isNativeInput ? zeroAddress : routerAddress,
-                    tx: {
-                        to: routerAddress,
-                        value: isNativeInput
-                            ? toHex(BigInt(resp.data.calldata.route.amount_in))
-                            : toHex(0),
-                        data: encodeFunctionData({
-                            abi: FibrousRouterABI,
-                            functionName: "swap",
-                            args: [
-                                {
-                                    token_in: getAddress(resp.data.calldata.route.token_in),
-                                    token_out: getAddress(resp.data.calldata.route.token_out),
-                                    amount_in: BigInt(resp.data.calldata.route.amount_in),
-                                    amount_out: BigInt(resp.data.calldata.route.amount_out),
-                                    min_received: BigInt(resp.data.calldata.route.min_received),
-                                    destination: getAddress(resp.data.calldata.route.destination),
-                                    swap_type: resp.data.calldata.route.swap_type,
-                                },
-                                resp.data.calldata.swap_parameters.map((swapParameter) => ({
-                                    token_in: getAddress(swapParameter.token_in),
-                                    token_out: getAddress(swapParameter.token_out),
-                                    rate: Number.parseInt(swapParameter.rate, 10),
-                                    protocol_id: Number.parseInt(swapParameter.protocol_id, 10),
-                                    pool_address: getAddress(swapParameter.pool_address),
-                                    swap_type: swapParameter.swap_type,
-                                    extra_data: swapParameter.extra_data,
-                                })),
-                            ],
-                        }),
-                    },
-                },
-            };
-            return quote;
-        }));
-        return list.map((item) => {
-            switch (item.status) {
-                case "fulfilled": {
-                    return item.value;
-                }
-                case "rejected": {
-                    console.error("Caught error in fetching Fibrous quotes:", item.reason);
-                    return null;
-                }
-            }
-        });
-    }
-}

package/dist/esm/xcs/iface.js

@@ -1,10 +0,0 @@
-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

@@ -1,6 +0,0 @@
-export * from './iface';
-export * from './lifi-agg';
-export * from './bebop-agg';
-export * from './fibrous-agg';
-export * from './autochoice';
-export * from './selectsources';

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

@@ -1,172 +0,0 @@
-import axios, { AxiosError } from "axios";
-import { bytesToHex, getAddress } from "viem";
-import { QuoteType, } from "./iface";
-import { Universe } from "../proto/definition";
-import Decimal from "decimal.js";
-const ALLOWED_CHAINS = new Set([
-    1, // Ethereum
-    10, // Optimism
-    56, // BSC
-    137, // Polygon
-    143, // Monad
-    999, // HyperEVM
-    4326, // MegaETH
-    8453, // Base
-    42161, // Arbitrum
-    43114, // Avalanche
-    8217, // Kaia
-    534352, // Scroll
-]);
-export class LiFiAggregator {
-    static BASE_URL_V1 = "https://li.quest/v1";
-    // Params that don't depend on chain — spread into every quote request.
-    // `denyExchanges` is built per-call via `denyExchangesFor(chainId)`.
-    static COMMON_OPTIONS = {
-        slippage: "0.01",
-        skipSimulation: true,
-    };
-    // Tools denied on every chain.
-    static GLOBAL_DENY = ["openocean"];
-    // Tools denied only on specific chains. Add an entry here when a tool quotes
-    // well on most chains but mis-quotes on a specific one — global-denying it
-    // would needlessly disable healthy routes elsewhere.
-    //
-    // 999 (HyperEVM): fly/hyperflow/liquidswap all share the same on-chain entry
-    //   (0x0a0758d937d1059c356d4714e57f5df0239bce1a) and systematically over-quote
-    //   native HYPE -> USDC routes by 5-11% (LI.FI /quote toAmountMin vs on-chain
-    //   delivery, observed via InsufficientAmountOut(0xe52970aa) failures in
-    //   HyperEVM Safe-mode swaps). They quote within ±0.2% of other tools on
-    //   Ethereum/Base/Arbitrum/Polygon/Optimism, so the deny is chain-local.
-    static PER_CHAIN_DENY = {
-        999: ["fly", "hyperflow", "liquidswap"],
-    };
-    denyExchangesFor(chainId) {
-        const perChain = LiFiAggregator.PER_CHAIN_DENY[chainId] ?? [];
-        return [...LiFiAggregator.GLOBAL_DENY, ...perChain].join(",");
-    }
-    axios;
-    constructor(apiKey) {
-        this.axios = axios.create({
-            baseURL: LiFiAggregator.BASE_URL_V1,
-            headers: {
-                "x-lifi-api-key": apiKey,
-            },
-            timeout: 10_000,
-        });
-    }
-    async getQuotes(requests) {
-        const list = await Promise.allSettled(requests.map(async (r) => {
-            if (r.chain.universe !== Universe.ETHEREUM) {
-                return null;
-            }
-            if (!ALLOWED_CHAINS.has(Number(r.chain.chainID))) {
-                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)));
-            const receiverAddrHex = r.receiverAddress != null
-                ? getAddress(bytesToHex(r.receiverAddress.subarray(12)))
-                : userAddrHex;
-            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,
-                            toAddress: receiverAddrHex,
-                            fromAmount: r.inputAmount.toString(),
-                            ...LiFiAggregator.COMMON_OPTIONS,
-                            denyExchanges: this.denyExchangesFor(Number(r.chain.chainID)),
-                        },
-                    });
-                    break;
-                }
-                case QuoteType.EXACT_OUT: {
-                    respPromise = this.axios({
-                        method: "GET",
-                        url: "/quote/toAmount",
-                        params: {
-                            fromChain: chIDStr,
-                            toChain: chIDStr,
-                            fromToken: inputTokenAddr,
-                            toToken: outputTokenAddr,
-                            fromAddress: userAddrHex,
-                            toAddress: receiverAddrHex,
-                            toAmount: r.outputAmount.toString(),
-                            ...LiFiAggregator.COMMON_OPTIONS,
-                            denyExchanges: this.denyExchangesFor(Number(r.chain.chainID)),
-                        },
-                    });
-                    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 { estimate, transactionRequest: { to, value, data }, action: { fromToken, toToken }, } = resp.data;
-            const inputAmountInDecimal = new Decimal(estimate.fromAmount)
-                .div(Decimal.pow(10, fromToken.decimals))
-                .toFixed(fromToken.decimals);
-            const outputAmountInDecimal = new Decimal(estimate.toAmountMin)
-                .div(Decimal.pow(10, toToken.decimals))
-                .toFixed(toToken.decimals);
-            return {
-                input: {
-                    amount: inputAmountInDecimal,
-                    amountRaw: BigInt(estimate.fromAmount),
-                    contractAddress: inputTokenAddr,
-                    decimals: fromToken.decimals,
-                    value: Decimal.mul(inputAmountInDecimal, fromToken.priceUSD).toNumber(),
-                    symbol: fromToken.symbol,
-                },
-                output: {
-                    amount: outputAmountInDecimal,
-                    amountRaw: BigInt(estimate.toAmountMin),
-                    contractAddress: outputTokenAddr,
-                    decimals: toToken.decimals,
-                    value: Decimal.mul(outputAmountInDecimal, toToken.priceUSD).toNumber(),
-                    symbol: toToken.symbol,
-                },
-                txData: {
-                    approvalAddress: estimate.approvalAddress,
-                    tx: {
-                        to,
-                        value,
-                        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;
-                }
-            }
-        });
-    }
-}