@merkl/api 1.0.78 → 1.0.80

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

@@ -0,0 +1,16 @@
+import type { ResourceAPI } from "../prisma";
+/**
+ * Explorer
+ * @description A chain explorer
+ * @see {@link ResourceAPI}
+ */
+export type Explorer = ResourceAPI<"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}`;
+        };
+    }>;
+}

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

@@ -0,0 +1,114 @@
+export declare const dexIdToProtocolId: {
+    DEX_UNISWAPV3: "uniswap";
+    DEX_UNISWAPV2: "uniswap";
+    DEX_PANCAKESWAPV3: "pancake-swap";
+    DEX_SUSHISWAPV3: "sushi-swap";
+    DEX_CURVE: "curve";
+    DEX_SYNCSWAP_V3: "syncswap";
+    DEX_ZKSWAP_V3: "zk-swap";
+    DEX_QUICKSWAPV3UNI: "quickswap";
+    DEX_QUICKSWAPV3ALGEBRA: "quickswap";
+    DEX_THRUSTERV3: "thruster";
+    DEX_CAMELOTV3: "camelot";
+    DEX_BEEFY: "beefy";
+    DEX_KOICL: "koi";
+    DEX_AERODROMECL: "aerodrome";
+    DEX_BALANCER: "balancer";
+};
+export declare const chainToKyberLabel: {
+    [chainId: number]: string;
+};
+export type KyberZapDexId = keyof typeof dexIdToProtocolId;
+export declare const apiTypes: {
+    "/api/v1/in/route": {
+        query: import("@sinclair/typebox").TObject<{
+            dex: import("@sinclair/typebox").TString;
+            "pool.id": import("@sinclair/typebox").TString;
+            "position.tickLower": import("@sinclair/typebox").TString;
+            "position.tickUpper": import("@sinclair/typebox").TString;
+            tokenIn: import("@sinclair/typebox").TString;
+            amountIn: import("@sinclair/typebox").TString;
+            feeAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            feePcm: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            slippage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        }>;
+        response: import("@sinclair/typebox").TObject<{
+            message: import("@sinclair/typebox").TString;
+            data: import("@sinclair/typebox").TObject<{
+                poolDetails: import("@sinclair/typebox").TObject<{}>;
+                positionDetails: import("@sinclair/typebox").TObject<{}>;
+                zapDetails: import("@sinclair/typebox").TObject<{
+                    actions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{}>>;
+                    finalAmountUsd: import("@sinclair/typebox").TString;
+                    priceImpact: import("@sinclair/typebox").TNumber;
+                }>;
+                route: import("@sinclair/typebox").TString;
+                routerAddress: import("@sinclair/typebox").TString;
+            }>;
+            requestId: import("@sinclair/typebox").TString;
+        }>;
+    };
+    "/api/v1/in/route/build": {
+        query: import("@sinclair/typebox").TObject<{}>;
+        body: import("@sinclair/typebox").TObject<{
+            sender: import("@sinclair/typebox").TString;
+            recipient: import("@sinclair/typebox").TString;
+            route: import("@sinclair/typebox").TString;
+            deadline: import("@sinclair/typebox").TNumber;
+            source: import("@sinclair/typebox").TString;
+        }>;
+        response: import("@sinclair/typebox").TObject<{
+            message: import("@sinclair/typebox").TString;
+            data: import("@sinclair/typebox").TObject<{
+                routerAddress: import("@sinclair/typebox").TString;
+                callData: import("@sinclair/typebox").TString;
+                value: import("@sinclair/typebox").TString;
+            }>;
+            requestId: import("@sinclair/typebox").TString;
+        }>;
+    };
+};
+export type ZapToken = {
+    address: string;
+    amount: string;
+    amountUsd: string;
+};
+export type ZapActions = {
+    ACTION_TYPE_PROTOCOL_FEE: {
+        protocolFee: {
+            pcm: number;
+            tokens: ZapToken[];
+        };
+    };
+    ACTION_TYPE_AGGREGATOR_SWAP: {
+        aggregatorSwap: {
+            swaps: {
+                tokenIn: ZapToken;
+                tokenOut: ZapToken;
+            }[];
+        };
+    };
+    ACTION_TYPE_POOL_SWAP: {
+        poolSwap: {
+            swaps: {
+                tokenIn: ZapToken;
+                tokenOut: ZapToken;
+            }[];
+        };
+    };
+    ACTION_TYPE_ADD_LIQUIDITY: {
+        addLiquidity: {
+            tokens: ZapToken[];
+            token0: ZapToken;
+            token1: ZapToken;
+        };
+    };
+};
+export type ZapAction<Action extends keyof ZapActions = keyof ZapActions> = {
+    type: Action;
+} & ZapActions[Action];
+export type KyberZapRoute = keyof typeof apiTypes;
+export type KyberZapPostRoute = {
+    [R in KyberZapRoute]: "body" extends keyof KyberZapApi<R> ? R : never;
+}[KyberZapRoute];
+export type KyberZapApi<T extends KyberZapRoute> = (typeof apiTypes)[T];

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

@@ -0,0 +1,34 @@
+import type { ProtocolId } from "../../../modules/v4/protocol/protocol.model";
+import type { InteractionAction, Router } from "../interaction/interaction.model";
+import { type KyberZapDexId, type ZapAction } from "./kyberzap.model";
+export declare abstract class KyberZapService {
+    #private;
+    static getDexId(protocolId: ProtocolId | string): KyberZapDexId | undefined;
+    static getChainLabel(chainId: number): string | undefined;
+    static getProtocolId(dexId: KyberZapDexId | string): ProtocolId | undefined;
+    /**
+     * @notice We don't handle tick setting in the UI for now, until we do this give the full-range ticks
+     * @param param0
+     */
+    static getFullRangeTicks(): number[];
+    /**
+     * Converts the breakdown of actions
+     * @param zapActions
+     * @returns provider-agnostic interaction actions
+     */
+    static getActions(chainId: number, zapActions: ZapAction[]): Promise<InteractionAction[]>;
+    static getTransaction(chainId: number, protocol: ProtocolId, identifier: string, userAddress: string, fromTokenAddress: string, fromTokenAmount: bigint, slippage?: number): Promise<{
+        actions: InteractionAction[];
+        depositValue: number;
+        transaction: {
+            to: string;
+            data: string;
+            value: string;
+        };
+    }>;
+    /**
+     * Defines abstract router functions
+     * @returns Router
+     */
+    static getRouter(): Router;
+}

package/dist/src/modules/v4/liquidity/implementations/AjnaPositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@angleprotocol/sdk/ts";
+import type { Opportunity } from "../../../../modules/v4/opportunity/opportunity.model";
+import type { PositionFetcher } from "../liquidity.model";
+export declare class AjnaPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<import("../liquidity.model").PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/BadgerPositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@angleprotocol/sdk/ts";
+import type { Opportunity } from "../../../../modules/v4/opportunity/opportunity.model";
+import type { PositionFetcher, PositionT } from "../liquidity.model";
+export declare class BadgerPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/ClammPositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@angleprotocol/sdk/ts";
+import type { Opportunity } from "../../../../modules/v4/opportunity/opportunity.model";
+import type { PositionFetcher, PositionT } from "../liquidity.model";
+export declare class ClammPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/DolomitePositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@angleprotocol/sdk/ts";
+import type { Opportunity } from "../../../../modules/v4/opportunity/opportunity.model";
+import type { PositionFetcher } from "../liquidity.model";
+export declare class DolomitePositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<import("../liquidity.model").PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/ERC20PositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@angleprotocol/sdk/ts";
+import type { PositionFetcher, PositionT } from "../../../../modules/v4/liquidity/liquidity.model";
+import type { Opportunity } from "../../../../modules/v4/opportunity/opportunity.model";
+export declare class ERC20PositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/EulerPositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@angleprotocol/sdk/ts";
+import type { Opportunity } from "../../../../modules/v4/opportunity/opportunity.model";
+import type { PositionFetcher, PositionT } from "../liquidity.model";
+export declare class EulerPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<PositionT[]>;
+}

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

@@ -0,0 +1,50 @@
+import { Elysia } from "elysia";
+export declare const LiquidityController: Elysia<"/liquidity", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    liquidity: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                address: string;
+                chainId: number;
+            };
+            headers: unknown;
+            response: {
+                200: import("./liquidity.model").PositionT[];
+                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/liquidity/liquidity.model.d.ts

@@ -0,0 +1,25 @@
+import type { MerklChainId } from "@angleprotocol/sdk/ts";
+import type { Opportunity } from "../../../modules/v4/opportunity/opportunity.model";
+export type PositionT = {
+    flags: {
+        range?: string;
+        id?: string;
+        link?: string;
+    };
+    opportunity: Opportunity["model"];
+    tokens: {
+        token: Opportunity["model"]["tokens"][0];
+        breakdown: {
+            type: string;
+            value: number;
+        }[];
+    }[];
+};
+export interface PositionFetcher {
+    fetchPositions(chainId: MerklChainId, user: string, opportunity: Opportunity["model"][]): Promise<PositionT[]>;
+}
+export declare const PositionsInputDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    address: import("@sinclair/typebox").TString;
+}>;
+export type PositionsInputModel = typeof PositionsInputDto.static;

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

@@ -0,0 +1,14 @@
+import type { MerklChainId } from "@angleprotocol/sdk/ts";
+export declare class LiquidityRepository {
+    static findManyDolomitePositions(chainId: MerklChainId, user: string): Promise<{
+        balance: string;
+        token: {
+            id: string;
+            marketId: string;
+            symbol: string;
+            decimals: string;
+            borrowLiquidity: string;
+            supplyLiquidity: string;
+        };
+    }[]>;
+}

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

@@ -0,0 +1,5 @@
+import type { PositionT, PositionsInputModel } from "./liquidity.model";
+export declare class LiquidityService {
+    #private;
+    static fetchPositions(query: PositionsInputModel): Promise<PositionT[]>;
+}