@merkl/api 0.10.199 → 0.10.200

package/dist/src/modules/v4/interaction/interaction.service.js

@@ -1,33 +1,111 @@
+import { decodeFunctionResult, encodeFunctionData, parseAbi } from "viem";
+import { ChainInteractionService } from "../chainInteraction";
 import { EnsoService } from "../enso/enso.service";
-import { TokenService } from "../token";
+import { KyberZapService } from "../kyberzap/kyberzap.service";
 export class InteractionService {
     static async getTarget(chainId, protocolId, identifier) {
+        const targets = [];
+        const slug = EnsoService.getSlug(protocolId);
+        if (slug) {
+            const tokens = await EnsoService.getTokens(chainId, slug, identifier);
+            const ensoTargets = await InteractionService.getTargetsFromEnsoTokens(tokens);
+            targets.push(ensoTargets?.[0]);
+        }
+        return targets;
+    }
+    static getTargetFromKyberZap(chainId, protocolId, identifier) {
+        const dexId = KyberZapService.getDexId(protocolId);
+        const chainLabel = KyberZapService.getChainLabel(chainId);
+        if (!dexId || !chainLabel)
+            return;
+        return {
+            provider: "zap",
+            chainId: chainId,
+            identifier: identifier,
+        };
+    }
+    static async getTargetFromEnso(chainId, protocolId, identifier) {
         const slug = EnsoService.getSlug(protocolId);
         if (!slug)
             return;
         const tokens = await EnsoService.getTokens(chainId, slug, identifier);
-        return await InteractionService.getTargetsFromEnsoTokens(tokens);
+        const ensoTargets = await InteractionService.getTargetsFromEnsoTokens(tokens);
+        return ensoTargets?.[0];
     }
     static async getTargetsFromEnsoTokens(tokens) {
         const targets = [];
         for (const { address, underlyingTokens, ...target } of tokens) {
             try {
-                const [utilityToken, ...assetTokens] = await TokenService.getManyOrCreate([{ chainId: target.chainId, address }].concat(underlyingTokens));
                 targets.push({
+                    provider: "enso",
+                    chainId: target.chainId,
                     identifier: address,
-                    name: `${utilityToken?.symbol}: ${assetTokens.map(t => t?.symbol).join("/")}`,
-                    tokens: assetTokens.filter(t => t !== undefined),
                 });
             }
             catch { }
         }
         return targets;
     }
-    static async getTargets(chainId, protocolId) {
-        const slug = EnsoService.getSlug(protocolId);
-        if (!slug)
-            return;
-        const tokens = await EnsoService.getTokens(chainId, slug);
-        return await InteractionService.getTargetsFromEnsoTokens(tokens);
+    static async getTargets(chainId, protocolId, identifier) {
+        const targets = [];
+        const ensoTarget = await InteractionService.getTargetFromEnso(chainId, protocolId, identifier);
+        const zapTarget = InteractionService.getTargetFromKyberZap(chainId, protocolId, identifier);
+        if (zapTarget)
+            targets.push(zapTarget);
+        if (ensoTarget)
+            targets.push(ensoTarget);
+        return targets;
+    }
+    /**
+     * Gets approval information onchain
+     * @returns approved?, approval tx & allowance amount
+     */
+    static async getApproval(chainId, owner, spender, tokenAddress, amount) {
+        //TODO: add utils to make using viem type-safety more concise
+        const abi = parseAbi([
+            "function approve(address, uint256) returns (bool)",
+            "function allowance(address owner, address spender) returns (uint256)",
+        ]);
+        const decode = (r) => decodeFunctionResult({
+            abi,
+            functionName: "allowance",
+            data: r?.returnData,
+        });
+        const allowance = await ChainInteractionService(chainId).fetchAndDecode({
+            target: tokenAddress,
+            allowFailure: true,
+            callData: encodeFunctionData({
+                abi,
+                functionName: "allowance",
+                args: [owner, spender],
+            }),
+        }, decode);
+        const approved = allowance >= amount;
+        return {
+            approved,
+            allowance,
+            approval: {
+                to: tokenAddress,
+                data: encodeFunctionData({
+                    abi,
+                    functionName: "approve",
+                    args: [spender, amount],
+                }),
+            },
+        };
+    }
+    static async getTransaction(provider, chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount) {
+        if (provider === "zap")
+            return await KyberZapService.getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount);
+        const { tx, ...quote } = await EnsoService.getTransaction({
+            fromAddress: userAddress,
+            tokenIn: [fromTokenAddress],
+            tokenOut: [identifier],
+            amountIn: [fromTokenAmount.toString()],
+            routingStrategy: "router",
+            chainId,
+        });
+        const { allowance, approval, approved } = await InteractionService.getApproval(chainId, userAddress, tx.to, fromTokenAddress, fromTokenAmount);
+        return { ...quote, allowance, approval, approved, transaction: tx };
     }
 }

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

@@ -0,0 +1,72 @@
+export declare const dexIdToProtocolId: {
+    readonly DEX_UNISWAPV3: "uniswap-v3";
+    readonly DEX_UNISWAPV2: "uniswap-v2";
+    readonly DEX_PANCAKESWAPV3: "pancakeswap-v3";
+    readonly DEX_SUSHISWAPV3: "sushiswap-v3";
+    readonly DEX_CURVE: "curve";
+    readonly DEX_QUICKSWAPV3UNI: "quickswap-uni";
+    readonly DEX_QUICKSWAPV3ALGEBRA: "quickswap-algebra";
+    readonly DEX_THRUSTERV3: "thruster";
+    readonly DEX_CAMELOTV3: "camelot";
+    readonly DEX_BEEFY: "beefy";
+    readonly DEX_KOICL: "koi";
+    readonly DEX_AERODROMECL: "aerodrome";
+    readonly DEX_BALANCER: "balancer";
+};
+export declare const chainToKyberLabel: {
+    [chainId: number]: string;
+};
+export type KyberZapDexId = keyof typeof dexIdToProtocolId;
+export declare const apiTypes: {
+    readonly "/api/v1/in/route": {
+        readonly 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>;
+        }>;
+        readonly 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;
+        }>;
+    };
+    readonly "/api/v1/in/route/build": {
+        readonly query: import("@sinclair/typebox").TObject<{}>;
+        readonly 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;
+        }>;
+        readonly 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 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.model.js

@@ -0,0 +1,79 @@
+import { ChainId } from "@sdk";
+import { t } from "elysia";
+export const dexIdToProtocolId = {
+    DEX_UNISWAPV3: "uniswap-v3",
+    DEX_UNISWAPV2: "uniswap-v2",
+    DEX_PANCAKESWAPV3: "pancakeswap-v3",
+    DEX_SUSHISWAPV3: "sushiswap-v3",
+    DEX_CURVE: "curve",
+    DEX_QUICKSWAPV3UNI: "quickswap-uni",
+    DEX_QUICKSWAPV3ALGEBRA: "quickswap-algebra",
+    DEX_THRUSTERV3: "thruster",
+    DEX_CAMELOTV3: "camelot",
+    DEX_BEEFY: "beefy",
+    DEX_KOICL: "koi",
+    DEX_AERODROMECL: "aerodrome",
+    DEX_BALANCER: "balancer",
+};
+export const chainToKyberLabel = {
+    [ChainId.ARBITRUM]: "arbitrum",
+    [ChainId.AVALANCHE]: "avalance",
+    [ChainId.BASE]: "base",
+    [ChainId.BLAST]: "blast",
+    [ChainId.BSC]: "bsc",
+    [ChainId.MAINNET]: "ethereum",
+    [ChainId.LINEA]: "linea",
+    [ChainId.OPTIMISM]: "optimism",
+    [ChainId.POLYGON]: "polygon",
+    [ChainId.POLYGONZKEVM]: "polygon-zkevm",
+    [ChainId.SCROLL]: "scroll",
+    [ChainId.ZKSYNC]: "zksync",
+};
+export const apiTypes = {
+    "/api/v1/in/route": {
+        query: t.Object({
+            dex: t.String({ example: "DEX_UNISWAPV3" }),
+            "pool.id": t.String({ example: "0x2f5e87c9312fa29aed5c179e456625d79015299c" }),
+            "position.tickLower": t.String(),
+            "position.tickUpper": t.String(),
+            tokenIn: t.String(),
+            amountIn: t.String(),
+            feeAddress: t.Optional(t.String()),
+            feePcm: t.Optional(t.Number()),
+        }),
+        response: t.Object({
+            message: t.String({ example: "OK" }),
+            data: t.Object({
+                poolDetails: t.Object({}),
+                positionDetails: t.Object({}),
+                zapDetails: t.Object({
+                    actions: t.Array(t.Object({})),
+                    finalAmountUsd: t.String(),
+                    priceImpact: t.Number(),
+                }),
+                route: t.String(),
+                routerAddress: t.String(),
+            }),
+            requestId: t.String(),
+        }),
+    },
+    "/api/v1/in/route/build": {
+        query: t.Object({}),
+        body: t.Object({
+            sender: t.String(),
+            recipient: t.String(),
+            route: t.String(),
+            deadline: t.Number(),
+            source: t.String(),
+        }),
+        response: t.Object({
+            message: t.String({ example: "OK" }),
+            data: t.Object({
+                routerAddress: t.String(),
+                callData: t.String(),
+                value: t.String(),
+            }),
+            requestId: t.String(),
+        }),
+    },
+};

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

@@ -0,0 +1,15 @@
+import type { InteractionQuote } from "../interaction/interaction.model";
+import type { ProtocolId } from "../protocol";
+import { type KyberZapDexId } 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[];
+    static getTransaction(chainId: number, protocol: ProtocolId, identifier: string, userAddress: string, fromTokenAddress: string, fromTokenAmount: bigint): Promise<InteractionQuote>;
+}

package/dist/src/modules/v4/kyberzap/kyberzap.service.js

@@ -0,0 +1,84 @@
+import { InteractionService } from "../interaction/interaction.service";
+import { chainToKyberLabel, dexIdToProtocolId, } from "./kyberzap.model";
+const KYBERZAP = `https://zap-api.kyberswap.com/`;
+export class KyberZapService {
+    static async #fetch(route, params) {
+        const res = await fetch(`${KYBERZAP}${chainToKyberLabel[params?.chainId] ?? ""}${route}?${params?.query ? new URLSearchParams(params?.query) : ""}`, {
+            headers: new Headers({
+                Authorization: `Bearer ${process.env.KYBERSWAP_ZAP_API_KEY}`,
+                "Content-Type": "application/json",
+            }),
+        });
+        if (res.status !== 200)
+            throw new Error((await res.json())?.message);
+        return (await res.json());
+    }
+    static async #post(route, params) {
+        const res = await fetch(`${KYBERZAP}${chainToKyberLabel[params?.chainId] ?? ""}${route}`, {
+            method: "POST",
+            body: JSON.stringify(params?.body),
+            headers: new Headers({
+                Authorization: `Bearer ${"8dbbda50-6ed5-4bda-bf54-ea2796602057"}`,
+                "Content-Type": "application/json",
+            }),
+        });
+        if (res.status !== 200)
+            throw new Error((await res.json())?.message);
+        return (await res.json());
+    }
+    static getDexId(protocolId) {
+        const dexId = Object.entries(dexIdToProtocolId).find(([_, id]) => id === protocolId)?.[0];
+        return dexId;
+    }
+    static getChainLabel(chainId) {
+        return chainToKyberLabel?.[chainId];
+    }
+    static getProtocolId(dexId) {
+        return dexIdToProtocolId[dexId];
+    }
+    /**
+     * @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() {
+        return [-886800, 886800];
+    }
+    static async getTransaction(chainId, protocol, identifier, userAddress, fromTokenAddress, fromTokenAmount) {
+        const [lower, upper] = KyberZapService.getFullRangeTicks();
+        const { data: route } = await KyberZapService.#fetch("/api/v1/in/route", {
+            query: {
+                tokenIn: fromTokenAddress,
+                amountIn: fromTokenAmount?.toString(),
+                "pool.id": identifier,
+                "position.tickLower": lower?.toString(),
+                "position.tickUpper": upper?.toString(),
+                dex: KyberZapService.getDexId(protocol),
+            },
+            chainId,
+        });
+        const { data: transaction } = await KyberZapService.#post("/api/v1/in/route/build", {
+            query: {},
+            body: {
+                //TODO: add a more relevant value here
+                deadline: 1800000000,
+                recipient: userAddress,
+                sender: userAddress,
+                route: route.route,
+                source: "merkl",
+            },
+            chainId,
+        });
+        const { allowance, approval, approved } = await InteractionService.getApproval(chainId, userAddress, route.routerAddress, fromTokenAddress, fromTokenAmount);
+        return {
+            allowance,
+            approval,
+            approved,
+            amountIn: fromTokenAmount,
+            transaction: {
+                to: transaction.routerAddress,
+                data: transaction.callData,
+                value: 0n,
+            },
+        };
+    }
+}

package/dist/src/modules/v4/liquidity/liquidity.controller.js

@@ -3,7 +3,7 @@ import { Elysia } from "elysia";
 import { PositionsInputDto } from "./liquidity.model";
 import { LiquidityService } from "./liquidity.service";
 // ─── Positions Controller ──────────────────────────────────────────────
-export const LiquidityController = new Elysia({ prefix: "/liquidity", detail: { tags: ["Positions"] } })
+export const LiquidityController = new Elysia({ prefix: "/liquidity", detail: { tags: ["Positions"], hide: true } })
     // ─── Get User Positions on a Chain ───────────────────────────────────
     .get("/", async ({ query }) => {
     return await LiquidityService.fetchPositions(query);

package/dist/src/modules/v4/merklRoot/merklRoot.controller.js

@@ -4,7 +4,7 @@ import Elysia from "elysia";
 import { CreateRootDto, RootByTimestampsDto } from "./merklRoot.model";
 import { MerklRootService } from "./merklRoot.service";
 // ─── Merkl Roots Controller ─────────────────────────────────────────────
-export const MerklRootController = new Elysia({ prefix: "/roots", detail: { tags: ["Roots"] } })
+export const MerklRootController = new Elysia({ prefix: "/roots", detail: { tags: ["Roots"], hide: true } })
     // ─── Get Merkl Root By Timestamp ─────────────────────────────────────
     .get("/", async ({ query }) => await MerklRootService.rootForTimestamp(query), {
     query: RootByTimestampsDto,