@merkl/api 0.9.15

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

@@ -0,0 +1,79 @@
+import type { CreateProtocolModel, GetProtocolsQueryModel, UpdateProtocolModel } from "./protocol.model";
+export declare abstract class ProtocolRepository {
+    #private;
+    static create(data: CreateProtocolModel): Promise<{
+        id: string;
+        name: string;
+        url: string;
+        description: string;
+        tags: string[];
+        icon: string;
+    }>;
+    static read(type: string): Promise<{
+        id: string;
+        name: string;
+        url: string;
+        description: string;
+        tags: string[];
+        icon: string;
+    } | null>;
+    static findManyByName(name: string): Promise<{
+        id: string;
+        name: string;
+        url: string;
+        description: string;
+        tags: string[];
+        icon: string;
+    }[]>;
+    static findMany(query: GetProtocolsQueryModel): Promise<({
+        MainOpportunities: ({
+            Campaigns: {
+                id: string;
+                type: string;
+                params: import("database/api/.generated/runtime/library").JsonValue;
+                subType: number | null;
+                computeChainId: number;
+                distributionChainId: number;
+                campaignId: string;
+                rewardTokenId: string;
+                amount: string;
+                opportunityId: string;
+                startTimestamp: bigint;
+                endTimestamp: bigint;
+                creatorAddress: string;
+                manualOverrides: import("@db/api").$Enums.CampaignManualOverride[];
+                createdAt: Date;
+            }[];
+        } & {
+            id: string;
+            name: string;
+            type: string;
+            status: import("@db/api").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            action: import("@db/api").$Enums.OpportunityAction;
+            chainId: number;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        })[];
+    } & {
+        id: string;
+        name: string;
+        url: string;
+        description: string;
+        tags: string[];
+        icon: string;
+    })[]>;
+    static countMany(query: GetProtocolsQueryModel): Promise<number>;
+    static update(id: string, data: UpdateProtocolModel): Promise<{
+        id: string;
+        name: string;
+        url: string;
+        description: string;
+        tags: string[];
+        icon: string;
+    }>;
+}

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

@@ -0,0 +1,81 @@
+import { apiDbClient } from "@db";
+// ─── Protocols Repository ────────────────────────────────────────────────────
+export class ProtocolRepository {
+    static async create(data) {
+        return await apiDbClient.protocol.create({
+            data: {
+                id: data.id,
+                name: data.name,
+                icon: data.icon,
+                url: data.url,
+                description: data.description,
+                tags: data.tags,
+            },
+        });
+    }
+    static async read(type) {
+        return await apiDbClient.protocol.findUnique({ where: { id: type } });
+    }
+    static async findManyByName(name) {
+        return await apiDbClient.protocol.findMany({ where: { name: { equals: name } } });
+    }
+    static #transformQueryToPrismaFilters(query) {
+        return {
+            where: {
+                id: query.id
+                    ? { contains: query.id, mode: "insensitive" }
+                    : query.ids
+                        ? { in: query.ids, mode: "insensitive" }
+                        : undefined,
+                tags: query.tags ? { hasEvery: query.tags } : undefined,
+                name: query.name ? { contains: query.name, mode: "insensitive" } : undefined,
+                OR: query.opportunityTag // The opportunity tag specified can be either at the protocol level or the opportunity level
+                    ? [
+                        {
+                            MainOpportunities: {
+                                some: {
+                                    tags: {
+                                        has: query.opportunityTag,
+                                    },
+                                },
+                            },
+                        },
+                        { tags: { has: query.opportunityTag } },
+                    ]
+                    : undefined,
+                // id: typeof query.id === "string" ? query.id : !!query.id ? { in: query.id } : undefined,
+            },
+        };
+    }
+    static async findMany(query) {
+        const { page: _page, items: _items } = query;
+        const page = _page ? _page : 0;
+        const items = _items ? _items : 500;
+        const args = ProtocolRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.protocol.findMany({
+            take: items,
+            skip: page * items,
+            ...args,
+            include: {
+                MainOpportunities: {
+                    include: {
+                        Campaigns: {
+                            where: {
+                                endTimestamp: {
+                                    gt: BigInt(Math.floor(Date.now() / 1000)),
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+    }
+    static async countMany(query) {
+        const args = ProtocolRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.protocol.count(args);
+    }
+    static async update(id, data) {
+        return await apiDbClient.protocol.update({ where: { id }, data });
+    }
+}

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

@@ -0,0 +1,24 @@
+import type { CreateProtocolModel, GetProtocolsQueryModel, Protocol, ProtocolId, UpdateProtocolModel } from "./protocol.model";
+export declare abstract class ProtocolService {
+    static findMany(query: GetProtocolsQueryModel): Promise<Protocol["model"][]>;
+    static countMany(query: GetProtocolsQueryModel): Promise<number>;
+    static getFromId(id: ProtocolId | string): Promise<Protocol["model"] | null>;
+    static getFromName(name: string): Promise<Protocol["model"] | null>;
+    static create(data: CreateProtocolModel): Promise<{
+        id: string;
+        name: string;
+        url: string;
+        description: string;
+        tags: string[];
+        icon: string;
+    }>;
+    static update(id: string, data: UpdateProtocolModel): Promise<{
+        id: string;
+        name: string;
+        url: string;
+        description: string;
+        tags: string[];
+        icon: string;
+    }>;
+    static changeLogoUrls(): Promise<void>;
+}

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

@@ -0,0 +1,62 @@
+import { ChainService } from "@/modules/v4/chain/chain.service";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { log } from "@/utils/logger";
+import { ProtocolRepository } from "./protocol.repository";
+// ─── Protocols Services ──────────────────────────────────────────────────────
+export class ProtocolService {
+    static async findMany(query) {
+        const protocols = await ProtocolRepository.findMany(query);
+        const enrichedProtocols = protocols.map(({ MainOpportunities, ...protocol }) => ({
+            ...protocol,
+            dailyRewards: MainOpportunities.reduce((sum, opportunity) => sum + opportunity.dailyRewards, 0),
+            numberOfLiveCampaigns: MainOpportunities.reduce((sum, opportunity) => sum + opportunity.Campaigns.length, 0),
+            opportunityLiveTags: [...new Set(MainOpportunities.flatMap(opportunity => opportunity.action))], // ensure uniqness of tags
+        }));
+        return enrichedProtocols;
+    }
+    static async countMany(query) {
+        return ProtocolRepository.countMany(query);
+    }
+    static async getFromId(id) {
+        return ProtocolRepository.read(id);
+    }
+    // Todo : Should be a findfirst by name here
+    static async getFromName(name) {
+        return (await ProtocolRepository.findManyByName(name))[0];
+    }
+    static async create(data) {
+        return await ProtocolRepository.create(data);
+    }
+    static async update(id, data) {
+        // let iconUri = data.icon;
+        // if (data.iconFile) {
+        //   iconUri = await BucketService.upload("merkl-assets", `/protocols/${id}`, data.iconFile.stream(), true);
+        // }
+        return await ProtocolRepository.update(id, data);
+    }
+    static async changeLogoUrls() {
+        const oldUrl = "https://storage.googleapis.com/merkl-assets/";
+        const newUrl = "https://raw.githubusercontent.com/AngleProtocol/angle-token-list/main/src/assets/";
+        const protocols = await ProtocolService.findMany({ items: 10_000 });
+        for (const protocol of protocols) {
+            if (protocol.icon.includes(oldUrl)) {
+                await ProtocolService.update(protocol.id, { icon: protocol.icon.replace(oldUrl, newUrl) });
+                log.info(`Updated protocol ${protocol.id} icon`);
+            }
+        }
+        const chains = await ChainService.findMany({});
+        for (const chain of chains) {
+            if (chain.icon.includes(oldUrl)) {
+                await ChainService.update(chain.id, { icon: chain.icon.replace(oldUrl, newUrl) });
+                log.info(`Updated chain ${chain.id} icon`);
+            }
+        }
+        const tokens = await TokenService.findMany({});
+        for (const token of tokens) {
+            if (token.icon.includes(oldUrl)) {
+                await TokenService.update(token.id, { icon: token.icon.replace(oldUrl, newUrl) });
+                log.info(`Updated token ${token.id} icon`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,82 @@
+import Elysia from "elysia";
+export declare const ReferralController: Elysia<"/referral", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    referral: {
+        code: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    address: string;
+                    chainId: number;
+                    referralKey: string;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        code: string;
+                        referrer: boolean;
+                        referredUsers: never[];
+                        transaction: {
+                            to: string;
+                            data: `0x${string}`;
+                        };
+                    } | {
+                        code: any;
+                        referrer: boolean;
+                        referredUsers: any;
+                        transaction?: undefined;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    referral: {
+        redeem: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    code: string;
+                    chainId: number;
+                    referralKey: string;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        code: string;
+                        referrer: any;
+                        transaction?: undefined;
+                    } | {
+                        code: string;
+                        referrer: any;
+                        transaction: {
+                            to: string;
+                            data: `0x${string}`;
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,25 @@
+import { throwOnUnsupportedChainId } from "@/utils/throw";
+import Elysia from "elysia";
+import { ReferralCodeDto, ReferralRedeemCodeDto } from "./referral.model";
+import { ReferralService } from "./referral.service";
+// ─── Rewards Controller ──────────────────────────────────────────────────────
+export const ReferralController = new Elysia({ prefix: "/referral", detail: { tags: ["Referral"] } })
+    // ─── Get Reward Breakdowns For Campaign Ids ──────────────────────────
+    .get("/code", async ({ query: { chainId, referralKey, address } }) => await ReferralService.getCodeOrTransaction(chainId, referralKey, address), {
+    query: ReferralCodeDto,
+    beforeHandle: ({ query: { chainId } }) => {
+        throwOnUnsupportedChainId(chainId);
+    },
+    detail: {
+        description: "Returns the transaction to register user as a referrer on-chain and some additional state",
+    },
+})
+    .get("/redeem", async ({ query: { chainId, referralKey, code } }) => await ReferralService.getReferralTransaction(chainId, referralKey, code), {
+    query: ReferralRedeemCodeDto,
+    beforeHandle: ({ query: { chainId } }) => {
+        throwOnUnsupportedChainId(chainId);
+    },
+    detail: {
+        description: "Returns the transaction to redeem a referral code on-chain and some additional state",
+    },
+});

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

@@ -0,0 +1,10 @@
+export declare const ReferralCodeDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    referralKey: import("@sinclair/typebox").TString;
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare const ReferralRedeemCodeDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    referralKey: import("@sinclair/typebox").TString;
+    code: import("@sinclair/typebox").TString;
+}>;

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

@@ -0,0 +1,12 @@
+import { t } from "elysia";
+// ─── DTOs ────────────────────────────────────────────────────────────────────
+export const ReferralCodeDto = t.Object({
+    chainId: t.Number(),
+    referralKey: t.String(),
+    address: t.String(),
+});
+export const ReferralRedeemCodeDto = t.Object({
+    chainId: t.Number(),
+    referralKey: t.String(),
+    code: t.String(),
+});

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

@@ -0,0 +1,216 @@
+export declare abstract class ReferralService {
+    #private;
+    static abi: readonly [{
+        readonly name: "getReferralKeys";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "string[]";
+        }];
+    }, {
+        readonly name: "getReferrerStatus";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }, {
+            readonly type: "address";
+            readonly name: "user";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bytes32";
+        }];
+    }, {
+        readonly name: "referrerCodeMapping";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }, {
+            readonly type: "address";
+            readonly name: "user";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "string";
+        }];
+    }, {
+        readonly name: "codeToReferrer";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }, {
+            readonly type: "string";
+            readonly name: "user";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "address";
+        }];
+    }, {
+        readonly name: "getReferrer";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }, {
+            readonly type: "address";
+            readonly name: "user";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "address";
+        }];
+    }, {
+        readonly name: "getReferredUsers";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }, {
+            readonly type: "address";
+            readonly name: "user";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "address[]";
+        }];
+    }, {
+        readonly name: "acknowledgeReferrerByKey";
+        readonly type: "function";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }, {
+            readonly type: "string";
+            readonly name: "referrerCode";
+        }];
+        readonly outputs: readonly [];
+    }, {
+        readonly name: "getCostOfReferral";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "getPaymentToken";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "address";
+        }];
+    }, {
+        readonly name: "getReferrerStatusByKey";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }, {
+            readonly type: "address";
+            readonly name: "referrer";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "uint8";
+        }];
+    }, {
+        readonly name: "requiresAuthorization";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }, {
+        readonly name: "requiresRefererToBeSet";
+        readonly type: "function";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }, {
+        readonly name: "becomeReferrer";
+        readonly type: "function";
+        readonly stateMutability: "payable";
+        readonly inputs: readonly [{
+            readonly type: "string";
+            readonly name: "key";
+        }, {
+            readonly type: "string";
+            readonly name: "referrerCode";
+        }];
+        readonly outputs: readonly [];
+    }];
+    static getReferralContract(chainId: number): "0xF39CC381B91f36238c77f42B9fF4D45376F80E5b" | undefined;
+    static isKeyAvailable(key: string, chainId: number): Promise<any>;
+    static getReferredUsers(chainId: number, key: string, address: string): Promise<any>;
+    static getReferralStatus(chainId: number, key: string, address: string): Promise<boolean>;
+    static generateCode(chainId: number, key: string, address: string): string;
+    static getCode(chainId: number, key: string, address: string): Promise<any>;
+    /**
+     * Get state & transaction for creating a referral code
+     * @param chainId of the referral contract
+     * @param key of referral
+     * @param address of the creator
+     */
+    static getCodeOrTransaction(chainId: number, key: string, address: string): Promise<{
+        code: string;
+        referrer: boolean;
+        referredUsers: never[];
+        transaction: {
+            to: string;
+            data: `0x${string}`;
+        };
+    } | {
+        code: any;
+        referrer: boolean;
+        referredUsers: any;
+        transaction?: undefined;
+    }>;
+    /**
+     * Checks if code exists in the contracts
+     * @param chainId of the referral contract
+     * @param key of referral
+     * @param code user referral code
+     * @returns referrerAddress if code exitst
+     */
+    static isCodeRegistered(chainId: number, key: string, code: string): Promise<any>;
+    /**
+     * Get state & transaction for redeeming a referral code
+     * @param chainId of the referral contract
+     * @param key of referral
+     * @param code user referral code
+     */
+    static getReferralTransaction(chainId: number, key: string, code: string): Promise<{
+        code: string;
+        referrer: any;
+        transaction?: undefined;
+    } | {
+        code: string;
+        referrer: any;
+        transaction: {
+            to: string;
+            data: `0x${string}`;
+        };
+    }>;
+}