@merkl/api 0.9.15

package/dist/src/libs/positions/types.d.ts

@@ -0,0 +1,75 @@
+import type { Forwarder, ForwarderParameters } from "@sdk";
+export interface BucketData {
+    bucket_index: number;
+    deposit: string;
+    bucket_price: string;
+}
+export type UserPosition = {
+    balance: number;
+    token: string;
+    origin: string;
+    totalSupply: number;
+    tvl: number;
+};
+export type PositionType = {
+    [mainParameter: string]: {
+        userPositions: UserPosition[];
+        decimals: number;
+        totalSupply: number;
+        userTVL: number;
+    };
+};
+export type FetchedCampaign = {
+    computedtotalSupply: number;
+    rewardToken: string;
+    symbolRewardToken: string;
+    tvl: number;
+    decimals: number;
+    totalSupplyTargetToken: number;
+    amount: number;
+    forwarders?: {
+        [address: string]: ForwarderParameters<Forwarder>;
+    };
+};
+export type Res = {
+    userPositions: UserPosition[];
+    decimals: number;
+    totalSupply: number;
+    userTVL: number;
+};
+export type CLAMMPosition = {
+    userPositions: {
+        almAddress: string;
+        balance0: number;
+        balance1: number;
+        id: string;
+        inRangeLiquidity: number;
+        lowerTick: number;
+        origin: number;
+        totalLiquidity: number;
+        tvl: number;
+        upperTick: number;
+    }[];
+    tick: number;
+    userTVL: number;
+    userBalanceToken0: number;
+    userBalanceToken1: number;
+    userTotalLiquidity: number;
+    userInRangeLiquidity: number;
+};
+export type AjnaFetchedCampaign = FetchedCampaign & {
+    subtype: number;
+    poolId: string;
+    quoteToken: string;
+};
+export type BadgerFetchedCampaign = FetchedCampaign & {
+    targetToken: string;
+};
+export type MorphoFetchedCampaign = FetchedCampaign & {
+    targetToken: string;
+    subtype: number;
+    marketId?: string;
+};
+export type EigenLayerFetchedCampaign = FetchedCampaign & {
+    targetToken: string;
+};

package/dist/src/libs/positions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/libs/staticCampaigns.d.ts

@@ -0,0 +1,7 @@
+import type { MerklChainId } from "@sdk";
+/**
+ * @deprecated - to remove once:
+ *  - old update page is deprecated
+ *  - v3 campaigns route is removed
+ */
+export declare const staticCampaignWithCache: (chainId: MerklChainId) => Promise<any>;

package/dist/src/libs/staticCampaigns.js

@@ -0,0 +1,15 @@
+import { Redis } from "@/cache";
+import { engineDbClient } from "@db";
+async function staticCampaigns(chainId) {
+    return await engineDbClient.campaigns.findMany({
+        where: {
+            chainId: chainId,
+        },
+    });
+}
+/**
+ * @deprecated - to remove once:
+ *  - old update page is deprecated
+ *  - v3 campaigns route is removed
+ */
+export const staticCampaignWithCache = async (chainId) => await Redis.getOrSet(`StaticCampaigns_${chainId}`, staticCampaigns, chainId);

package/dist/src/libs/tokens/allowances.d.ts

@@ -0,0 +1 @@
+export declare function getUserAllowance(chainId: number, tokenAddress: string, userAddress: string, spenderAddresses: string): Promise<bigint>;

package/dist/src/libs/tokens/allowances.js

@@ -0,0 +1,18 @@
+import { ChainId, ChainInteractionService, ETH_ZKSYNC_ADDRESS, Erc20__factory, EthOnZKSync_INTERFACE } from "@sdk";
+export async function getUserAllowance(chainId, tokenAddress, userAddress, spenderAddresses) {
+    const ERC20_Interface = Erc20__factory.createInterface();
+    const allowanceCall = chainId === ChainId.ZKSYNC && tokenAddress === ETH_ZKSYNC_ADDRESS
+        ? {
+            allowFailure: true,
+            callData: EthOnZKSync_INTERFACE.encodeFunctionData("allowance", [userAddress, spenderAddresses]),
+            target: tokenAddress,
+        }
+        : {
+            allowFailure: true,
+            callData: ERC20_Interface.encodeFunctionData("allowance", [userAddress, spenderAddresses]),
+            target: tokenAddress,
+        };
+    const [result] = await ChainInteractionService(chainId).fetchState([allowanceCall]);
+    const allowance = ERC20_Interface.decodeFunctionResult("allowance", result.returnData)[0].toString();
+    return BigInt(allowance);
+}

package/dist/src/libs/tokens/balances.d.ts

@@ -0,0 +1,11 @@
+import type { UncachedResult } from "../../utils/execute";
+type ReturnType = {
+    [address: string]: {
+        symbol: string;
+        balance: string;
+        decimals: number;
+    };
+};
+export declare function getOnlyUserBalance(chainId: number, userAddress: string, tokenAddresses: string[]): Promise<ReturnType>;
+export declare function getUserBalances(user: string, chainId: number, tokenAddresses?: string[]): Promise<UncachedResult<ReturnType>>;
+export {};

package/dist/src/libs/tokens/balances.js

@@ -0,0 +1,127 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { ChainId, ChainInteractionService, ETH_ADDRESS, ETH_ZKSYNC_ADDRESS, Erc20__factory, EthOnZKSync_INTERFACE, NETWORK_LABELS, } from "@sdk";
+import { log } from "../../utils/logger";
+export async function getOnlyUserBalance(chainId, userAddress, tokenAddresses) {
+    const calls = [];
+    const ERC20_Interface = Erc20__factory.createInterface();
+    for (const tokenAddress of tokenAddresses) {
+        if (chainId === ChainId.ZKSYNC && tokenAddress === ETH_ZKSYNC_ADDRESS) {
+            calls.push({
+                allowFailure: true,
+                callData: EthOnZKSync_INTERFACE.encodeFunctionData("balanceOf", [userAddress]),
+                target: tokenAddress,
+            });
+        }
+        else {
+            calls.push({
+                allowFailure: true,
+                callData: ERC20_Interface.encodeFunctionData("balanceOf", [userAddress]),
+                target: tokenAddress,
+            });
+        }
+    }
+    const result = await ChainInteractionService(chainId).fetchState(calls);
+    const res = {};
+    for (let j = 0; j < tokenAddresses.length; j++) {
+        const tokenAddress = tokenAddresses[j];
+        let balance = "0";
+        try {
+            balance = ERC20_Interface.decodeFunctionResult("balanceOf", result[j].returnData)[0]?.toString();
+        }
+        catch (_error) {
+            log.local(`❌ Failed to call balanceOf for ${tokenAddress} on ${NETWORK_LABELS[chainId]}`);
+        }
+        res[tokenAddress] = {
+            balance: balance,
+            decimals: 0,
+            symbol: "",
+        };
+    }
+    return res;
+}
+export async function getUserBalances(user, chainId, tokenAddresses) {
+    const tokens = await TokenService.findManyObjectPerAddress({ chainId, verified: true });
+    if (!tokens) {
+        log.debug("❌ Chain not supported");
+        return {
+            cached: false,
+            call: {
+                callData: [],
+                handler: () => { },
+                reducer: async () => {
+                    return {};
+                },
+            },
+        };
+    }
+    const tokenListAddresses = Object.keys(tokens).filter(t => t !== ETH_ADDRESS);
+    const ERC20_Interface = Erc20__factory.createInterface();
+    const calls = [];
+    for (const tokenAddress of tokenListAddresses) {
+        calls.push({
+            allowFailure: true,
+            callData: ERC20_Interface.encodeFunctionData("balanceOf", [user]),
+            target: tokenAddress,
+        });
+    }
+    /** Only if the route is called from mainnet */
+    if (!!tokenAddresses && tokenAddresses?.length > 0) {
+        for (const externalTokenAddress of tokenAddresses) {
+            calls.push({
+                allowFailure: true,
+                callData: ERC20_Interface.encodeFunctionData("balanceOf", [user]),
+                target: externalTokenAddress,
+            }, {
+                allowFailure: true,
+                callData: ERC20_Interface.encodeFunctionData("decimals"),
+                target: externalTokenAddress,
+            }, {
+                allowFailure: true,
+                callData: ERC20_Interface.encodeFunctionData("symbol"),
+                target: externalTokenAddress,
+            });
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const res = {};
+                for (let j = 0; j < tokenListAddresses.length; j++) {
+                    const tokenAddress = tokenListAddresses[j];
+                    let balance = "0";
+                    try {
+                        balance = ERC20_Interface.decodeFunctionResult("balanceOf", result[j])[0]?.toString();
+                    }
+                    catch (_error) {
+                        log.local(`❌ Failed to call balanceOf for ${tokenAddress} on ${chainId}`);
+                    }
+                    res[tokenAddress] = {
+                        balance: balance,
+                        decimals: tokens[tokenAddress]?.decimals,
+                        symbol: tokens[tokenAddress]?.symbol,
+                    };
+                }
+                if (!!tokenAddresses && tokenAddresses?.length > 0) {
+                    for (let j = 0; j < tokenAddresses.length; j++) {
+                        const externalTokenAddress = tokenAddresses[j];
+                        try {
+                            res[externalTokenAddress] = {
+                                balance: ERC20_Interface.decodeFunctionResult("balanceOf", result[Object.keys(tokens)?.length + 3 * j])[0]?.toString(),
+                                decimals: ERC20_Interface.decodeFunctionResult("decimals", result[Object.keys(tokens)?.length + 3 * j + 1])[0]?.toString(),
+                                symbol: ERC20_Interface.decodeFunctionResult("symbol", result[Object.keys(tokens)?.length + 3 * j + 2])[0]?.toString(),
+                            };
+                        }
+                        catch (error) {
+                            // If it fails we don't return the token info
+                            log.local(`❌ Failed to call balanceOf, decimals or symbol for ${externalTokenAddress} on ${chainId}`);
+                        }
+                    }
+                }
+                return res;
+            },
+        },
+    };
+}

package/dist/src/libs/tokens/tokenInfo.d.ts

@@ -0,0 +1,8 @@
+import type { UncachedResult } from "@/utils/execute";
+type ReturnType = {
+    name: string;
+    symbol: string;
+    decimals: number;
+};
+export declare function getTokenInfo(address: string): Promise<UncachedResult<ReturnType>>;
+export {};

package/dist/src/libs/tokens/tokenInfo.js

@@ -0,0 +1,22 @@
+import { Erc20__factory } from "@sdk";
+export async function getTokenInfo(address) {
+    const ERC20_Interface = Erc20__factory.createInterface();
+    const read = ["symbol", "name", "decimals"];
+    const calls = read.map(fn => ({
+        allowFailure: false,
+        callData: ERC20_Interface.encodeFunctionData(fn),
+        target: address,
+    }));
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                return read.reduce((res, fn, index) => Object.assign(res, {
+                    [fn]: ERC20_Interface.decodeFunctionResult(fn, result[index])[0],
+                }), {});
+            },
+        },
+    };
+}

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

@@ -0,0 +1,219 @@
+import Elysia from "elysia";
+export declare const AccountingController: Elysia<"/accounting", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    accounting: {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    items?: number | undefined;
+                    page?: number | undefined;
+                };
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        id: string;
+                        datetime: Date;
+                        chainId: number;
+                        timestamp: number;
+                        recipient: string;
+                        fromTokenId: string;
+                        toTokenId: string;
+                        multisig: string;
+                        amountIn: string;
+                        amountOut: string;
+                    }[];
+                };
+            };
+        };
+    } & {
+        revenues: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        total: number;
+                        breakdown: {
+                            [key: number]: {
+                                chainAmount: number;
+                                percentage: number;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        revenues: {
+            "per-month": {
+                ":year": {
+                    ":month": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                year: number;
+                                month: number;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: {
+                                    total: number;
+                                    breakdown: {
+                                        [key: number]: {
+                                            chainAmount: number;
+                                            percentage: number;
+                                        };
+                                    };
+                                    from: string;
+                                    to: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        revenues: {
+            chains: {
+                ":chainId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            chainId: number;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: {
+                                totalAmount: number;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        revenues: {
+            chains: {
+                ":chainId": {
+                    "per-month": {
+                        ":year": {
+                            ":month": {
+                                get: {
+                                    body: unknown;
+                                    params: {
+                                        chainId: number;
+                                        year: number;
+                                        month: number;
+                                    };
+                                    query: unknown;
+                                    headers: {
+                                        authorization: string;
+                                    };
+                                    response: {
+                                        200: {
+                                            totalAmount: number;
+                                            from: string;
+                                            to: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        tokens: {
+            ":chainId": {
+                ":tokenAddress": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            chainId: number;
+                            tokenAddress: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: {
+                                totalAmount: number;
+                                totalAmountUSD: number;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        tokens: {
+            ":chainId": {
+                ":tokenAddress": {
+                    "per-month": {
+                        ":year": {
+                            ":month": {
+                                get: {
+                                    body: unknown;
+                                    params: {
+                                        chainId: number;
+                                        year: number;
+                                        month: number;
+                                        tokenAddress: string;
+                                    };
+                                    query: unknown;
+                                    headers: {
+                                        authorization: string;
+                                    };
+                                    response: {
+                                        200: {
+                                            totalAmount: number;
+                                            totalAmountUSD: number;
+                                            from: string;
+                                            to: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,66 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
+import { AccountingService, ChainDto, DateDto, GetTransactionsQueryModel, RevenuesDto, TokensDateDto, TokensDto, } from "@/modules/v4/accounting";
+import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
+import Elysia from "elysia";
+export const AccountingController = new Elysia({ prefix: "/accounting", detail: { tags: ["Accounting"], hide: true } })
+    .get("/", async ({ query }) => await AccountingService.findMany(query), {
+    query: GetTransactionsQueryModel,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: async ({ headers }) => {
+        await BackOfficeGuard({ headers });
+    },
+})
+    .group("/revenues", app => {
+    return app
+        .get("", async () => await AccountingService.getAllRevenueBreakdownByChain(), {
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ headers }) => {
+            await BackOfficeGuard({ headers });
+        },
+    })
+        .get("/per-month/:year/:month", async ({ params }) => await AccountingService.getMonthlyRevenue(params.year, params.month), {
+        params: DateDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ headers }) => {
+            await BackOfficeGuard({ headers });
+        },
+    })
+        .get("/chains/:chainId", async ({ params }) => await AccountingService.getRevenueByChain(params.chainId), {
+        params: ChainDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ params, headers }) => {
+            await BackOfficeGuard({ headers });
+            throwOnUnsupportedChainId(params.chainId);
+        },
+    })
+        .get("/chains/:chainId/per-month/:year/:month", async ({ params }) => await AccountingService.getMonthlyRevenueByChain(params.chainId, params.year, params.month), {
+        params: RevenuesDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ params, headers }) => {
+            await BackOfficeGuard({ headers });
+            throwOnUnsupportedChainId(params.chainId);
+        },
+    });
+})
+    // ─── Tokens Group ────────────────────────────────────────────────────
+    .group("/tokens", app => {
+    return app
+        .get("/:chainId/:tokenAddress", async ({ params }) => await AccountingService.getTokenTransaction(params.tokenAddress, params.chainId), {
+        params: TokensDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ params, headers }) => {
+            await BackOfficeGuard({ headers });
+            params.tokenAddress = throwOnInvalidRequiredAddress(params.tokenAddress);
+            throwOnUnsupportedChainId(params.chainId);
+        },
+    })
+        .get("/:chainId/:tokenAddress/per-month/:year/:month", async ({ params }) => await AccountingService.getTokenMonthlyTransaction(params.tokenAddress, params.chainId, params.year, params.month), {
+        params: TokensDateDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ params, headers }) => {
+            await BackOfficeGuard({ headers });
+            params.tokenAddress = throwOnInvalidRequiredAddress(params.tokenAddress);
+            throwOnUnsupportedChainId(params.chainId);
+        },
+    });
+});

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

@@ -0,0 +1,32 @@
+export declare const TokensDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    tokenAddress: import("@sinclair/typebox").TString;
+}>;
+export declare const GetTransactionsQueryModel: import("@sinclair/typebox").TObject<{
+    page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const TokensDateDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    tokenAddress: import("@sinclair/typebox").TString;
+    month: import("@sinclair/typebox").TNumber;
+    year: import("@sinclair/typebox").TNumber;
+}>;
+export declare const DateDto: import("@sinclair/typebox").TObject<{
+    month: import("@sinclair/typebox").TNumber;
+    year: import("@sinclair/typebox").TNumber;
+}>;
+export declare const ChainDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+}>;
+export declare const RevenuesDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    month: import("@sinclair/typebox").TNumber;
+    year: import("@sinclair/typebox").TNumber;
+}>;
+export declare const GetRevenuesDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    month: import("@sinclair/typebox").TNumber;
+    year: import("@sinclair/typebox").TNumber;
+}>;
+export type GetTransactionsQueryModel = typeof GetTransactionsQueryModel.static;

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

@@ -0,0 +1,32 @@
+import { t } from "elysia";
+export const TokensDto = t.Object({
+    chainId: t.Numeric(),
+    tokenAddress: t.String(),
+});
+export const GetTransactionsQueryModel = t.Object({
+    page: t.Optional(t.Numeric()),
+    items: t.Optional(t.Numeric()),
+});
+export const TokensDateDto = t.Object({
+    chainId: t.Numeric(),
+    tokenAddress: t.String(),
+    month: t.Numeric(),
+    year: t.Numeric(),
+});
+export const DateDto = t.Object({
+    month: t.Numeric(),
+    year: t.Numeric(),
+});
+export const ChainDto = t.Object({
+    chainId: t.Numeric(),
+});
+export const RevenuesDto = t.Object({
+    chainId: t.Numeric(),
+    month: t.Numeric(),
+    year: t.Numeric(),
+});
+export const GetRevenuesDto = t.Object({
+    chainId: t.Numeric(),
+    month: t.Numeric(),
+    year: t.Numeric(),
+});