@avail-project/ca-common 2.2.1 → 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).toNumber(),
-                    symbol: sellT.symbol,
-                },
-                output: {
-                    amount: outputAmountInDecimal,
-                    amountRaw: BigInt(buyT.minimumAmount),
-                    contractAddress: outputTokenAddr,
-                    decimals: buyT.decimals,
-                    value: Decimal.mul(buyT.priceUsd, outputAmountInDecimal).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,5 +0,0 @@
-export * from './iface';
-export * from './lifi-agg';
-export * from './bebop-agg';
-export * from './fibrous-agg';
-export * from './autochoice';

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

@@ -1,150 +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";
-    static COMMON_OPTIONS = {
-        denyExchanges: "openocean",
-        slippage: "0.01",
-        skipSimulation: true,
-    };
-    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,
-                        },
-                    });
-                    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,
-                        },
-                    });
-                    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;
-                }
-            }
-        });
-    }
-}

package/dist/types/_polyfill.d.ts

@@ -1 +0,0 @@
-export declare function ensureBufferPolyfill(): void;

package/dist/types/balances/ub-api.d.ts

@@ -1,14 +0,0 @@
-import Decimal from "decimal.js";
-import { Universe } from "../proto/definition";
-import { Bytes } from "../types";
-import { OmniversalChainID } from "../data";
-export type BalanceOnChain = {
-    chainID: OmniversalChainID;
-    totalValue: Decimal;
-    currencywise: {
-        tokenAddress: Buffer;
-        amount: Decimal;
-        value: Decimal;
-    }[];
-};
-export declare function getBalances(vscURL: string, universe: Universe, address: Bytes): Promise<BalanceOnChain[]>;

package/dist/types/cosmos/index.d.ts

@@ -1,6 +0,0 @@
-import { Registry as CosmosRegistry, OfflineDirectSigner, DirectSecp256k1Wallet } from "@cosmjs/proto-signing";
-import { HttpEndpoint, SigningStargateClient, SigningStargateClientOptions } from "@cosmjs/stargate";
-import { Bytes } from "../types";
-export declare const Registry: CosmosRegistry;
-export declare function createCosmosWallet(privateKey: string | Bytes): Promise<DirectSecp256k1Wallet>;
-export declare function createCosmosClient(signer: OfflineDirectSigner, endpoint: string | HttpEndpoint, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;

package/dist/types/data/chaindata.d.ts

@@ -1,20 +0,0 @@
-import { Universe } from "../proto/definition";
-import { ChainIDKeyedMap, OmniversalChainID } from "./chainid";
-import { Currency } from "./currency";
-import { ezPadTo32Hex } from "./utils";
-declare class CurrencyMap {
-    private readonly map;
-    constructor(currencies: Currency[]);
-    get(input: Parameters<typeof ezPadTo32Hex>[0]): Currency | undefined;
-}
-export type ChainDatum = {
-    ChainID: OmniversalChainID;
-    Universe: Universe;
-    ChainID32: Buffer;
-    Currencies: Currency[];
-    CurrencyMap: CurrencyMap;
-};
-export declare const Chaindata: ChainDatum[];
-export declare const ChaindataMap: ChainIDKeyedMap<ChainDatum>;
-export declare const RPCURLMap: ChainIDKeyedMap<string>;
-export {};

package/dist/types/data/chainid.d.ts

@@ -1,31 +0,0 @@
-import { type Hex } from "viem";
-import { Universe } from "../proto/definition";
-import { Bytes } from "../types";
-export declare function encodeChainID36(universe: Universe, chainID: Bytes | bigint | number): Buffer;
-export declare class OmniversalChainID {
-    readonly universe: Universe;
-    readonly chainID: bigint;
-    private readonly binaryForm;
-    constructor(universe: Universe, chainID: bigint | number | string | Bytes);
-    toString(): string;
-    toJSON(): {
-        universe: string;
-        chainID: `0x${string}`;
-    };
-    static fromJSON(input: {
-        universe: string;
-        chainID: Hex;
-    }): OmniversalChainID;
-    static fromChainID36(_input: Bytes): OmniversalChainID;
-    toBytes(): Buffer;
-    equals(rhs: OmniversalChainID): boolean;
-    static equals(lhs: OmniversalChainID, rhs: OmniversalChainID): boolean;
-}
-export declare class ChainIDKeyedMap<V> {
-    private readonly map;
-    constructor(entries?: readonly [OmniversalChainID, V][] | null);
-    get(key: OmniversalChainID): V | undefined;
-    set(key: OmniversalChainID, value: V): this;
-    getFromChainID36(key: Bytes): V | undefined;
-    entries(): Generator<[OmniversalChainID, V]>;
-}

package/dist/types/data/currency.d.ts

@@ -1,30 +0,0 @@
-import { Hex } from "viem";
-import Decimal from "decimal.js";
-import { Bytes } from "../types";
-import { PermitVariant } from "../permitutils";
-export declare enum CurrencyID {
-    USDC = 1,
-    USDT = 2,
-    ETH = 3,
-    POL = 4,
-    AVAX = 5,
-    BNB = 6,
-    HYPE = 16,
-    KAIA = 17,
-    SOPH = 18,
-    TRX = 19,
-    MON = 20,
-    CBTC = 21
-}
-export declare class Currency {
-    readonly currencyID: CurrencyID;
-    readonly decimals: number;
-    readonly permitVariant: PermitVariant;
-    readonly permitContractVersion: number;
-    readonly isGasToken: boolean;
-    readonly tokenAddress: Buffer;
-    private readonly oneUnitToAtomicUnitRatio;
-    constructor(currencyID: CurrencyID, tokenAddress: string | Bytes | number[], decimals: number, permitVariant: PermitVariant, permitContractVersion: number | undefined, isGasToken: boolean);
-    convertUnitsToAmountDecimal(input: bigint | number | Hex | Bytes): Decimal;
-    convertAmountToUnitsInBinary(input: Decimal): Buffer;
-}

package/dist/types/data/index.d.ts

@@ -1,4 +0,0 @@
-export * from './chaindata';
-export * from './chainid';
-export * from './currency';
-export * from './utils';

package/dist/types/data/utils.d.ts

@@ -1,10 +0,0 @@
-import { Hex, toHex } from "viem";
-import Decimal from "decimal.js";
-import { Bytes } from "../types";
-export declare function convertToBufferIfNecessary(buf: Bytes): Buffer<ArrayBufferLike>;
-export declare function zeroExtendBufToGivenSize(buf: Bytes, size?: number): Buffer;
-export declare function ezPadTo32Hex(input: Hex | Parameters<typeof toHex>[0]): Hex;
-export declare function convertDecimalToBigInt(dec: Decimal): bigint;
-export declare function convertBigIntToDecimal(big: bigint): Decimal;
-export declare function maxByBigInt<T>(items: readonly T[], getValue: (element: T) => bigint): T;
-export declare function minByBigInt<T>(items: readonly T[], getValue: (element: T) => bigint): T;