@avail-project/ca-common 1.0.1 → 2.1.0

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

@@ -0,0 +1,144 @@
+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"],
+    [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;
+    constructor(options = {}) {
+        const { apiKey, slippage = 0.5 } = options;
+        this.slippage = slippage;
+        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)));
+            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: userAddrHex,
+                    },
+                });
+            }
+            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/index.js

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

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

@@ -2,11 +2,13 @@ import axios, { AxiosError } from "axios";
 import { bytesToHex, getAddress } from "viem";
 import { QuoteType, } from "./iface";
 import { Universe } from "../proto/definition";
+import Decimal from "decimal.js";
 export class LiFiAggregator {
     static BASE_URL_V1 = "https://li.quest/v1";
     static COMMON_OPTIONS = {
         denyExchanges: "openocean",
         slippage: "0.01",
+        skipSimulation: true,
     };
     axios;
     constructor(apiKey) {
@@ -15,6 +17,7 @@ export class LiFiAggregator {
             headers: {
                 "x-lifi-api-key": apiKey,
             },
+            timeout: 10_000,
         });
     }
     async getQuotes(requests) {
@@ -76,12 +79,38 @@ export class LiFiAggregator {
                 }
                 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 {
-                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.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) => {

package/dist/types/evmabi/fibrousrouter.abi.d.ts

@@ -0,0 +1,77 @@
+export declare const FibrousRouterABI: readonly [{
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "token_in";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "token_out";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount_in";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount_out";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "min_received";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "destination";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint8";
+            readonly name: "swap_type";
+            readonly type: "uint8";
+        }];
+        readonly internalType: "struct IFibrousRouter.RouteParam";
+        readonly name: "route";
+        readonly type: "tuple";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "token_in";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "token_out";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint32";
+            readonly name: "rate";
+            readonly type: "uint32";
+        }, {
+            readonly internalType: "int24";
+            readonly name: "protocol_id";
+            readonly type: "int24";
+        }, {
+            readonly internalType: "address";
+            readonly name: "pool_address";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint8";
+            readonly name: "swap_type";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "extra_data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct IFibrousRouter.SwapParams[]";
+        readonly name: "swap_parameters";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "swap";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];

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

@@ -1,3 +1,4 @@
 export * from './erc20.abi';
 export * from './vault.abi';
 export * from './yakaggregator.abi';
+export * from './fibrousrouter.abi';

package/dist/types/proto/definition.d.ts

@@ -227,12 +227,18 @@ export interface AdminFeeRecipient {
     universe: Universe;
     address: Uint8Array;
 }
+export interface PerChainFeeBP {
+    universe: Universe;
+    chainID: Uint8Array;
+    feeBP: Long;
+}
 export interface ProtocolFees {
     feeBP: Long;
     collectionFees: FixedFeeTuple[];
     fulfilmentFees: FixedFeeTuple[];
     admin: string;
     feeRecipients: AdminFeeRecipient[];
+    perChainFeeBP: PerChainFeeBP[];
 }
 export interface QueryGetProtocolFeesRequest {
 }
@@ -245,6 +251,7 @@ export interface MsgCreateProtocolFees {
     collectionFees: FixedFeeTuple[];
     fulfilmentFees: FixedFeeTuple[];
     feeRecipients: AdminFeeRecipient[];
+    perChainFeeBP: PerChainFeeBP[];
 }
 export interface MsgCreateProtocolFeesResponse {
 }
@@ -254,6 +261,7 @@ export interface MsgUpdateProtocolFees {
     collectionFees: FixedFeeTuple[];
     fulfilmentFees: FixedFeeTuple[];
     feeRecipients: AdminFeeRecipient[];
+    perChainFeeBP: PerChainFeeBP[];
 }
 export interface MsgUpdateProtocolFeesResponse {
 }
@@ -330,6 +338,7 @@ export declare const QueryAllSettlementResponse: MessageFns<QueryAllSettlementRe
 export declare const QueryRequestForFundsByAddressRequest: MessageFns<QueryRequestForFundsByAddressRequest>;
 export declare const FixedFeeTuple: MessageFns<FixedFeeTuple>;
 export declare const AdminFeeRecipient: MessageFns<AdminFeeRecipient>;
+export declare const PerChainFeeBP: MessageFns<PerChainFeeBP>;
 export declare const ProtocolFees: MessageFns<ProtocolFees>;
 export declare const QueryGetProtocolFeesRequest: MessageFns<QueryGetProtocolFeesRequest>;
 export declare const QueryGetProtocolFeesResponse: MessageFns<QueryGetProtocolFeesResponse>;

package/dist/types/xcs/autochoice.d.ts

@@ -1,16 +1,8 @@
 import Decimal from "decimal.js";
-import { Aggregator, Quote, QuoteRequestExactInput, QuoteRequestExactOutput } from "./iface";
+import { Aggregator, Quote, QuoteRequestExactInput, QuoteRequestExactOutput, QuoteResponse } from "./iface";
 import { Currency, CurrencyID, OmniversalChainID } from "../data";
 import { Bytes } from "../types";
-import { FixedFeeTuple } from "../proto/definition";
-type Asset = {
-    tokenAddress: Bytes;
-    amount: bigint;
-};
-export type Holding = {
-    chainID: OmniversalChainID;
-    value: number;
-} & Asset;
+import { Holding } from "./iface";
 export declare class AutoSelectionError extends Error {
 }
 declare const enum AggregateAggregatorsMode {
@@ -22,15 +14,7 @@ export declare function aggregateAggregators(requests: (QuoteRequestExactInput |
     aggregator: Aggregator;
 }[]>;
 export declare function autoSelectSourcesV2(userAddress: Bytes, holdings: Holding[], outputRequired: Decimal, aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<{
-    quotes: ({
-        req: QuoteRequestExactInput;
-        originalHolding: Holding;
-        cur: Currency;
-        idx: number;
-    } & {
-        quote: Quote;
-        agg: Aggregator;
-    })[];
+    quoteResponses: QuoteResponse[];
     usedCOTs: {
         originalHolding: Holding;
         amountUsed: Decimal;
@@ -38,37 +22,7 @@ export declare function autoSelectSourcesV2(userAddress: Bytes, holdings: Holdin
         cur: Currency;
     }[];
 }>;
-export declare function autoSelectSources(userAddress: Bytes, holdings: Holding[], outputRequired: Decimal, aggregators: Aggregator[], collectionFees: FixedFeeTuple[], commonCurrencyID?: CurrencyID): Promise<({
-    req: QuoteRequestExactInput;
-    cfee: bigint;
-    originalHolding: Holding;
-    cur: Currency;
-} & {
-    quote: Quote;
-    agg: Aggregator;
-})[]>;
-export declare function determineDestinationSwaps(userAddress: Bytes, chainID: OmniversalChainID, requirement: Asset, aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<{
-    quote: Quote | null;
-    aggregator: Aggregator;
-    inputAmount: Decimal;
-    outputAmount: bigint;
-}>;
-export declare function liquidateInputHoldings(userAddress: Bytes, holdings: Holding[], aggregators: Aggregator[], collectionFees: FixedFeeTuple[], commonCurrencyID?: CurrencyID): Promise<{
-    quotes: {
-        agg: Aggregator;
-        quote: Quote;
-        req: QuoteRequestExactInput;
-        cfee: bigint;
-        originalHolding: Holding;
-        cur: Currency;
-        aggregator: Aggregator;
-    }[];
-    total: Decimal;
-}>;
-export declare function destinationSwapWithExactIn(userAddress: Bytes, chainID: OmniversalChainID, inputAmount: bigint, outputToken: Bytes, aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<{
-    inputAmount: Decimal;
-    outputAmount: bigint;
-    quote: Quote | null;
-    aggregator: Aggregator;
-}>;
+export declare function determineDestinationSwaps(userAddress: Bytes, requirement: Holding, aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<QuoteResponse>;
+export declare function liquidateInputHoldings(userAddress: Bytes, holdings: Holding[], aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<QuoteResponse[]>;
+export declare function destinationSwapWithExactIn(userAddress: Bytes, omniChainID: OmniversalChainID, inputAmount: bigint, outputToken: Bytes, aggregators: Aggregator[], inputCurrency?: CurrencyID): Promise<QuoteResponse>;
 export {};

package/dist/types/xcs/bebop-agg.d.ts

@@ -35,7 +35,7 @@ export type BebopCommonQuote = {
         priceBeforeFee: number;
     }>;
     settlementAddress: string;
-    approvalTarget: string;
+    approvalTarget: Hex;
     requiredSignatures: Array<never>;
     priceImpact: number;
     warnings: Array<never>;
@@ -100,5 +100,5 @@ export declare class BebopAggregator implements Aggregator {
     private static readonly COMMON_OPTIONS;
     private readonly axios;
     constructor(apiKey: string);
-    getQuotes(requests: (QuoteRequestExactInput | QuoteRequestExactOutput)[]): Promise<(BebopQuote | null)[]>;
+    getQuotes(requests: (QuoteRequestExactInput | QuoteRequestExactOutput)[]): Promise<(Quote | null)[]>;
 }

package/dist/types/xcs/fibrous-agg.d.ts

@@ -0,0 +1,54 @@
+import { Hex } from "viem";
+import { Aggregator, Quote, QuoteRequestExactInput, QuoteRequestExactOutput } from "./iface";
+export type FibrousToken = {
+    name: string;
+    symbol?: string;
+    address: Hex;
+    decimals: number;
+    price: number | string | null;
+};
+export type FibrousResponse = {
+    route: {
+        success: boolean;
+        routeSwapType: number;
+        inputToken: FibrousToken;
+        inputAmount: string;
+        outputToken: FibrousToken;
+        outputAmount: string;
+    };
+    calldata: {
+        route: {
+            token_in: Hex;
+            token_out: Hex;
+            amount_in: string;
+            amount_out: string;
+            min_received: string;
+            destination: Hex;
+            swap_type: number;
+        };
+        swap_parameters: Array<{
+            token_in: Hex;
+            token_out: Hex;
+            rate: string;
+            protocol_id: string;
+            pool_address: Hex;
+            swap_type: number;
+            extra_data: Hex;
+        }>;
+    };
+    router_address: Hex;
+};
+export type FibrousQuote = Quote & {
+    originalResponse: FibrousResponse;
+};
+export type FibrousAggregatorOptions = {
+    apiKey?: string;
+    slippage?: number;
+};
+export declare class FibrousAggregator implements Aggregator {
+    private static readonly BASE_URL;
+    private readonly axios;
+    private readonly slippage;
+    constructor(options?: FibrousAggregatorOptions);
+    getQuotes(requests: (QuoteRequestExactInput | QuoteRequestExactOutput)[]): Promise<(Quote | null)[]>;
+}

package/dist/types/xcs/iface.d.ts

@@ -1,5 +1,6 @@
 import { Bytes } from "../types";
 import { OmniversalChainID } from "../data";
+import { Hex } from "viem";
 export declare enum QuoteType {
     EXACT_IN = 0,
     EXACT_OUT = 1
@@ -8,12 +9,43 @@ export declare enum QuoteSeriousness {
     PRICE_SURVEY = 0,
     SERIOUS = 1
 }
+export type QuoteResponse = {
+    chainID: number;
+    quote: Quote;
+    holding: Holding;
+    aggregator: Aggregator;
+};
+export type Holding = {
+    chainID: OmniversalChainID;
+    tokenAddress: Bytes;
+    amountRaw: bigint;
+};
 export interface Quote {
-    originalResponse: unknown;
-    type: QuoteType;
-    inputAmount: bigint;
-    outputAmountMinimum: bigint;
-    outputAmountLikely: bigint;
+    expiry?: number;
+    input: {
+        contractAddress: Hex;
+        amount: string;
+        amountRaw: bigint;
+        decimals: number;
+        value: number;
+        symbol: string;
+    };
+    output: {
+        contractAddress: Hex;
+        amount: string;
+        amountRaw: bigint;
+        decimals: number;
+        value: number;
+        symbol: string;
+    };
+    txData: {
+        approvalAddress: Hex;
+        tx: {
+            to: Hex;
+            data: Hex;
+            value: Hex;
+        };
+    };
 }
 type CommonQuoteParameters = {
     userAddress: Bytes;

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

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

package/dist/types/xcs/lifi-agg.d.ts

@@ -1,35 +1,39 @@
+import { Hex } from "viem";
 import { Aggregator, Quote, QuoteRequestExactInput, QuoteRequestExactOutput } from "./iface";
 export type LiFiResponse = {
     type: string;
     id: string;
     estimate: {
         tool: string;
-        approvalAddress: string;
+        approvalAddress: Hex;
         toAmountMin: string;
         toAmount: string;
         fromAmount: string;
         executionDuration: number;
-        fromAmountUSD: string;
-        toAmountUSD: string;
+    };
+    action: {
+        fromToken: {
+            symbol: string;
+            decimals: number;
+            priceUSD: string;
+        };
+        toToken: {
+            symbol: string;
+            decimals: number;
+            priceUSD: string;
+        };
     };
     integrator: string;
     transactionRequest: {
-        value: string;
-        to: string;
-        data: string;
-        chainId: number;
-        gasPrice: string;
-        gasLimit: string;
-        from: string;
+        value: Hex;
+        to: Hex;
+        data: Hex;
     };
 };
-export type LiFiQuote = Quote & {
-    originalResponse: LiFiResponse;
-};
 export declare class LiFiAggregator implements Aggregator {
     private static readonly BASE_URL_V1;
     private static readonly COMMON_OPTIONS;
     private readonly axios;
     constructor(apiKey: string);
-    getQuotes(requests: (QuoteRequestExactInput | QuoteRequestExactOutput)[]): Promise<(LiFiQuote | null)[]>;
+    getQuotes(requests: (QuoteRequestExactInput | QuoteRequestExactOutput)[]): Promise<(Quote | null)[]>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avail-project/ca-common",
-  "version": "1.0.1",
+  "version": "2.1.0",
   "description": "common utilities for CA",
   "files": [
     "dist"
@@ -63,7 +63,10 @@
     "es-toolkit": "^1.39.7",
     "tslib": "^2.8.1"
   },
+  "publishConfig": {
+    "provenance": true
+  },
   "repository": {
-    "url": "https://github.com/availproject/ca-common"
+    "url": "git+https://github.com/availproject/ca-common.git"
   }
 }