@merkl/api 0.12.12 → 0.13.2

package/dist/src/backgroundJobs/index.js

@@ -29,10 +29,12 @@ new Elysia({
     .use(healthCheck) // /v3/health
     .use(sync) // GET /jobs/api/sync-with-engine
     .get("/eulerUpdate", async () => {
-    await Redis.safeSet("EulerV2Vaults", getEulerV2Vaults);
+    log.info("🔃 updating Euler vaults...");
+    await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());
 })
     .get("/uniswapv4Update", async () => {
-    await Redis.safeSet("UniswapV4Pools", getUniswapV4Pools);
+    log.info("🔃 updating UniswapV4 pools...");
+    await Redis.safeSet("UniswapV4Pools", await getUniswapV4Pools());
 })
     .group("/v4", app => {
     return app.use(DungeonKeeperController);

package/dist/src/backgroundJobs/jobs/priceUpdater.d.ts

@@ -1,4 +1,5 @@
 import type Elysia from "elysia";
+export declare const updatePrices: () => Promise<void>;
 export declare const priceUpdater: (app: Elysia) => Elysia<"", false, {
     decorator: {};
     store: {};

package/dist/src/backgroundJobs/jobs/priceUpdater.js

@@ -1,12 +1,17 @@
 import { TokenService } from "../../modules/v4";
 import { log } from "../../utils/logger";
 import { Pricer } from "../../utils/pricer";
+export const updatePrices = async () => {
+    const pricer = await Pricer.load();
+    const prices = await pricer.update();
+    log.info(`✅ ${Object.keys(prices).length} prices cache updated successfully`);
+    log.info("⏳ Updating API database...");
+    await TokenService.updatePrices(pricer);
+    log.info("✅ API database updated successfully!");
+};
 export const priceUpdater = (app) => {
     return app.get("/v3/updatePrices", async () => {
-        const pricer = await Pricer.load();
-        await pricer.update();
-        log.info("✅ price cache updated successfully");
-        await TokenService.updatePrices(pricer);
+        await updatePrices();
         return new Response(JSON.stringify({
             status: "success",
         }), {

package/dist/src/eden/index.d.ts

@@ -2328,6 +2328,8 @@ declare const eden: {
                         approved: boolean;
                         transaction: import("../modules/v4/interaction/interaction.model").UserTransaction;
                         approval: import("../modules/v4/interaction/interaction.model").UserTransaction;
+                        actions?: import("../modules/v4/interaction/interaction.model").InteractionAction[] | undefined;
+                        depositValue?: number | undefined;
                     } | undefined;
                 }>>;
             };
@@ -5329,6 +5331,8 @@ declare const eden: {
                         approved: boolean;
                         transaction: import("../modules/v4/interaction/interaction.model").UserTransaction;
                         approval: import("../modules/v4/interaction/interaction.model").UserTransaction;
+                        actions?: import("../modules/v4/interaction/interaction.model").InteractionAction[] | undefined;
+                        depositValue?: number | undefined;
                     } | undefined;
                 }>>;
             };
@@ -9548,6 +9552,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             approved: boolean;
                             transaction: import("../modules/v4/interaction/interaction.model").UserTransaction;
                             approval: import("../modules/v4/interaction/interaction.model").UserTransaction;
+                            actions?: import("../modules/v4/interaction/interaction.model").InteractionAction[] | undefined;
+                            depositValue?: number | undefined;
                         } | undefined;
                     };
                 };
@@ -13635,6 +13641,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         approved: boolean;
                         transaction: import("../modules/v4/interaction/interaction.model").UserTransaction;
                         approval: import("../modules/v4/interaction/interaction.model").UserTransaction;
+                        actions?: import("../modules/v4/interaction/interaction.model").InteractionAction[] | undefined;
+                        depositValue?: number | undefined;
                     } | undefined;
                 }>>;
             };
@@ -16636,6 +16644,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         approved: boolean;
                         transaction: import("../modules/v4/interaction/interaction.model").UserTransaction;
                         approval: import("../modules/v4/interaction/interaction.model").UserTransaction;
+                        actions?: import("../modules/v4/interaction/interaction.model").InteractionAction[] | undefined;
+                        depositValue?: number | undefined;
                     } | undefined;
                 }>>;
             };

package/dist/src/index.d.ts

@@ -2857,6 +2857,8 @@ declare const app: Elysia<"", false, {
                             approved: boolean;
                             transaction: import("./modules/v4/interaction/interaction.model").UserTransaction;
                             approval: import("./modules/v4/interaction/interaction.model").UserTransaction;
+                            actions?: import("./modules/v4/interaction/interaction.model").InteractionAction[] | undefined;
+                            depositValue?: number | undefined;
                         } | undefined;
                     };
                 };

package/dist/src/jobs/etl/prices.js

@@ -0,0 +1,3 @@
+import { updatePrices } from "../../backgroundJobs/jobs/priceUpdater";
+await updatePrices();
+process.exit(0);

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/EqualizerGaugeProcessor.js

@@ -38,9 +38,6 @@ export class EqualizerGaugeProcessor extends GenericProcessor {
             }
         }
         catch (e) { }
-        try {
-        }
-        catch (e) { }
         const priceTargetToken = tvl / totalSupply;
         //const displayName = `Stake into ${data[typeInfo.tokenAddress].pair.displayName} Equalizer Gauge`;
         return {

package/dist/src/libs/campaigns/utils/getUniswapV4Pools.js

@@ -20,7 +20,7 @@ export async function getUniswapV4Pools() {
         try {
             // 1_ Get latest euler vaults from chain
             const storedPoolsPerChain = storedPools.filter(pool => pool.chainId === chainId);
-            log.info(`found ${storedPoolsPerChain.length} already stored vaults on ${NETWORK_LABELS[chainId]}`);
+            log.info(`found ${storedPoolsPerChain.length} already stored pools on ${NETWORK_LABELS[chainId]}`);
             let fromBlock;
             if (storedPoolsPerChain.length > 0) {
                 fromBlock = Math.max(...storedPools.map(x => x.fetchAtBlock)) + 1;

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

@@ -142,6 +142,17 @@ export declare const apiTypes: {
             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;

package/dist/src/modules/v4/enso/enso.model.js

@@ -122,6 +122,20 @@ export const apiTypes = {
             priceImpact: t.Number(),
             feeAmount: t.Array(t.String()),
             createAt: t.Number(),
+            route: t.Array(t.Union([
+                t.Object({
+                    action: t.Literal("swap"),
+                    protocol: t.String(),
+                    tokenIn: t.Array(t.String()),
+                    tokenOut: t.Array(t.String()),
+                }),
+                t.Object({
+                    action: t.Literal("deposit"),
+                    primary: t.String(),
+                    tokenIn: t.Array(t.String()),
+                    tokenOut: t.Array(t.String()),
+                }),
+            ])),
             tx: t.Object({
                 data: t.String(),
                 to: t.String(),

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

@@ -1,4 +1,4 @@
-import type { GetParticipateProtocolsQuery } from "../interaction/interaction.model";
+import type { GetParticipateProtocolsQuery, InteractionAction, InteractionTarget, Router } from "../interaction/interaction.model";
 import { type ProtocolId } from "../protocol";
 import { type EnsoApi, type EnsoSlug } from "./enso.model";
 export declare abstract class EnsoService {
@@ -32,6 +32,17 @@ export declare abstract class EnsoService {
         priceImpact: number;
     }>;
     static getTransaction(query: EnsoApi<"/v1/shortcuts/route">["query"]["static"]): Promise<{
+        route: ({
+            protocol: string;
+            action: "swap";
+            tokenIn: string[];
+            tokenOut: string[];
+        } | {
+            action: "deposit";
+            primary: string;
+            tokenIn: string[];
+            tokenOut: string[];
+        })[];
         amountOut: string;
         gas: string;
         feeAmount: string[];
@@ -44,4 +55,11 @@ export declare abstract class EnsoService {
             to: string;
         };
     }>;
+    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/enso/enso.service.js

@@ -1,4 +1,5 @@
 import { ProtocolService } from "../protocol";
+import { TokenService } from "../token";
 import { slugToProtocolId } from "./enso.model";
 const ENSO = `https://api.enso.finance/api`;
 export class EnsoService {
@@ -43,4 +44,70 @@ export class EnsoService {
     static async getTransaction(query) {
         return await EnsoService.#fetch("/v1/shortcuts/route", { query });
     }
+    static async getActions(chainId, route, amountOut) {
+        return await Promise.all(route.map(async (r) => {
+            switch (r.action) {
+                case "deposit": {
+                    const tokensIn = await TokenService.getManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
+                    const [tokenOut] = await TokenService.getManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
+                    return {
+                        action: "deposit",
+                        tokens: tokensIn.filter(a => !!a),
+                        tokensOut: [{ ...tokenOut, amount: amountOut }],
+                    };
+                }
+                case "swap": {
+                    const [from] = await TokenService.getManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
+                    const [to] = await TokenService.getManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
+                    return { action: "swap", from: from, to: to };
+                }
+            }
+        }));
+    }
+    static async getTargetsFromTokens(tokens) {
+        const targets = [];
+        for (const { address, underlyingTokens, ...target } of tokens) {
+            try {
+                targets.push({
+                    provider: "enso",
+                    chainId: target.chainId,
+                    identifier: address,
+                });
+            }
+            catch { }
+        }
+        return targets;
+    }
+    /**
+     * Defines abstract router functions
+     * @returns Router
+     */
+    static getRouter() {
+        return {
+            name: "enso",
+            async getTarget(chainId, protocolId, identifier) {
+                const slug = EnsoService.getSlug(protocolId);
+                if (!slug)
+                    return;
+                const tokens = await EnsoService.getTokens(chainId, slug, identifier);
+                const targets = await EnsoService.getTargetsFromTokens(tokens);
+                return targets?.[0];
+            },
+            async getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, options) {
+                const { tx, ...quote } = await EnsoService.getTransaction({
+                    fromAddress: userAddress,
+                    tokenIn: [fromTokenAddress],
+                    tokenOut: [identifier],
+                    routingStrategy: "router",
+                    chainId,
+                    amountIn: [fromTokenAmount.toString()],
+                    slippage: options.slippage?.toString(),
+                });
+                const [LpToken] = await TokenService.getManyOrCreate([{ address: identifier, chainId }]);
+                const depositValue = await TokenService.getValue([{ ...LpToken, amount: BigInt(quote.amountOut) }]);
+                const actions = await EnsoService.getActions(chainId, quote.route, BigInt(quote.amountOut));
+                return { transaction: tx, depositValue: depositValue, actions };
+            },
+        };
+    }
 }

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

@@ -75,6 +75,8 @@ export declare const InteractionController: Elysia<"/interaction", false, {
                         approved: boolean;
                         transaction: import("./interaction.model").UserTransaction;
                         approval: import("./interaction.model").UserTransaction;
+                        actions?: import("./interaction.model").InteractionAction[] | undefined;
+                        depositValue?: number | undefined;
                     } | undefined;
                 };
             };

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

@@ -1,3 +1,15 @@
+import type { ProtocolId } from "../protocol";
+import type { Token } from "../token";
+/**
+ * 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> = {
@@ -35,7 +47,7 @@ export type UserTransaction = {
     data: string;
     to: string;
     from?: string;
-    value?: bigint;
+    value?: string;
 };
 export type InteractionQuote = {
     amountIn: bigint;
@@ -43,7 +55,41 @@ export type InteractionQuote = {
     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>;

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

@@ -1,12 +1,28 @@
-import { EnsoService } from "../enso/enso.service";
 import type { ProtocolId } from "../protocol";
-import type { InteractionQuote, InteractionTarget } from "./interaction.model";
+import type { InteractionQuote } from "./interaction.model";
 export declare abstract class InteractionService {
-    static getTarget(chainId: number, protocolId: ProtocolId, identifier: string): Promise<InteractionTarget[]>;
-    static getTargetFromKyberZap(chainId: number, protocolId: ProtocolId, identifier: string): InteractionTarget | undefined;
-    static getTargetFromEnso(chainId: number, protocolId: ProtocolId, identifier: string): Promise<InteractionTarget | undefined>;
-    static getTargetsFromEnsoTokens(tokens: Awaited<ReturnType<typeof EnsoService.getTokens>>): Promise<InteractionTarget[]>;
-    static getTargets(chainId: number, protocolId: ProtocolId, identifier: string): Promise<InteractionTarget[]>;
+    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
@@ -19,5 +35,4 @@ export declare abstract class InteractionService {
             data: `0x${string}`;
         };
     }>;
-    static getTransaction(provider: InteractionTarget["provider"], chainId: number, protocolId: ProtocolId, identifier: string, userAddress: string, fromTokenAddress: string, fromTokenAmount: bigint, slippage?: number): Promise<InteractionQuote>;
 }

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

@@ -1,60 +1,41 @@
 import { ETH_ADDRESS, ETH_ZKSYNC_ADDRESS } from "@sdk";
 import { decodeFunctionResult, encodeFunctionData, parseAbi } from "viem";
 import { ChainInteractionService } from "../chainInteraction";
-import { EnsoService } from "../enso/enso.service";
 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);
-        const ensoTargets = await InteractionService.getTargetsFromEnsoTokens(tokens);
-        return ensoTargets?.[0];
-    }
-    static async getTargetsFromEnsoTokens(tokens) {
-        const targets = [];
-        for (const { address, underlyingTokens, ...target } of tokens) {
-            try {
-                targets.push({
-                    provider: "enso",
-                    chainId: target.chainId,
-                    identifier: address,
-                });
-            }
-            catch { }
-        }
-        return targets;
-    }
+    static routers = [KyberZapService].map(service => service.getRouter());
+    /**
+     * 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 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;
+        return (await Promise.all(InteractionService.routers?.map(router => router.getTarget(chainId, protocolId, identifier)))).filter(a => a !== undefined);
+    }
+    /**
+     * 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 async getTransaction(provider, chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, slippage) {
+        const router = InteractionService.routers.find(({ name }) => name === provider);
+        if (!router)
+            throw new Error(`Router "${provider} not found`);
+        // Normalizing ETH on ZKSync
+        if (fromTokenAddress === ETH_ZKSYNC_ADDRESS)
+            fromTokenAddress = ETH_ADDRESS;
+        const transaction = await router.getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, { slippage });
+        const { allowance, approval, approved } = await InteractionService.getApproval(chainId, userAddress, transaction.transaction.to, fromTokenAddress, fromTokenAmount);
+        return { amountIn: fromTokenAmount, ...transaction, allowance, approval, approved };
     }
     /**
      * Gets approval information onchain
@@ -110,21 +91,4 @@ export class InteractionService {
             },
         };
     }
-    static async getTransaction(provider, chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, slippage) {
-        // Normalizing ETH on ZKSync
-        if (fromTokenAddress === ETH_ZKSYNC_ADDRESS)
-            fromTokenAddress = ETH_ADDRESS;
-        if (provider === "zap")
-            return await KyberZapService.getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, slippage);
-        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

@@ -68,6 +68,45 @@ export declare const apiTypes: {
         }>;
     };
 };
+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;

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

@@ -51,7 +51,7 @@ export const apiTypes = {
                 poolDetails: t.Object({}),
                 positionDetails: t.Object({}),
                 zapDetails: t.Object({
-                    actions: t.Array(t.Object({})),
+                    actions: t.Array(t.Object({}, { description: "ZapActions" })),
                     finalAmountUsd: t.String(),
                     priceImpact: t.Number(),
                 }),

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

@@ -1,6 +1,6 @@
-import type { InteractionQuote } from "../interaction/interaction.model";
+import type { InteractionAction, Router } from "../interaction/interaction.model";
 import type { ProtocolId } from "../protocol";
-import { type KyberZapDexId } from "./kyberzap.model";
+import { type KyberZapDexId, type ZapAction } from "./kyberzap.model";
 export declare abstract class KyberZapService {
     #private;
     static getDexId(protocolId: ProtocolId | string): KyberZapDexId | undefined;
@@ -11,5 +11,24 @@ export declare abstract class KyberZapService {
      * @param param0
      */
     static getFullRangeTicks(): number[];
-    static getTransaction(chainId: number, protocol: ProtocolId, identifier: string, userAddress: string, fromTokenAddress: string, fromTokenAmount: bigint, slippage?: number): Promise<InteractionQuote>;
+    /**
+     * 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;
 }