@merkl/api 0.21.46 → 1.0.0

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

@@ -1,240 +0,0 @@
-import { CampaignTypeConfigResourceMapping, ChainId, NULL_ADDRESS, NULL_ROOT, buildCampaignPayload, encodeForwarderData, parseCampaign, registry, } from "@sdk";
-import _ from "lodash";
-import { TokenService } from "../token/token.service";
-import { safeTemplate, } from "./programPayload.model";
-import { MerklInterfaceCampaigns } from "./programPayload.repository";
-export class ProgramPayloadService {
-    // ─── ProgramPayload ──────────────────────────────────────────────────────────
-    static buildConfigTemplate(params) {
-        class CampaignConfig extends CampaignTypeConfigResourceMapping[params.campaignType] {
-        }
-        const parsedConfig = new CampaignConfig();
-        const configTemplate = {};
-        for (const [key, value] of Object.entries(parsedConfig)) {
-            configTemplate[key] = typeof value;
-        }
-        return configTemplate;
-    }
-    static buildConfig(query) {
-        const campaign = query.campaign;
-        const startTimestamp = query.startTimestamp;
-        const endTimestamp = query.endTimestamp;
-        const rewardToken = query.rewardToken;
-        const creator = query.creator;
-        const amount = query.amount;
-        const program = query.program;
-        const apr = query.apr;
-        if (!(program in MerklInterfaceCampaigns)) {
-            throw new Error(`Program ${program} not found`);
-        }
-        const programInterface = MerklInterfaceCampaigns[program];
-        if (!(campaign in programInterface)) {
-            throw new Error(`Campaign ${campaign} not found`);
-        }
-        const config = programInterface[campaign];
-        if (apr && "apr" in config) {
-            // override the apr if in query params
-            config.apr = apr;
-        }
-        return {
-            ...config,
-            amount: amount,
-            startTimestamp,
-            endTimestamp,
-            rewardToken,
-            creator,
-            forwarders: "forwarders" in config
-                ? config.forwarders.map(forwarder => typeof forwarder === "string" ? forwarder : encodeForwarderData(forwarder))
-                : [],
-        };
-    }
-    /** building payload for a single campaign */
-    static buildCampaignData(query) {
-        const distributionChainId = query.distributionChainId ? query.distributionChainId : ChainId.MAINNET;
-        const args = buildCampaignPayload(ProgramPayloadService.buildConfig(query), distributionChainId).args;
-        return { args };
-    }
-    static async buildPayloadFromConfig(config, debug = false) {
-        const campaignType = config.campaignType;
-        const rewardToken = config.rewardToken;
-        class CampaignConfig extends CampaignTypeConfigResourceMapping[campaignType] {
-        }
-        const parsedConfig = CampaignConfig.hydrate(config, {
-            strategy: "exposeAll",
-            excludeExtraneousValues: true,
-        });
-        parsedConfig.hooks = config.hooks?.map(hook => hook) ?? [];
-        const nonEncodedConfig = { ...parsedConfig };
-        if ("forwarders" in parsedConfig) {
-            parsedConfig.forwarders = config?.forwarders
-                ? config.forwarders.map(forwarder => typeof forwarder === "string" ? forwarder : encodeForwarderData(forwarder))
-                : [];
-        }
-        const distributionChainId = config.distributionChainId ? config.distributionChainId : ChainId.MAINNET;
-        const registryInitialized = registry(distributionChainId);
-        const distributionCreator = registryInitialized?.Merkl?.DistributionCreator ?? NULL_ADDRESS;
-        // Small hack to avoid the need to parse the config again
-        const args = buildCampaignPayload(parsedConfig, distributionChainId).args;
-        const safePayload = ProgramPayloadService.initiateSafePayload(distributionChainId, distributionCreator, rewardToken);
-        const tokenAmount = BigInt(args?.amount.toString());
-        const numberOfHours = BigInt(args?.duration.toString()) / 3600n;
-        if (!(await ProgramPayloadService.checkMinimumAmount(rewardToken, tokenAmount, numberOfHours, distributionChainId))) {
-            throw new Error("Amount is less than minimum");
-        }
-        const transactions = await ProgramPayloadService.createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator ?? NULL_ADDRESS);
-        safePayload.transactions.push(...transactions);
-        if (debug) {
-            return { safePayload, nonEncodedConfig };
-        }
-        return safePayload;
-    }
-    static async checkMinimumAmount(rewardToken, tokenAmount, numberOfHours, distributionChainId) {
-        const minimumAmountPerHour = await ProgramPayloadService.getMinimumAmount(rewardToken, distributionChainId);
-        if (!minimumAmountPerHour) {
-            throw new Error("Token not found");
-        }
-        return tokenAmount / numberOfHours >= BigInt(minimumAmountPerHour);
-    }
-    static async getMinimumAmount(rewardToken, distributionChainId) {
-        const tokenList = await TokenService.getValidRewardTokens(distributionChainId);
-        const minimumAmountPerHour = tokenList.find(token => token.address.toLowerCase() === rewardToken.toLowerCase())?.minimumAmountPerHour;
-        if (!minimumAmountPerHour) {
-            throw new Error("Token not found");
-        }
-        return BigInt(minimumAmountPerHour);
-    }
-    static async createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator, withApproval = true) {
-        const safePayload = _.cloneDeep(safeTemplate);
-        safePayload.chainId = distributionChainId.toString();
-        safePayload.createdAt = Math.floor(Date.now() / 1000);
-        safePayload.transactions[0].to = rewardToken;
-        safePayload.transactions[0].contractInputsValues = {
-            amount: args?.amount.toString(),
-            spender: distributionCreator ? distributionCreator : NULL_ADDRESS,
-        };
-        safePayload.transactions[2].to = distributionCreator ? distributionCreator : NULL_ADDRESS;
-        safePayload.transactions[2].contractInputsValues = {
-            newCampaign: JSON.stringify([
-                NULL_ROOT,
-                NULL_ADDRESS,
-                args?.rewardToken,
-                args?.amount,
-                args?.campaignType,
-                args?.startTimestamp,
-                args?.duration,
-                args?.campaignData,
-            ]),
-        };
-        if (withApproval) {
-            return [safePayload.transactions[0], safePayload.transactions[2]];
-        }
-        return [safePayload.transactions[2]];
-    }
-    static initiateSafePayload(distributionChainId, distributionCreator, rewardToken, approvalAmount = "0") {
-        const safePayload = _.cloneDeep(safeTemplate);
-        safePayload.chainId = distributionChainId.toString();
-        safePayload.createdAt = Math.floor(Date.now() / 1000);
-        safePayload.transactions[1].to = distributionCreator;
-        if (approvalAmount !== "0") {
-            safePayload.transactions[0].to = rewardToken;
-            safePayload.transactions[0].contractInputsValues = {
-                amount: approvalAmount,
-                spender: distributionCreator,
-            };
-            safePayload.transactions = [safePayload.transactions[1], safePayload.transactions[0]];
-        }
-        else
-            safePayload.transactions = [safePayload.transactions[1]];
-        const wrapperContract = "0x8A5A5DE9db5770123Ff2145F59e9F20047f0A8EC";
-        if (rewardToken === wrapperContract && approvalAmount !== "0") {
-            const secondarySafePayload = _.cloneDeep(safeTemplate);
-            const underlying = "0x282A69142bac47855C3fbE1693FcC4bA3B4d5Ed6";
-            secondarySafePayload.transactions[0].to = underlying;
-            secondarySafePayload.transactions[0].contractInputsValues = {
-                amount: approvalAmount,
-                spender: wrapperContract,
-            };
-            safePayload.transactions.push(secondarySafePayload.transactions[0]);
-        }
-        return safePayload;
-    }
-    static async buildPayload(query, initialCampaignPayload = null, totalAmount = "0") {
-        const withApproval = Boolean(totalAmount === "0");
-        const rewardToken = query.rewardToken;
-        const distributionChainId = query.distributionChainId ? query.distributionChainId : ChainId.MAINNET;
-        const registryInitialized = registry(distributionChainId);
-        const distributionCreator = registryInitialized?.Merkl?.DistributionCreator ?? NULL_ADDRESS;
-        async function generatePayloadFile(query, withApproval = true) {
-            const args = buildCampaignPayload(ProgramPayloadService.buildConfig(query), distributionChainId).args;
-            const safePayload = await ProgramPayloadService.createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator, withApproval);
-            return safePayload;
-        }
-        const campaignPayloads = initialCampaignPayload === null
-            ? ProgramPayloadService.initiateSafePayload(distributionChainId, distributionCreator, rewardToken, totalAmount)
-            : initialCampaignPayload;
-        const transactions = await generatePayloadFile(query, withApproval);
-        campaignPayloads.transactions.push(...transactions);
-        return campaignPayloads;
-    }
-    static async buildProgramPayload(query) {
-        let campaignPayloads = null;
-        query.amount = query.amount ? query.amount : "0";
-        for (const campaign of Object.keys(MerklInterfaceCampaigns[query.program])) {
-            const queryCampaign = {
-                ...query,
-                campaign,
-                amount: query.amount,
-            };
-            campaignPayloads = await ProgramPayloadService.buildPayload(queryCampaign, campaignPayloads);
-        }
-        return campaignPayloads;
-    }
-    static async buildProgramPayloadWithAmounts(query, body) {
-        let campaignPayloads = null;
-        const totalAmount = Object.values(body).reduce((sum, amount) => sum + BigInt(amount), 0n);
-        const minimumAmountPerHour = await ProgramPayloadService.getMinimumAmount(query.rewardToken, query.distributionChainId);
-        const numberOfHours = (BigInt(query.endTimestamp) - BigInt(query.startTimestamp)) / 3600n;
-        if (numberOfHours < 1n) {
-            throw new Error("Duration is less than 1 hour");
-        }
-        if (!minimumAmountPerHour) {
-            throw new Error("Token not found");
-        }
-        for (const [campaign, amount] of Object.entries(body)) {
-            if (Object.keys(MerklInterfaceCampaigns[query.program]).includes(campaign)) {
-                const queryCampaign = { ...query, campaign, amount: amount };
-                if (BigInt(amount) / numberOfHours < BigInt(minimumAmountPerHour))
-                    throw new Error("Amount is less than minimum");
-                campaignPayloads = await ProgramPayloadService.buildPayload(queryCampaign, campaignPayloads, totalAmount.toString());
-            }
-            else {
-                throw new Error(`Campaign ${campaign} not found`);
-            }
-        }
-        return campaignPayloads;
-    }
-    static async buildConfigFromCampaignData(body) {
-        const base = {
-            campaignId: "0xdefaultId",
-            creator: "Oxcreator",
-            rewardToken: body.rewardToken,
-            amount: body.amount,
-            campaignType: body.campaignType,
-            startTimestamp: body.startTimestamp,
-            duration: body.duration,
-            campaignData: body.campaignData,
-        };
-        try {
-            console.log("Parsing campaign data");
-            const res = await parseCampaign(body.chainId, base, 0);
-            if (res.success) {
-                return res;
-            }
-            throw res.message;
-        }
-        catch (e) {
-            console.error(e);
-            throw e;
-        }
-    }
-}

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

@@ -1,42 +0,0 @@
-import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
-import Elysia, { t } from "elysia";
-import { CreateProtocolDto, GetProtocolsQueryDto, NotionWebhookAddProtocolDto, ProtocolIdDto, ProtocolResourceDto, UpdateProtocolDto, } from "./protocol.model";
-import { ProtocolService } from "./protocol.service";
-// ─── Protocols Controller ────────────────────────────────────────────────────
-export const ProtocolController = new Elysia({ prefix: "/protocols", detail: { tags: ["Protocols"] } })
-    // ─── Get Many Protocols ──────────────────────────────────────────────
-    .get("/", async ({ query }) => await ProtocolService.findMany(query), {
-    query: GetProtocolsQueryDto,
-    response: t.Array(ProtocolResourceDto),
-    detail: { description: "List protocols supported and integrated by Merkl." },
-})
-    // ─── Count Protocols ─────────────────────────────────────────────────
-    .get("/count", async ({ query }) => await ProtocolService.countMany(query), {
-    query: GetProtocolsQueryDto,
-    detail: { description: "Get the number of protocols corresponding to the query." },
-})
-    // ─── Get A Protocol By Its Id Or Name ────────────────────────────────
-    .get("/:id", async ({ params }) => {
-    const fromId = await ProtocolService.findUnique(params.id);
-    if (fromId)
-        return fromId;
-    return (await ProtocolService.findMany({ name: params.id }))?.[0];
-})
-    .guard({ detail: { hide: true }, headers: AuthorizationHeadersDto, beforeHandle: BackOfficeGuard })
-    // ─── Update A Protocol ───────────────────────────────────────────────
-    .patch("/:id", async ({ params, body }) => await ProtocolService.update(params.id, body), {
-    params: ProtocolIdDto,
-    body: UpdateProtocolDto,
-})
-    // ─── Create A Protocol ───────────────────────────────────────────────
-    .post("/", async ({ body }) => await ProtocolService.create(body), { body: CreateProtocolDto })
-    .group("/webhooks", app => app.post("/notion", async ({ body }) => ProtocolService.upsert({
-    id: body.data.properties.id.title[0].text.content,
-    description: body.data.properties.description.rich_text[0].text.content,
-    icon: "file" in body.data.properties.icon.files[0]
-        ? body.data.properties.icon.files[0].file.url
-        : body.data.properties.icon.files[0].external.url,
-    name: body.data.properties.name.rich_text[0].text.content,
-    tags: body.data.properties.tags.rich_text[0]?.text.content.split(","),
-    url: body.data.properties.url.url,
-}), { body: NotionWebhookAddProtocolDto }));

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

@@ -1,186 +0,0 @@
-import { t } from "elysia";
-export const protocolIdList = [
-    // ─── DEX ─────────────────────────────────────────────────────────────
-    "uniswap",
-    "ambient",
-    "arthswap",
-    "base-swap",
-    "camelot",
-    "crust",
-    "fenix",
-    "horiza",
-    "izumi",
-    "kim",
-    "pancake-swap",
-    "quickswap",
-    "ramses",
-    "retro",
-    "stryke",
-    "sushi-swap",
-    "swapr",
-    "thruster",
-    "voltage",
-    "zero",
-    "koi",
-    "supswap",
-    "zk-swap",
-    "thirdtrade",
-    "swap-x",
-    "velodrome",
-    "aerodrome",
-    "balancer",
-    "curve",
-    "cross_curve",
-    "curveNPool",
-    "aura",
-    "akron",
-    "beefy",
-    "dragonswap",
-    "poolside",
-    "koi",
-    "syncswap",
-    "neptune",
-    "zkSwapThreePool",
-    "syncswap",
-    "rfx",
-    "ra",
-    "maverick",
-    "trader-joe",
-    "velodrome",
-    "hanji",
-    "reserve",
-    "pinto",
-    // ─── Lending ──────────────────────────────────────────────────────
-    "radiant",
-    "aave",
-    "fraxlend",
-    "ironclad",
-    "euler",
-    "gearbox",
-    "compound",
-    "sturdy",
-    "frax",
-    "ionic",
-    "moonwell",
-    "fluid",
-    "silo",
-    "morpho",
-    "dolomite",
-    "badger",
-    "ajna",
-    "layerbank",
-    "ion",
-    "venus",
-    "woofi",
-    "reactor_fusion",
-    "eigenlayer",
-    "vest",
-    "zerolend",
-    "lnd",
-    "dlend",
-    "hyperdrive",
-    "gamma",
-    "oku",
-    "hourglass",
-    "veda",
-    "kyo",
-    "sonex",
-    "lendle",
-    "tako-tako",
-    "equalizer",
-    "spectra",
-    "beraborrow",
-    "superlend",
-    "avalon",
-    "iguana",
-    "xlend",
-    "sake",
-    "sonicmarket",
-    "stability",
-    "hypurrfi",
-    // ─── Staking ──────────────────────────────────────────────────────
-    "angles",
-    // ─── Yield Aggregator ──────────────────────────────────────────────
-    "enzyme",
-    "toros",
-    "vicuna",
-    "bunni",
-    "beratrax",
-    "concrete",
-    "cian",
-    // ─── Fixed Yield ──────────────────────────────────────────────
-    "pendle",
-    "splice",
-    "sturdy",
-    "yei",
-    "termmax",
-    // ─── Option Trading ────────────────────────────────────────────────
-    "filament",
-    "gammaswap",
-    // ─── Synthetic Assets ────────────────────────────────────────────────
-    "maha",
-    "tempest",
-    "uranium",
-    "hanji",
-    // ─── Others ──────────────────────────────────────────────────────
-    "holdstation",
-    "katana",
-    "punchswap",
-    "satlayer",
-    "puffer",
-];
-// ─── DTOs ────────────────────────────────────────────────────────────────────
-export const ProtocolResourceDto = t.Object({
-    id: t.String(),
-    name: t.String(),
-    icon: t.String(),
-    tags: t.Array(t.String()),
-    description: t.String(),
-    url: t.String(),
-});
-export const GetProtocolsQueryDto = t.Object({
-    id: t.Optional(t.String({ description: "Filter results by name. Useful for searching a protocol to verify its integration" })),
-    test: t.Optional(t.Boolean({ description: "Includes protocols that have only test opportunities", default: false })),
-    ids: t.Optional(t.Array(t.String())),
-    name: t.Optional(t.String({ description: "Search protocols by name" })),
-    tags: t.Optional(t.Array(t.String())),
-    opportunityTag: t.Optional(t.String({ description: "Filter by underlying opportunities' tag" })),
-    page: t.Optional(t.Numeric({ description: "0-indexed page number", default: 0 })),
-    items: t.Optional(t.Numeric({ description: "Number of items returned by page", default: 20 })), // items per page
-});
-export const GetProtocolParamsDto = t.Object({ id: t.String() });
-export const UpdateProtocolDto = t.Object({
-    icon: t.Optional(t.String({ format: "uri" })),
-    url: t.Optional(t.String({ format: "uri" })),
-    description: t.Optional(t.String()),
-    name: t.Optional(t.String()),
-    // iconFile: t.Optional(t.File()),
-});
-export const CreateProtocolDto = t.Object({
-    icon: t.String({ format: "uri" }),
-    url: t.String({ format: "uri" }),
-    description: t.String(),
-    id: t.String(),
-    name: t.String(),
-    tags: t.Array(t.String()),
-});
-export const ProtocolIdDto = t.Object({ id: t.String() });
-export const NotionWebhookAddProtocolDto = t.Object({
-    data: t.Object({
-        properties: t.Object({
-            id: t.Object({
-                title: t.Array(t.Object({ text: t.Object({ content: t.String() }) })),
-            }),
-            description: t.Object({ rich_text: t.Array(t.Object({ text: t.Object({ content: t.String() }) })) }),
-            icon: t.Object({
-                files: t.Array(t.Union([
-                    t.Object({ name: t.String(), file: t.Object({ url: t.String() }) }),
-                    t.Object({ external: t.Object({ url: t.String() }) }),
-                ])),
-            }),
-            name: t.Object({ rich_text: t.Array(t.Object({ text: t.Object({ content: t.String() }) })) }),
-            tags: t.Object({ rich_text: t.Array(t.Object({ text: t.Object({ content: t.String() }) })) }),
-            url: t.Object({ url: t.String() }),
-        }),
-    }),
-}, { additionalProperties: true });

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

@@ -1,175 +0,0 @@
-import { log } from "@/utils/logger";
-import { apiDbClient } from "@db";
-// ─── Protocols Repository ────────────────────────────────────────────────────
-export class ProtocolRepository {
-    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 } },
-                    ]
-                    : !query.test
-                        ? [
-                            { MainOpportunities: { some: { Campaigns: { some: { RewardToken: { isTest: false } } } } } },
-                            { Opportunities: { some: { Campaigns: { some: { RewardToken: { isTest: false } } } } } },
-                        ]
-                        : undefined,
-                // id: typeof query.id === "string" ? query.id : !!query.id ? { in: query.id } : undefined,
-            },
-        };
-    }
-    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 upsert(data) {
-        return await apiDbClient.protocol.upsert({
-            where: { id: data.id },
-            create: {
-                id: data.id,
-                name: data.name,
-                icon: data.icon,
-                url: data.url,
-                description: data.description,
-                tags: data.tags,
-            },
-            update: {
-                name: data.name,
-                icon: data.icon,
-                url: data.url,
-                description: data.description,
-                tags: data.tags,
-            },
-        });
-    }
-    static async changeId(oldId, newId) {
-        if (!(await ProtocolRepository.findMany({ id: newId }))[0]) {
-            await apiDbClient.protocol.create({
-                data: {
-                    id: newId,
-                    name: newId,
-                    icon: "",
-                    url: "",
-                    description: "",
-                    tags: [],
-                },
-            });
-        }
-        await apiDbClient.opportunity.updateMany({
-            where: {
-                mainProtocolId: oldId,
-            },
-            data: {
-                mainProtocolId: newId,
-            },
-        });
-        await apiDbClient.rewardBreakdown.updateMany({
-            where: {
-                protocolId: oldId,
-            },
-            data: {
-                protocolId: newId,
-            },
-        });
-        const opportunities = await apiDbClient.opportunity.findMany({
-            where: {
-                Protocols: {
-                    some: {
-                        id: oldId,
-                    },
-                },
-            },
-        });
-        for (const opportunity of opportunities) {
-            await apiDbClient.opportunity.update({
-                where: {
-                    id: opportunity.id,
-                },
-                data: {
-                    Protocols: {
-                        disconnect: [
-                            {
-                                id: oldId,
-                            },
-                        ],
-                        connect: [
-                            {
-                                id: newId,
-                            },
-                        ],
-                    },
-                },
-            });
-        }
-        try {
-            await apiDbClient.protocol.delete({
-                where: {
-                    id: oldId,
-                },
-            });
-            log.info(`protocol with id ${oldId} deleted`);
-        }
-        catch {
-            log.warn(`protocol with id ${oldId} not found`);
-        }
-    }
-    static async findUnique(type) {
-        return await apiDbClient.protocol.findUnique({ where: { id: type } });
-    }
-    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 });
-    }
-}