@merkl/api 0.9.15

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

@@ -0,0 +1,13 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
+import Elysia from "elysia";
+import { CreateExplorerDto } from "./explorer.model";
+import { ExplorerService } from "./explorer.service";
+// ─── Explorer Controller ───────────────────────────────────────────────────────
+export const ExplorerController = new Elysia({ prefix: "/explorers", detail: { tags: ["Explorers"] } })
+    // ─── Create An Explorer ──────────────────────────────────────────────────────
+    .post("", async ({ body }) => await ExplorerService.create(body), {
+    beforeHandle: BackOfficeGuard,
+    headers: AuthorizationHeadersDto,
+    body: CreateExplorerDto,
+    detail: { hide: true },
+});

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<{
+        ETHERSCAN: "ETHERSCAN";
+        BLOCKSCOUT: "BLOCKSCOUT";
+    }>;
+    url: import("@sinclair/typebox").TString;
+}>;
+export type CreateExplorerDto = typeof CreateExplorerDto.static;

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

@@ -0,0 +1,8 @@
+// ─── Schemas ─────────────────────────────────────────────────────────────────
+import { ExplorerType } from "@db/api";
+import { t } from "elysia";
+export const CreateExplorerDto = t.Object({
+    chainId: t.Numeric(),
+    type: t.Enum(ExplorerType),
+    url: t.String(),
+});

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

@@ -0,0 +1,21 @@
+import type { ExplorerType } from "@db/api";
+export declare abstract class ExplorerRepository {
+    static getByChainId(chainId: number): Promise<{
+        id: string;
+        type: import("@db/api").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    }>;
+    /**
+     * 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;
+        type: import("@db/api").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    }>;
+}

package/dist/src/modules/v4/explorer/explorer.repository.js

@@ -0,0 +1,23 @@
+import { apiDbClient } from "@db";
+import { ExplorerService } from "./explorer.service";
+export class ExplorerRepository {
+    static async getByChainId(chainId) {
+        return await apiDbClient.explorer.findFirstOrThrow({ where: { chainId } });
+    }
+    /**
+     * 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 async create(chainId, type, url) {
+        return apiDbClient.explorer.create({
+            data: {
+                chainId,
+                type,
+                url,
+                id: ExplorerService.hashId(type, chainId),
+            },
+        });
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { ExplorerType } from "@db/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;
+        type: import("@db/api").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    }>;
+    static format(explorer: Explorer["raw"]): {
+        type: import("@db/api").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    };
+    /**
+     * 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;
+        type: import("@db/api").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    }>;
+}

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

@@ -0,0 +1,24 @@
+import { ExplorerRepository } from "./explorer.repository";
+export class ExplorerService {
+    static hashId(type, chainId) {
+        return Bun.hash(`${type}${chainId}`).toString();
+    }
+    static async getByChainId(chainId) {
+        return await ExplorerRepository.getByChainId(chainId);
+    }
+    static format(explorer) {
+        const { id, ...rest } = explorer;
+        return {
+            ...rest,
+        };
+    }
+    /**
+     * 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 async create(data) {
+        return ExplorerRepository.create(data.chainId, data.type, data.url);
+    }
+}

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

@@ -0,0 +1,97 @@
+import Elysia from "elysia";
+export declare const InteractionController: Elysia<"/interaction", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    interaction: {
+        targets: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    protocolId?: string | undefined;
+                    identifier: string;
+                    chainId: number;
+                };
+                headers: unknown;
+                response: {
+                    200: import("./interaction.model").InteractionTarget[];
+                };
+            };
+        };
+    };
+} & {
+    interaction: {
+        protocols: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    chainId?: number | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: ({
+                        id: string;
+                        name: string;
+                        url: string;
+                        description: string;
+                        tags: string[];
+                        icon: string;
+                    } & {
+                        dailyRewards?: number | undefined;
+                        numberOfLiveCampaigns?: number | undefined;
+                        opportunityLiveTags?: string[] | undefined;
+                    })[];
+                };
+            };
+        };
+    };
+} & {
+    interaction: {
+        transaction: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    slippage?: number | undefined;
+                    identifier: string;
+                    chainId: number;
+                    protocolId: string;
+                    userAddress: string;
+                    fromAmount: 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;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,40 @@
+import Elysia from "elysia";
+import { EnsoService } from "../enso/enso.service";
+import { GetInteractionProtocolsQueryDto, GetInteractionQuoteQueryDto, GetInteractionTargetsQueryDto, } from "./interaction.model";
+import { InteractionService } from "./interaction.service";
+// ─── Interaction Controller ──────────────────────────────────────────────────
+export const InteractionController = new Elysia({
+    prefix: "/interaction",
+    detail: { tags: ["Interaction"], hide: true },
+})
+    .get("/targets", async ({ query: { protocolId, chainId, identifier } }) => {
+    return await InteractionService.getTargets(chainId, protocolId, identifier);
+}, {
+    query: GetInteractionTargetsQueryDto,
+    detail: {
+        summary: "Available interaction targets for a protocol",
+        description: "Retrieves all the pool/token/contract",
+    },
+})
+    // ─── Get All Compatible Protocols ───────────────────────────────────────
+    .get("/protocols", async ({ query }) => await EnsoService.getCompatibleProtocols(query), {
+    query: GetInteractionProtocolsQueryDto,
+    detail: {
+        summary: "Interactable protocols",
+        description: "Retrieves protocols integrated by merkl which supports being interacted with",
+    },
+})
+    // ─── Get Transaction ─────────────────────────────────────────────────
+    .get("/transaction", async ({ query: { protocolId, chainId, identifier, userAddress, fromAmount, fromTokenAddress, slippage } }) => {
+    const [target] = await InteractionService.getTargets(chainId, protocolId, identifier);
+    //TODO: throw error
+    if (!target)
+        return;
+    return await InteractionService.getTransaction(target.provider, chainId, protocolId, identifier, userAddress, fromTokenAddress, BigInt(fromAmount), slippage);
+}, {
+    query: GetInteractionQuoteQueryDto,
+    detail: {
+        summary: "Get participate transaction",
+        description: "",
+    },
+});

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.model.js

@@ -0,0 +1,25 @@
+import protocol from "database/api/seeder/resources/protocol";
+import { t } from "elysia";
+export const participateInputTypes = ["tokenAmount", "token"];
+export const participateTypes = ["link", "deposit", "withdraw"];
+export const GetInteractionTargetsQueryDto = t.Object({
+    chainId: t.Numeric(),
+    protocolId: t.Optional(t.String({
+        examples: Object.values(protocol).reduce((obj, i) => Object.assign(obj, { [i.name]: { value: i.id } }), {}),
+    })),
+    identifier: t.String(),
+});
+export const GetInteractionQuoteQueryDto = t.Object({
+    chainId: t.Numeric(),
+    protocolId: t.String({
+        examples: Object.values(protocol).reduce((obj, i) => Object.assign(obj, { [i.name]: { value: i.id } }), {}),
+    }),
+    identifier: t.String(),
+    userAddress: t.String(),
+    fromTokenAddress: t.String(),
+    fromAmount: t.String(),
+    slippage: t.Optional(t.Number({ description: "Slippage in basis points (O.1%)" })),
+});
+export const GetInteractionProtocolsQueryDto = t.Object({
+    chainId: t.Optional(t.Numeric()),
+});

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: any;
+        approval: {
+            to: string;
+            data: `0x${string}`;
+        };
+    }>;
+}

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

@@ -0,0 +1,95 @@
+import { ChainInteractionService } from "@/modules/v4/chainInteraction/chainInteraction.service";
+import { EnsoService } from "@/modules/v4/enso/enso.service";
+import { KyberZapService } from "@/modules/v4/kyberzap/kyberzap.service";
+import { ETH_ADDRESS, ETH_ZKSYNC_ADDRESS } from "@sdk";
+import { decodeFunctionResult, encodeFunctionData, parseAbi } from "viem";
+export class InteractionService {
+    static routers = [KyberZapService, EnsoService].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) {
+        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
+     * @returns approved?, approval tx & allowance amount
+     */
+    static async getApproval(chainId, owner, spender, tokenAddress, amount) {
+        // Normalizing ETH on ZKSync
+        if (tokenAddress === ETH_ZKSYNC_ADDRESS)
+            tokenAddress = ETH_ADDRESS;
+        //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)",
+        ]);
+        if (tokenAddress === ETH_ADDRESS)
+            return {
+                approved: true,
+                allowance: 0n,
+                approval: {
+                    to: tokenAddress,
+                    data: encodeFunctionData({
+                        abi,
+                        functionName: "approve",
+                        args: [spender, amount],
+                    }),
+                },
+            };
+        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],
+                }),
+            },
+        };
+    }
+}

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: "pancakeswap";
+    DEX_SUSHISWAPV3: "sushiswap";
+    DEX_CURVE: "curve";
+    DEX_SYNCSWAP_V3: "syncswap";
+    DEX_ZKSWAP_V3: "zkswap";
+    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];