@merkl/api 0.9.15

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

@@ -0,0 +1,38 @@
+import { apiDbClient } from "@db";
+// ─── Users Repository ────────────────────────────────────────────────────────
+export class UserRepository {
+    static async findUnique(address) {
+        return await apiDbClient.user.findUnique({ where: { address } });
+    }
+    static async findMany(query) {
+        const { page: _page, items: _items, ...filters } = query;
+        const page = _page ? _page : 0;
+        const items = _items ? _items : 20;
+        return await apiDbClient.user.findMany({
+            take: items,
+            skip: page * items,
+            where: {
+                address: filters.address ? filters.address : undefined,
+                tags: filters.tags ? { hasEvery: filters.tags } : undefined,
+            },
+        });
+    }
+    static async findManyWithTags() {
+        return await apiDbClient.user.findMany({
+            where: {
+                tags: {
+                    isEmpty: false,
+                },
+            },
+        });
+    }
+    static async create(user) {
+        return await apiDbClient.user.create({ data: user });
+    }
+    static async createMany(users) {
+        return await apiDbClient.user.createMany({ data: users, skipDuplicates: true });
+    }
+    static async updateTags(address, tags) {
+        return await apiDbClient.user.update({ where: { address }, data: { tags } });
+    }
+}

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

@@ -0,0 +1,31 @@
+import type { GetManyUserModel, UserModel } from "./user.model";
+export declare abstract class UserService {
+    static findUnique(address: string): Promise<{
+        tags: string[];
+        address: string;
+        creatorId: string | null;
+    } | null>;
+    static findMany(query: GetManyUserModel): Promise<{
+        tags: string[];
+        address: string;
+        creatorId: string | null;
+    }[]>;
+    static findManyWithTags(): Promise<{
+        tags: string[];
+        address: string;
+        creatorId: string | null;
+    }[]>;
+    static create(user: UserModel): Promise<{
+        tags: string[];
+        address: string;
+        creatorId: string | null;
+    }>;
+    static createMany(users: UserModel[]): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    static updateTags(user: string, tags: string[]): Promise<{
+        tags: string[];
+        address: string;
+        creatorId: string | null;
+    }>;
+    static syncTags(): Promise<void>;
+    static syncOpportunityTags(): Promise<void>;
+}

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

@@ -0,0 +1,67 @@
+import { log } from "@/utils/logger";
+import { engineDbClient } from "@db";
+import { OpportunityService } from "../opportunity";
+import { UserRepository } from "./user.repository";
+// ─── Users Services ──────────────────────────────────────────────────────────
+export class UserService {
+    static async findUnique(address) {
+        return await UserRepository.findUnique(address);
+    }
+    static async findMany(query) {
+        return await UserRepository.findMany(query);
+    }
+    static async findManyWithTags() {
+        return await UserRepository.findManyWithTags();
+    }
+    static async create(user) {
+        return await UserRepository.create(user);
+    }
+    static async createMany(users) {
+        return await UserRepository.createMany(users);
+    }
+    static async updateTags(user, tags) {
+        if (!(await UserRepository.findUnique(user))) {
+            await UserRepository.create({ address: user, tags: [] });
+        }
+        return await UserRepository.updateTags(user, tags);
+    }
+    static async syncTags() {
+        // 1 - engine -> api db
+        const creatorTags = await engineDbClient.campaignCreators.findMany();
+        log.info(`syncing ${creatorTags.length} creator tags`);
+        await UserRepository.createMany(creatorTags.map(tag => {
+            return {
+                address: tag.address,
+                tags: [],
+            };
+        }));
+        for (const tag of creatorTags) {
+            await UserRepository.updateTags(tag.address, tag.tags.split(",").map(tag => tag.trim()));
+        }
+        // 2 - api -> engine db
+        const apiUsers = await UserRepository.findManyWithTags();
+        for (const tag of creatorTags) {
+            if (creatorTags.findIndex(t => t.address === tag.address) === -1) {
+                await engineDbClient.campaignCreators.create({
+                    data: {
+                        address: tag.address,
+                        tags: apiUsers.find(u => u.address === tag.address)?.tags.join(",") || "",
+                    },
+                });
+            }
+        }
+    }
+    static async syncOpportunityTags() {
+        const users = await UserRepository.findManyWithTags();
+        for (const user of users) {
+            const opportunities = await OpportunityService.findMany({ creatorAddress: user.address });
+            for (const opportunity of opportunities) {
+                if (!user.tags.every(tag => opportunity.tags.includes(tag))) {
+                    log.local(`updating tags for opportunity ${opportunity.id}: adding ${user.tags.join(",")}`);
+                    log.local(`opportunity tags: ${opportunity.tags.join(",")}`);
+                    await OpportunityService.update(opportunity.id, { tags: [...opportunity.tags, ...user.tags] });
+                }
+            }
+        }
+    }
+}

package/dist/src/plugins/error-handling.plugin.d.ts

@@ -0,0 +1,29 @@
+import { BadRequestError, ConflictError, HttpError, NotFoundError, UnauthorizedError } from "@/errors";
+import type Elysia from "elysia";
+export declare const ErrorHandler: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {
+        readonly HttpError: HttpError;
+        readonly BadRequestError: BadRequestError;
+        readonly ConflictError: ConflictError;
+        readonly NotFoundError: NotFoundError;
+        readonly UnauthorizedError: UnauthorizedError;
+    };
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/plugins/error-handling.plugin.js

@@ -0,0 +1,34 @@
+import { BadRequestError, ConflictError, HttpError, NotFoundError, UnauthorizedError } from "@/errors";
+import { log } from "@/utils/logger";
+// ─── Error Handler Plugin ────────────────────────────────────────────────────
+export const ErrorHandler = (app) => app
+    // ─── Error Types ─────────────────────────────────────────────────────
+    .error({
+    HttpError,
+    BadRequestError,
+    ConflictError,
+    NotFoundError,
+    UnauthorizedError,
+})
+    // ─── Error Handling ──────────────────────────────────────────────────
+    .onError(({ code, error, set }) => {
+    set.headers["content-type"] = "application/json";
+    if (code === "HttpError") {
+        log.error("HttpError", error);
+        set.status = error.httpCode;
+        return {
+            name: error.name,
+            message: error.message,
+            info: error.info,
+        };
+    }
+    if (code === "VALIDATION") {
+        return {
+            name: "ValidationError",
+            message: JSON.parse(error.message).summary,
+            info: JSON.parse(error.message),
+        };
+    }
+    log.error("Unknown error", error);
+    return error;
+});

package/dist/src/routes/v1/allowances.d.ts

@@ -0,0 +1,67 @@
+import type { TokenInfoListType } from "@/libs/getTokensList";
+import { type UncachedResult } from "@/utils/execute";
+import type Elysia from "elysia";
+type ReturnType = {
+    [spender: string]: {
+        [address: string]: {
+            symbol: string;
+            allowance: string;
+            decimals: number;
+        };
+    };
+};
+export declare function getUserAllowances(user: string, spenders: string[], tokens: TokenInfoListType, chainId: number, additionalTokenAddresses?: string[]): Promise<UncachedResult<ReturnType>>;
+export declare const query: import("@sinclair/typebox").TObject<{
+    additionalTokenAddresses: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    chainId: import("@sinclair/typebox").TNumber;
+    user: import("@sinclair/typebox").TString;
+}>;
+export declare const response: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+    balance: import("@sinclair/typebox").TNumber;
+    decimals: import("@sinclair/typebox").TNumber;
+    symbol: import("@sinclair/typebox").TString;
+}>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    allowances: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                additionalTokenAddresses?: string[] | undefined;
+                chainId: number;
+                user: string;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    [x: string]: {
+                        symbol: string;
+                        balance: string;
+                        decimals: number;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

package/dist/src/routes/v1/allowances.js

@@ -0,0 +1,115 @@
+import checkQueryAddressValidity from "@/hooks/checkQueryAddressValidity";
+import checkQueryChainIdValidity from "@/hooks/checkQueryChainIdValidity";
+import { getUserBalances } from "@/libs/tokens/balances";
+import { executeSimple } from "@/utils/execute";
+import { throwOnInvalidAddress } from "@/utils/throw";
+import { ChainId, ERC20Interface, ETH_ADDRESS, registry } from "@sdk";
+import { t } from "elysia";
+export async function getUserAllowances(user, spenders, tokens, chainId, additionalTokenAddresses) {
+    /** Filtered tokens list */
+    const filteredTokens = Object.keys(tokens).reduce((filteredTokensList, tokenAddress) => {
+        if (tokenAddress === "0x0000000000000000000000000000000000001010" ||
+            tokenAddress === ETH_ADDRESS ||
+            tokenAddress === registry(ChainId.MAINNET)?.veANGLE)
+            return filteredTokensList;
+        if (!tokens[tokenAddress]?.wrappingMethod || tokens[tokenAddress]?.wrappingMethod !== "Convex") {
+            filteredTokensList[tokenAddress] = tokens[tokenAddress];
+        }
+        return filteredTokensList;
+    }, {});
+    const calls = [];
+    for (const tokenAddress of Object.keys(filteredTokens)) {
+        for (const spender of spenders) {
+            calls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("allowance", [user, spender]),
+                target: tokenAddress,
+            });
+        }
+    }
+    if (!!additionalTokenAddresses && additionalTokenAddresses?.length > 0) {
+        for (const tokenAddress of additionalTokenAddresses) {
+            for (const spender of spenders) {
+                calls.push({
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("allowance", [user, spender]),
+                    target: tokenAddress,
+                });
+            }
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const res = {};
+                let j = 0;
+                for (const tokenAddress of Object.keys(filteredTokens)) {
+                    const auxRes = {};
+                    for (const spender of spenders) {
+                        let allowance = "0";
+                        try {
+                            allowance = ERC20Interface.decodeFunctionResult("allowance", result[j])[0]?.toString();
+                        }
+                        catch (error) {
+                            console.log(`❌ Failed to call allowance for ${tokenAddress} on ${chainId}`);
+                        }
+                        auxRes[spender] = {
+                            allowance: allowance,
+                        };
+                        j++;
+                    }
+                    res[tokenAddress] = {
+                        ...auxRes,
+                        decimals: filteredTokens[tokenAddress]?.decimals,
+                    };
+                }
+                if (!!additionalTokenAddresses && additionalTokenAddresses?.length > 0) {
+                    for (const tokenAddress of additionalTokenAddresses) {
+                        const auxRes = {};
+                        for (const spender of spenders) {
+                            let allowance = "0";
+                            try {
+                                allowance = ERC20Interface.decodeFunctionResult("allowance", result[j])[0]?.toString();
+                            }
+                            catch (error) {
+                                console.log(`❌ Failed to call allowance for ${tokenAddress} on ${chainId}`);
+                            }
+                            auxRes[spender] = {
+                                allowance: allowance,
+                            };
+                            j++;
+                        }
+                        res[tokenAddress] = {
+                            ...auxRes,
+                            decimals: filteredTokens[tokenAddress]?.decimals,
+                        };
+                    }
+                }
+                return res;
+            },
+        },
+    };
+}
+export const query = t.Object({
+    additionalTokenAddresses: t.Optional(t.Array(t.String())),
+    chainId: t.Numeric(),
+    user: t.String(),
+});
+export const response = t.Record(t.String({ title: "TokenAddress" }), t.Object({ balance: t.Numeric(), decimals: t.Number(), symbol: t.String() }));
+export default (app) => app
+    .use(checkQueryChainIdValidity())
+    .use(checkQueryAddressValidity())
+    .get("/allowances", async ({ query }) => {
+    const { chainId, user } = query;
+    const additionalTokenAddresses = query.additionalTokenAddresses;
+    additionalTokenAddresses?.forEach(tokenAddress => throwOnInvalidAddress(tokenAddress));
+    return !!additionalTokenAddresses?.length && additionalTokenAddresses?.length > 0
+        ? await executeSimple(chainId, getUserBalances(user, chainId, additionalTokenAddresses))
+        : await executeSimple(chainId, getUserBalances(user, chainId));
+}, {
+    query,
+    tags: ["Onchain"],
+});

package/dist/src/routes/v1/balances.d.ts

@@ -0,0 +1,50 @@
+import type Elysia from "elysia";
+export declare const response: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+    balance: import("@sinclair/typebox").TNumber;
+    decimals: import("@sinclair/typebox").TNumber;
+    symbol: import("@sinclair/typebox").TString;
+}>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    balances: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                additionalTokenAddresses?: string[] | undefined;
+                chainId: number;
+                user: string;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    [x: string]: {
+                        symbol: string;
+                        balance: string;
+                        decimals: number;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

package/dist/src/routes/v1/balances.js

@@ -0,0 +1,25 @@
+import checkQueryAddressValidity from "@/hooks/checkQueryAddressValidity";
+import checkQueryChainIdValidity from "@/hooks/checkQueryChainIdValidity";
+import { getUserBalances } from "@/libs/tokens/balances";
+import { executeSimple } from "@/utils/execute";
+import { throwOnInvalidAddress } from "@/utils/throw";
+import { t } from "elysia";
+export const response = t.Record(t.String({ title: "TokenAddress" }), t.Object({ balance: t.Numeric(), decimals: t.Number(), symbol: t.String() }));
+export default (app) => app
+    .use(checkQueryChainIdValidity())
+    .use(checkQueryAddressValidity())
+    .get("/balances", async ({ query }) => {
+    const { chainId, user } = query;
+    const additionalTokenAddresses = query.additionalTokenAddresses;
+    additionalTokenAddresses?.forEach(tokenAddress => throwOnInvalidAddress(tokenAddress));
+    return !!additionalTokenAddresses?.length && additionalTokenAddresses?.length > 0
+        ? await executeSimple(chainId, getUserBalances(user, chainId, additionalTokenAddresses))
+        : await executeSimple(chainId, getUserBalances(user, chainId));
+}, {
+    query: t.Object({
+        additionalTokenAddresses: t.Optional(t.Array(t.String())),
+        chainId: t.Numeric(),
+        user: t.String(),
+    }),
+    tags: ["Onchain"],
+});

package/dist/src/routes/v1/prices.d.ts

@@ -0,0 +1,42 @@
+import type Elysia from "elysia";
+export declare const response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    rate: import("@sinclair/typebox").TNumber;
+    token: import("@sinclair/typebox").TString;
+}>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    prices: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {};
+            headers: unknown;
+            response: {
+                200: {
+                    rate: number;
+                    token: string;
+                }[];
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

package/dist/src/routes/v1/prices.js

@@ -0,0 +1,9 @@
+import { PriceService } from "@/modules/v4/price";
+import { t } from "elysia";
+export const response = t.Array(t.Object({ rate: t.Number(), token: t.String() }));
+export default (app) => app.get("/prices", async () => {
+    return await PriceService.findManyArray();
+}, {
+    query: t.Object({}),
+    tags: ["Onchain"],
+});

package/dist/src/routes/v1/router.d.ts

@@ -0,0 +1,102 @@
+import Elysia from "elysia";
+export declare const v1: Elysia<"/v1", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    v1: {
+        allowances: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    additionalTokenAddresses?: string[] | undefined;
+                    chainId: number;
+                    user: string;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        [x: string]: {
+                            symbol: string;
+                            balance: string;
+                            decimals: number;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        balances: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    additionalTokenAddresses?: string[] | undefined;
+                    chainId: number;
+                    user: string;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        [x: string]: {
+                            symbol: string;
+                            balance: string;
+                            decimals: number;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        prices: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {};
+                headers: unknown;
+                response: {
+                    200: {
+                        rate: number;
+                        token: string;
+                    }[];
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        tokens: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {};
+                headers: unknown;
+                response: {
+                    [x: string]: any;
+                    200: any;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/routes/v1/router.js

@@ -0,0 +1,6 @@
+import Elysia from "elysia";
+import allowances from "./allowances";
+import balances from "./balances";
+import prices from "./prices";
+import tokens from "./tokens";
+export const v1 = new Elysia({ tags: ["v1"], prefix: "/v1" }).use(allowances).use(balances).use(prices).use(tokens);

package/dist/src/routes/v1/tokens.d.ts

@@ -0,0 +1,45 @@
+import type Elysia from "elysia";
+export declare const response: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    decimals: import("@sinclair/typebox").TNumber;
+    symbol: import("@sinclair/typebox").TString;
+    hasPermit: import("@sinclair/typebox").TBoolean;
+    useInSwap: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    logoURI: import("@sinclair/typebox").TString;
+}>>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    tokens: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {};
+            headers: unknown;
+            response: {
+                [x: string]: any;
+                200: any;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;