@merkl/api 0.0.22

package/dist/src/modules/v4/enso/enso.model.d.ts

@@ -0,0 +1,166 @@
+export declare const slugToProtocolId: {
+    "uniswap-v2": "uniswap";
+    "aave-v3": "aave";
+    "aave-v2": "aave";
+    "aave-static-atokens": "aave";
+    "camelot-v2": "camelot";
+    "meta-morpho": "morpho";
+    "morpho-blue-vaults": "morpho";
+    "balancer-v2": "balancer";
+    "balancer-gauge": "balancer";
+    "aura-lp": "aura";
+    aura: "aura";
+    beefy: "beefy";
+    venus: "venus";
+    "compound-v3": "compound";
+    "curve-gauge": "curve";
+    "euler-v2": "euler";
+    fluid: "fluid";
+    fraxlend: "frax";
+    "frax-ether": "frax";
+    "gearbox-v3": "gearbox";
+    gearbox: "gearbox";
+    moonwell: "moonwell";
+    "pancakeswap-amm-v3": "pancake-swap";
+    "quickswap-dex": "quickswap";
+    "silo-protected": "silo";
+    silo: "silo";
+    "velodrome-v2-staking": "velodrome";
+    zerolend: "zerolend";
+};
+export type EnsoSlug = keyof typeof slugToProtocolId;
+export declare const apiTypes: {
+    "/v1/protocols": {
+        query: import("@sinclair/typebox").TObject<{
+            slug: import("@sinclair/typebox").TString;
+        }>;
+        response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            slug: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            desription: import("@sinclair/typebox").TString;
+            url: import("@sinclair/typebox").TString;
+            logosUri: import("@sinclair/typebox").TString;
+            chains: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                id: import("@sinclair/typebox").TNumber;
+                name: import("@sinclair/typebox").TString;
+            }>>;
+        }>>;
+    };
+    "/v1/tokens": {
+        query: import("@sinclair/typebox").TObject<{
+            protocolSlug: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            primaryAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            chainId: import("@sinclair/typebox").TNumber;
+            type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<{
+                defi: "defi";
+                base: "base";
+            }>>;
+            page: import("@sinclair/typebox").TNumber;
+            inludeMetadata: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        response: import("@sinclair/typebox").TObject<{
+            data: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                chainId: import("@sinclair/typebox").TNumber;
+                address: import("@sinclair/typebox").TString;
+                type: import("@sinclair/typebox").TEnum<{
+                    defi: "defi";
+                    base: "base";
+                }>;
+                primaryAddress: import("@sinclair/typebox").TString;
+                underlyingTokens: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    address: import("@sinclair/typebox").TString;
+                    chainId: import("@sinclair/typebox").TNumber;
+                    type: import("@sinclair/typebox").TEnum<{
+                        defi: "defi";
+                        base: "base";
+                    }>;
+                }>>;
+                apy: import("@sinclair/typebox").TNumber;
+            }>>;
+            meta: import("@sinclair/typebox").TObject<{
+                total: import("@sinclair/typebox").TNumber;
+                lastPage: import("@sinclair/typebox").TNumber;
+                currentPage: import("@sinclair/typebox").TNumber;
+                perPage: import("@sinclair/typebox").TNumber;
+                prev: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>;
+                next: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>;
+            }>;
+        }>;
+    };
+    "/v1/shortcuts/quote": {
+        query: import("@sinclair/typebox").TObject<{
+            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            fromAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            routingStrategy: import("@sinclair/typebox").TEnum<{
+                ensowallet: "ensowallet";
+                delegate: "delegate";
+                router: "router";
+            }>;
+            feeReceiver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            amountIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            fee: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            disableRFQs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            ignoreAggregators: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            ignoreStandards: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        }>;
+        response: import("@sinclair/typebox").TObject<{
+            gas: import("@sinclair/typebox").TString;
+            amountOut: import("@sinclair/typebox").TObject<{}>;
+            priceImpact: import("@sinclair/typebox").TNumber;
+            feeAmount: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        }>;
+    };
+    "/v1/shortcuts/route": {
+        query: import("@sinclair/typebox").TObject<{
+            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            fromAddress: import("@sinclair/typebox").TString;
+            routingStrategy: import("@sinclair/typebox").TEnum<{
+                ensowallet: "ensowallet";
+                delegate: "delegate";
+                router: "router";
+            }>;
+            receiver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            spender: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            amountIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            amountOut: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            minAmountOut: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            slippage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            fee: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            feeReceiver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            disableRFQs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            ignoreAggregators: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            ignoreStandards: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        }>;
+        response: import("@sinclair/typebox").TObject<{
+            gas: import("@sinclair/typebox").TString;
+            amountOut: import("@sinclair/typebox").TString;
+            priceImpact: import("@sinclair/typebox").TNumber;
+            feeAmount: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            createAt: import("@sinclair/typebox").TNumber;
+            route: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                action: import("@sinclair/typebox").TLiteral<"swap">;
+                protocol: import("@sinclair/typebox").TString;
+                tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+                tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>, import("@sinclair/typebox").TObject<{
+                action: import("@sinclair/typebox").TLiteral<"deposit">;
+                primary: import("@sinclair/typebox").TString;
+                tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+                tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>]>>;
+            tx: import("@sinclair/typebox").TObject<{
+                data: import("@sinclair/typebox").TString;
+                to: import("@sinclair/typebox").TString;
+                from: import("@sinclair/typebox").TString;
+                value: import("@sinclair/typebox").TString;
+            }>;
+        }>;
+    };
+};
+export type EnsoRoute = keyof typeof apiTypes;
+export type EnsoApi<T extends EnsoRoute> = (typeof apiTypes)[T];

package/dist/src/modules/v4/enso/enso.service.d.ts

@@ -0,0 +1,69 @@
+import type { GetInteractionProtocolsQuery, InteractionAction, InteractionTarget, Router } from "../../../modules/v4/interaction/interaction.model";
+import type { ProtocolId } from "../../../modules/v4/protocol/protocol.model";
+import { type EnsoApi, type EnsoSlug } from "./enso.model";
+export declare abstract class EnsoService {
+    #private;
+    static getSlug(protocolId: ProtocolId | string): EnsoSlug | undefined;
+    static getProtocolId(slug: EnsoSlug | string): ProtocolId | undefined;
+    static getCompatibleProtocols(query: GetInteractionProtocolsQuery): Promise<({
+        name: string;
+        description: string;
+        id: string;
+        url: string;
+        icon: string;
+        tags: string[];
+    } & {
+        dailyRewards?: number | undefined;
+        numberOfLiveCampaigns?: number | undefined;
+        opportunityLiveTags?: string[] | undefined;
+    })[]>;
+    static getTokens(chainId: number, slug: EnsoSlug, identifier?: string): Promise<{
+        address: string;
+        chainId: number;
+        type: "base" | "defi";
+        primaryAddress: string;
+        underlyingTokens: {
+            address: string;
+            chainId: number;
+            type: "base" | "defi";
+        }[];
+        apy: number;
+    }[]>;
+    static getQuote(query: EnsoApi<"/v1/shortcuts/quote">["query"]["static"]): Promise<{
+        feeAmount: string[];
+        amountOut: {};
+        gas: string;
+        priceImpact: number;
+    }>;
+    static getTransaction(query: EnsoApi<"/v1/shortcuts/route">["query"]["static"]): Promise<{
+        feeAmount: string[];
+        amountOut: string;
+        gas: string;
+        route: ({
+            tokenIn: string[];
+            tokenOut: string[];
+            action: "swap";
+            protocol: string;
+        } | {
+            tokenIn: string[];
+            tokenOut: string[];
+            action: "deposit";
+            primary: string;
+        })[];
+        tx: {
+            data: string;
+            from: string;
+            to: string;
+            value: string;
+        };
+        priceImpact: number;
+        createAt: number;
+    }>;
+    static getActions(chainId: number, route: EnsoApi<"/v1/shortcuts/route">["response"]["static"]["route"], amountOut: bigint): Promise<InteractionAction[]>;
+    static getTargetsFromTokens(tokens: Awaited<ReturnType<typeof EnsoService.getTokens>>): Promise<InteractionTarget[]>;
+    /**
+     * Defines abstract router functions
+     * @returns Router
+     */
+    static getRouter(): Router;
+}

package/dist/src/modules/v4/explorer/explorer.controller.d.ts

@@ -0,0 +1,58 @@
+import Elysia from "elysia";
+export declare const ExplorerController: Elysia<"/explorers", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    explorers: {
+        post: {
+            body: {
+                chainId: number;
+                type: "ETHERSCAN" | "BLOCKSCOUT";
+                url: string;
+            };
+            params: {};
+            query: unknown;
+            headers: {
+                authorization: string;
+            };
+            response: {
+                200: {
+                    id: string;
+                    chainId: number;
+                    type: import("@package/databases").ExplorerType;
+                    url: string;
+                };
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}>;

package/dist/src/modules/v4/explorer/explorer.model.d.ts

@@ -0,0 +1,16 @@
+import type { Resource } from "../prisma";
+/**
+ * Explorer
+ * @description A chain explorer
+ * @see {@link Resource}
+ */
+export type Explorer = Resource<"Explorer", "id">;
+export declare const CreateExplorerDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    type: import("@sinclair/typebox").TEnum<{
+        readonly ETHERSCAN: "ETHERSCAN";
+        readonly BLOCKSCOUT: "BLOCKSCOUT";
+    }>;
+    url: import("@sinclair/typebox").TString;
+}>;
+export type CreateExplorerDto = typeof CreateExplorerDto.static;

package/dist/src/modules/v4/explorer/explorer.repository.d.ts

@@ -0,0 +1,21 @@
+import type { ExplorerType } from "@package/databases/api";
+export declare abstract class ExplorerRepository {
+    static getByChainId(chainId: number): Promise<{
+        id: string;
+        chainId: number;
+        type: import("@package/databases").ExplorerType;
+        url: string;
+    }>;
+    /**
+     * Creates an explorer
+     * @param chainId to attach explorer to
+     * @param type that defines the subsequents links for transactions, addresses...
+     * @param url base url without / suffix
+     */
+    static create(chainId: number, type: ExplorerType, url: string): Promise<{
+        id: string;
+        chainId: number;
+        type: import("@package/databases").ExplorerType;
+        url: string;
+    }>;
+}

package/dist/src/modules/v4/explorer/explorer.service.d.ts

@@ -0,0 +1,28 @@
+import type { ExplorerType } from "@package/databases/api";
+import type { CreateExplorerDto, Explorer } from "./explorer.model";
+export declare abstract class ExplorerService {
+    static hashId(type: ExplorerType, chainId: number): string;
+    static getByChainId(chainId: number): Promise<{
+        id: string;
+        chainId: number;
+        type: import("@package/databases").ExplorerType;
+        url: string;
+    }>;
+    static format(explorer: Explorer["raw"]): {
+        chainId: number;
+        type: import("@package/databases").ExplorerType;
+        url: string;
+    };
+    /**
+     * Creates an explorer
+     * @param chainId to attach explorer to
+     * @param type that defines the subsequents links for transactions, addresses...
+     * @param url base url without / suffix
+     */
+    static create(data: CreateExplorerDto): Promise<{
+        id: string;
+        chainId: number;
+        type: import("@package/databases").ExplorerType;
+        url: string;
+    }>;
+}

package/dist/src/modules/v4/icon/icon.model.d.ts

@@ -0,0 +1,4 @@
+export type FileMetadata = {
+    name?: string;
+    extension?: string;
+};

package/dist/src/modules/v4/icon/icon.service.d.ts

@@ -0,0 +1,5 @@
+import type { BucketService } from "../bucket/bucket.service";
+import type { FileMetadata } from "./icon.model";
+export declare abstract class IconService {
+    static pullPush(url: string, bucket: BucketService, metadata?: FileMetadata): Promise<string>;
+}

package/dist/src/modules/v4/interaction/interaction.controller.d.ts

@@ -0,0 +1,128 @@
+import Elysia from "elysia";
+export declare const InteractionController: Elysia<"/interaction", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    interaction: {
+        targets: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    protocolId?: string | undefined;
+                    chainId: number;
+                    identifier: string;
+                };
+                headers: unknown;
+                response: {
+                    200: import("./interaction.model").InteractionTarget[];
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    interaction: {
+        protocols: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    chainId?: number | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: ({
+                        name: string;
+                        description: string;
+                        id: string;
+                        url: string;
+                        icon: string;
+                        tags: string[];
+                    } & {
+                        dailyRewards?: number | undefined;
+                        numberOfLiveCampaigns?: number | undefined;
+                        opportunityLiveTags?: string[] | undefined;
+                    })[];
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    interaction: {
+        transaction: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    slippage?: number | undefined;
+                    protocolId: string;
+                    chainId: number;
+                    fromAmount: string;
+                    userAddress: string;
+                    identifier: string;
+                    fromTokenAddress: string;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        amountIn: bigint;
+                        allowance: bigint;
+                        approved: boolean;
+                        transaction: import("./interaction.model").UserTransaction;
+                        approval: import("./interaction.model").UserTransaction;
+                        actions?: import("./interaction.model").InteractionAction[] | undefined;
+                        depositValue?: number | undefined;
+                    } | undefined;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}>;

package/dist/src/modules/v4/interaction/interaction.model.d.ts

@@ -0,0 +1,110 @@
+import type { Token } from "../../../modules/v4/token/token.model";
+import { type ProtocolId } from "../protocol/protocol.model";
+/**
+ * Interaction Route
+ */
+export interface Router {
+    name: string;
+    getTarget: (chainId: number, protocolId: ProtocolId, identifier: string) => Promise<InteractionTarget | undefined>;
+    getTransaction: (chainId: number, protocolId: ProtocolId, identifier: string, userAddress: string, fromTokenAddress: string, fromTokenAmount: bigint, options: {
+        slippage?: number;
+    }) => Promise<Pick<InteractionQuote, "actions" | "transaction" | "depositValue">>;
+}
+export declare const participateInputTypes: readonly ["tokenAmount", "token"];
+export type InteractionInputType = (typeof participateInputTypes)[number];
+export type InteractionInput<T extends InteractionInputType = InteractionInputType> = {
+    tokenAmount: {
+        chain: number[];
+        address: string[];
+        amount: number[];
+    };
+    token: {
+        address: string;
+    };
+}[T];
+export declare const participateTypes: readonly ["link", "deposit", "withdraw"];
+export type InteractionType = (typeof participateTypes)[number];
+export type InteractionSchema<T extends InteractionType> = {
+    link: {
+        link: string;
+    };
+    deposit: {
+        inputs: InteractionInput[];
+    };
+    withdraw: {
+        d: string;
+    };
+}[T];
+export type InteractionTarget = {
+    provider: "enso" | "zap";
+    identifier: string;
+    chainId: number;
+};
+export type InteractionSchemas = {
+    [T in InteractionType]?: InteractionSchema<T>;
+};
+export type UserTransaction = {
+    data: string;
+    to: string;
+    from?: string;
+    value?: string;
+};
+export type InteractionQuote = {
+    amountIn: bigint;
+    allowance: bigint;
+    approved: boolean;
+    transaction: UserTransaction;
+    approval: UserTransaction;
+    actions?: InteractionAction[];
+    depositValue?: number;
+};
+export type InteractionActions = {
+    /**
+     * Fee taken by the router and/or Merkl
+     */
+    fee: {
+        tokens: (Token["model"] & {
+            amount?: bigint;
+        })[];
+    };
+    /**
+     * Amount deposited
+     */
+    deposit: {
+        tokens: (Token["model"] & {
+            amount?: bigint;
+        })[];
+        tokensOut?: (Token["model"] & {
+            amount?: bigint;
+        })[];
+    };
+    swap: {
+        from: Token["model"] & {
+            amount?: bigint;
+        };
+        to: Token["model"] & {
+            amount?: bigint;
+        };
+    };
+};
+export type InteractionAction<Action extends keyof InteractionActions = keyof InteractionActions> = {
+    action: Action;
+} & InteractionActions[Action];
+export declare const GetInteractionTargetsQueryDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    protocolId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    identifier: import("@sinclair/typebox").TString;
+}>;
+export declare const GetInteractionQuoteQueryDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    protocolId: import("@sinclair/typebox").TString;
+    identifier: import("@sinclair/typebox").TString;
+    userAddress: import("@sinclair/typebox").TString;
+    fromTokenAddress: import("@sinclair/typebox").TString;
+    fromAmount: import("@sinclair/typebox").TString;
+    slippage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const GetInteractionProtocolsQueryDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export type GetInteractionProtocolsQuery = typeof GetInteractionProtocolsQueryDto.static;

package/dist/src/modules/v4/interaction/interaction.service.d.ts

@@ -0,0 +1,38 @@
+import type { ProtocolId } from "../../../modules/v4/protocol/protocol.model";
+import type { InteractionQuote } from "./interaction.model";
+export declare abstract class InteractionService {
+    static routers: import("./interaction.model").Router[];
+    /**
+     * Returns a target entry for each router, indicating the possiblity to deposit
+     * @param chainId compute
+     * @param protocolId i.e. "aave", "venus"
+     * @param identifier i.e. mainParameter, poolAddress
+     * @returns information about available routers
+     */
+    static getTargets(chainId: number, protocolId: ProtocolId, identifier: string): Promise<import("./interaction.model").InteractionTarget[]>;
+    /**
+     * Gets transaction to interact on opportunity via a router
+     * @param provider i.e. "enso" or "zap"
+     * @param chainId compute
+     * @param protocolId i.e. "aave", "venus"
+     * @param identifier i.e. mainParameter, poolAddress
+     * @param userAddress
+     * @param fromTokenAddress
+     * @param fromTokenAmount
+     * @param slippage
+     * @returns transaction and approval state
+     */
+    static getTransaction(provider: string, chainId: number, protocolId: ProtocolId, identifier: string, userAddress: string, fromTokenAddress: string, fromTokenAmount: bigint, slippage?: number): Promise<InteractionQuote>;
+    /**
+     * Gets approval information onchain
+     * @returns approved?, approval tx & allowance amount
+     */
+    static getApproval(chainId: number, owner: string, spender: string, tokenAddress: string, amount: bigint): Promise<{
+        approved: boolean;
+        allowance: bigint;
+        approval: {
+            to: string;
+            data: `0x${string}`;
+        };
+    }>;
+}