@merkl/api 0.10.362 → 0.10.378

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

@@ -1,13 +1,16 @@
 import type { GetCampaignComputedValueModel, GetUserComputedValuesModel, UpsertCampaignComputedValueModel, UpsertUserComputedValuesModel } from "./computedValue.model";
 export declare class ComputedValueService {
     static findCampaignValue(params: GetCampaignComputedValueModel): Promise<{
-        [x: string]: never;
-        [x: number]: never;
+        averageBoost: number | null;
+        totalDistributedInUSD: number | null;
+        forfeitingBoost: number | null;
     } | null>;
     static upsertCampaignComputedValue(data: UpsertCampaignComputedValueModel): Promise<void>;
     static findUserValues(params: GetUserComputedValuesModel): Promise<{
-        [x: string]: never;
-        [x: number]: never;
+        reason: string;
+        id: number;
+        campaignId: string;
+        boost: number | null;
     }[]>;
     static upsertUserComputedValues(data: UpsertUserComputedValuesModel): Promise<void>;
 }

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

@@ -1,6 +1,15 @@
+import { log } from "../../../utils/logger";
+import { CampaignService } from "../campaign";
 import { ComputedValueRepository } from "./computedValue.repository";
 export class ComputedValueService {
     static async findCampaignValue(params) {
+        if (params.campaignId.includes("-") && params.campaignId.startsWith("0x")) {
+            const [campaignId, distributionChain] = params.campaignId.split("-");
+            params.campaignId = CampaignService.hashId({ campaignId, distributionChain: Number.parseInt(distributionChain) });
+        }
+        else if (params.campaignId.startsWith("0x")) {
+            params.campaignId = (await CampaignService.findMany({ campaignId: params.campaignId }))[0].id;
+        }
         return await ComputedValueRepository.findCampaignValue(params);
     }
     static async upsertCampaignComputedValue(data) {
@@ -11,5 +20,6 @@ export class ComputedValueService {
     }
     static async upsertUserComputedValues(data) {
         await ComputedValueRepository.upsertUserComputedValues(data);
+        log.info(`Upserted ${data.length} users computed values`);
     }
 }

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

@@ -0,0 +1,118 @@
+import { Elysia } from "elysia";
+export declare const CreatorController: Elysia<"/creators", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    creators: {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    items?: number | undefined;
+                    page?: number | undefined;
+                    address?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: ({
+                        name: string;
+                        id: string;
+                        addresses: string[];
+                    } & {
+                        icon?: string | undefined;
+                    })[];
+                };
+            };
+        };
+    };
+} & {
+    creators: {
+        ":id": {
+            get: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        name: string;
+                        id: string;
+                        addresses: string[];
+                        icon?: string | undefined;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    creators: {
+        index: {
+            post: {
+                body: {
+                    icon?: string | undefined;
+                    name: string;
+                    id: string;
+                    addresses: string[];
+                };
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        name: string;
+                        id: string;
+                        icon: string | null;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    creators: {
+        ":id": {
+            patch: {
+                body: {
+                    icon?: string | undefined;
+                    name: string;
+                    addresses: string[];
+                };
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        name: string;
+                        id: string;
+                        icon: string | null;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,30 @@
+import { NotFoundError } from "../../../errors";
+import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
+import { Elysia } from "elysia";
+import { CreatorDto, GetManyCreatorQuery, UpdateCreatorDto } from "./creator.model";
+import { CreatorService } from "./creator.service";
+// ─── Creators Controller ────────────────────────────────────────────────────────
+export const CreatorController = new Elysia({ prefix: "/creators", detail: { tags: ["Creator"] } })
+    // ─── Get Many Creators ──────────────────────────────────────────────────
+    .get("/", async ({ query }) => (await CreatorService.findMany(query)).map(CreatorService.format), {
+    query: GetManyCreatorQuery,
+})
+    // ─── Get A Creator By Id ───────────────────────────────────────────
+    .get("/:id", async ({ params: { id } }) => {
+    const creator = await CreatorService.findUnique(id);
+    if (!creator)
+        throw new NotFoundError();
+    return CreatorService.format(creator);
+})
+    // ─── Create A Creator ───────────────────────────────────────────────────
+    .post("/", async ({ body }) => await CreatorService.create(body), {
+    headers: AuthorizationHeadersDto,
+    body: CreatorDto,
+    beforeHandle: BackOfficeGuard,
+})
+    // ─── Update Creator's Addresses ──────────────────────────────────────────────
+    .patch("/:id", async ({ params: { id }, body }) => CreatorService.update(id, body), {
+    headers: AuthorizationHeadersDto,
+    body: UpdateCreatorDto,
+    beforeHandle: BackOfficeGuard,
+});

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

@@ -0,0 +1,29 @@
+import type { Resource } from "../prisma";
+/**
+ * Campaign Creator (Client)
+ * @description A group of user that represent a campaign creator
+ * @see {@link Resource}
+ */
+export type Creator = Resource<"Creator", "icon", {
+    icon?: string;
+    addresses: string[];
+}>;
+export declare const CreatorDto: import("@sinclair/typebox").TObject<{
+    addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    id: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+}>;
+export declare const GetManyCreatorQuery: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const UpdateCreatorDto: import("@sinclair/typebox").TObject<{
+    addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    name: import("@sinclair/typebox").TString;
+}>;
+export type CreatorModel = typeof CreatorDto.static;
+export type GetManyCreatorModel = typeof GetManyCreatorQuery.static;
+export type UpdateCreatorDto = typeof UpdateCreatorDto.static;

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

@@ -0,0 +1,18 @@
+import { t } from "elysia";
+// ─── Dtos ────────────────────────────────────────────────────────────────────
+export const CreatorDto = t.Object({
+    addresses: t.Array(t.String()),
+    icon: t.Optional(t.String()),
+    id: t.String(),
+    name: t.String(),
+});
+export const GetManyCreatorQuery = t.Object({
+    address: t.Optional(t.String()),
+    page: t.Optional(t.Number()),
+    items: t.Optional(t.Number()),
+});
+export const UpdateCreatorDto = t.Object({
+    addresses: t.Array(t.String()),
+    icon: t.Optional(t.String()),
+    name: t.String(),
+});

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

@@ -0,0 +1,40 @@
+import type { Creator, GetManyCreatorModel, UpdateCreatorDto } from "./creator.model";
+export declare abstract class CreatorRepository {
+    static findUnique(id: Creator["model"]["id"]): Promise<({
+        Users: {
+            tags: string[];
+            address: string;
+            creatorId: string | null;
+        }[];
+    } & {
+        name: string;
+        id: string;
+        icon: string | null;
+    }) | null>;
+    static findUniqueFromAddress(address: string): Promise<{
+        name: string;
+        id: string;
+        icon: string | null;
+    } | null>;
+    static findMany(query: GetManyCreatorModel): Promise<({
+        Users: {
+            tags: string[];
+            address: string;
+            creatorId: string | null;
+        }[];
+    } & {
+        name: string;
+        id: string;
+        icon: string | null;
+    })[]>;
+    static create({ addresses, ...creator }: Creator["model"]): Promise<{
+        name: string;
+        id: string;
+        icon: string | null;
+    }>;
+    static update(id: Creator["model"]["id"], { addresses, ...creator }: UpdateCreatorDto): Promise<{
+        name: string;
+        id: string;
+        icon: string | null;
+    }>;
+}

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

@@ -0,0 +1,63 @@
+import { apiDbClient } from "../../../utils/prisma";
+// ─── Users Repository ────────────────────────────────────────────────────────
+export class CreatorRepository {
+    static async findUnique(id) {
+        return await apiDbClient.creator.findUnique({ where: { id }, include: { Users: true } });
+    }
+    static async findUniqueFromAddress(address) {
+        const creator = await apiDbClient.user.findUnique({ where: { address: address }, select: { Creator: true } });
+        return creator?.Creator ?? null;
+    }
+    static async findMany(query) {
+        const { page: _page, items: _items, ...filters } = query;
+        const page = _page ? _page : 0;
+        const items = _items ? _items : 20;
+        return await apiDbClient.creator.findMany({
+            take: items,
+            skip: page * items,
+            include: { Users: true },
+            where: {
+                Users: filters.address
+                    ? {
+                        some: {
+                            address: {
+                                equals: filters.address,
+                            },
+                        },
+                    }
+                    : undefined,
+            },
+        });
+    }
+    static async create({ addresses, ...creator }) {
+        return await apiDbClient.creator.create({
+            data: {
+                ...creator,
+                Users: {
+                    connectOrCreate: addresses.map(address => ({
+                        create: {
+                            address,
+                        },
+                        where: { address },
+                    })),
+                },
+            },
+        });
+    }
+    static async update(id, { addresses, ...creator }) {
+        return await apiDbClient.creator.update({
+            where: { id },
+            data: {
+                ...creator,
+                Users: {
+                    connectOrCreate: addresses.map(address => ({
+                        create: {
+                            address,
+                        },
+                        where: { address },
+                    })),
+                },
+            },
+        });
+    }
+}

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

@@ -0,0 +1,61 @@
+import type { Creator, GetManyCreatorModel, UpdateCreatorDto } from "./creator.model";
+export declare abstract class CreatorService {
+    /**
+     * Format creator into its model
+     * @param id
+     * @returns creator
+     */
+    static format({ Users, icon, ...creator }: NonNullable<Awaited<ReturnType<typeof CreatorService.findUnique>>>): Creator["model"];
+    /**
+     * Finds a creator from its id (i.e. "uniswap")
+     * @param id
+     * @returns creator
+     */
+    static findUnique(id: Creator["model"]["id"]): Promise<({
+        Users: {
+            tags: string[];
+            address: string;
+            creatorId: string | null;
+        }[];
+    } & {
+        name: string;
+        id: string;
+        icon: string | null;
+    }) | null>;
+    /**
+     * Finds many creator
+     * @param id
+     * @returns creator
+     */
+    static findMany(query: GetManyCreatorModel): Promise<({
+        Users: {
+            tags: string[];
+            address: string;
+            creatorId: string | null;
+        }[];
+    } & {
+        name: string;
+        id: string;
+        icon: string | null;
+    })[]>;
+    /**
+     * Creates a creator
+     * @param creator {addresses, id, name}
+     */
+    static create(creator: Creator["model"]): Promise<{
+        name: string;
+        id: string;
+        icon: string | null;
+    }>;
+    /**
+     * Updates data on a creator
+     * @notice will override the entire address array
+     * @param id of creator
+     * @param creator data for each field
+     */
+    static update(id: Creator["model"]["id"], creator: UpdateCreatorDto): Promise<{
+        name: string;
+        id: string;
+        icon: string | null;
+    }>;
+}

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

@@ -0,0 +1,44 @@
+import { CreatorRepository } from "./creator.repository";
+// ─── Creators Services ──────────────────────────────────────────────────────────
+export class CreatorService {
+    /**
+     * Format creator into its model
+     * @param id
+     * @returns creator
+     */
+    static format({ Users, icon, ...creator }) {
+        return { ...creator, addresses: Users.map(({ address }) => address), icon: icon ?? undefined };
+    }
+    /**
+     * Finds a creator from its id (i.e. "uniswap")
+     * @param id
+     * @returns creator
+     */
+    static async findUnique(id) {
+        return await CreatorRepository.findUnique(id);
+    }
+    /**
+     * Finds many creator
+     * @param id
+     * @returns creator
+     */
+    static async findMany(query) {
+        return await CreatorRepository.findMany(query);
+    }
+    /**
+     * Creates a creator
+     * @param creator {addresses, id, name}
+     */
+    static async create(creator) {
+        return await CreatorRepository.create(creator);
+    }
+    /**
+     * Updates data on a creator
+     * @notice will override the entire address array
+     * @param id of creator
+     * @param creator data for each field
+     */
+    static async update(id, creator) {
+        return await CreatorRepository.update(id, creator);
+    }
+}

package/dist/src/modules/v4/creator/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./creator.controller";
+export * from "./creator.model";
+export * from "./creator.service";

package/dist/src/modules/v4/creator/index.js

@@ -0,0 +1,3 @@
+export * from "./creator.controller";
+export * from "./creator.model";
+export * from "./creator.service";

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

@@ -72,8 +72,7 @@ export declare const DynamicDataController: Elysia<"/dynamic-data", false, {
                     authorization: string;
                 };
                 response: {
-                    [x: string]: any;
-                    200: any;
+                    200: any[];
                 };
             };
         };
@@ -96,6 +95,7 @@ export declare const DynamicDataController: Elysia<"/dynamic-data", false, {
                     mainParameter?: string | undefined;
                     campaignId?: string | undefined;
                     opportunityId?: string | undefined;
+                    creatorId?: string | undefined;
                     test?: boolean | undefined;
                     creatorTag?: string | undefined;
                     tokenSymbol?: string | undefined;
@@ -104,8 +104,7 @@ export declare const DynamicDataController: Elysia<"/dynamic-data", false, {
                     authorization: string;
                 };
                 response: {
-                    [x: string]: any;
-                    200: any;
+                    200: any[];
                 };
             };
         };

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

@@ -25,7 +25,7 @@ export const DynamicDataController = new Elysia({
         BackOfficeGuard({ headers });
     },
 })
-    .get("/from-existing", async ({ query }) => await DynamicDataService.queryDynamicDataFromCampaignId(query), {
+    .get("/from-existing", async ({ query }) => await DynamicDataService.queryDynamicDataFromManyCampaignId(query), {
     query: GetCampaignQueryDto,
     headers: AuthorizationHeadersDto,
     beforeHandle: ({ headers }) => {

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

@@ -97,6 +97,7 @@ export declare const FilledCampaignDto: import("@sinclair/typebox").TObject<{
     startTimestamp: import("@sinclair/typebox").TString;
     endTimestamp: import("@sinclair/typebox").TString;
     campaignParameters: import("@sinclair/typebox").TObject<{}>;
+    mainParameter: import("@sinclair/typebox").TString;
 }>;
 export type DynamicDataSourceModel = typeof DynamicDataSourceIdentifier.static;
 export type SimplifiedCampaignDtoModel = typeof SimplifiedCampaignDto.static;

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

@@ -51,4 +51,5 @@ export const FilledCampaignDto = t.Object({
     startTimestamp: t.String(),
     endTimestamp: t.String(),
     campaignParameters: t.Object({}),
+    mainParameter: t.String(),
 });

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

@@ -1,7 +1,7 @@
 import { CampaignType } from "../../../../database/api/.generated";
 import { Campaign, type ChainId } from "@sdk";
 import { type GetCampaignQueryModel } from "../campaign";
-import type { SimplifiedCampaignDtoModel } from "./dynamicData.model";
+import type { FilledCampaignDtoModel, SimplifiedCampaignDtoModel } from "./dynamicData.model";
 type output = {
     tvl: number;
     totalSupply: number;
@@ -14,8 +14,11 @@ export declare class DynamicDataService {
     #private;
     /** Fetches a single price */
     static queryERC20DynamicData(chainId: ChainId, tokenAddress: string, decimals?: number): Promise<output>;
-    static queryDynamicData(campaign: SimplifiedCampaignDtoModel): Promise<any>;
-    static queryDynamicDataFromCampaignId(query: GetCampaignQueryModel): Promise<any>;
+    static generateDummyData(campaign: SimplifiedCampaignDtoModel): FilledCampaignDtoModel;
+    static generateMainParameter(campaign: SimplifiedCampaignDtoModel): string;
+    static queryDynamicData(campaign: SimplifiedCampaignDtoModel): Promise<any[]>;
+    static queryDynamicDataFromCampaignId(query: GetCampaignQueryModel): Promise<any[]>;
+    static queryDynamicDataFromManyCampaignId(query: GetCampaignQueryModel): Promise<any[]>;
     /**
      * Returns the campaign type index from the CampaignType enum
      * @param type CampaignType as db-related enum for v4

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

@@ -3,8 +3,10 @@ import { executeSimple } from "../../../utils/execute";
 import { log } from "../../../utils/logger";
 import { CampaignType } from "../../../../database/api/.generated";
 import { Campaign, NETWORK_LABELS } from "@sdk";
+import { utils } from "ethers";
 import { CampaignService, campaignTypeToEnumMap } from "../campaign";
 import { CampaignRepository } from "../campaign/campaign.repository";
+import { OpportunityService } from "../opportunity";
 export class DynamicDataService {
     // ─── DynamicDatas ──────────────────────────────────────────────────────────
     /** Fetches a single price */
@@ -50,7 +52,7 @@ export class DynamicDataService {
             type: result[0]?.type ?? "defaultType",
         };
     }
-    static async queryDynamicData(campaign) {
+    static generateDummyData(campaign) {
         const campaignParameters = {
             type: campaign.type,
             computeChainId: campaign.computeChainId,
@@ -64,21 +66,46 @@ export class DynamicDataService {
                 : (Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60).toString(), // 30 days from now
             creatorAddress: campaign.creatorAddress ? campaign.creatorAddress : "0xdefaultcreatoraddress",
             campaignParameters: campaign.params,
-            campaignId: "0xdefaultid",
+            campaignId: campaign.id ? campaign.id : "0xdefaultid",
             opportunityIdentifier: "0xdefaultopportunityid",
-            id: "0xdefaultid",
+            id: campaign.id ? campaign.id : "0xdefaultid",
             distributionChainId: campaign.distributionChainId ? campaign.distributionChainId : 1,
             rewardTokenId: campaign.rewardTokenId ? campaign.rewardTokenId : "0xdefaultrewardtokenid",
             opportunityId: campaign.opportunityId ? campaign.opportunityId : "0xdefaultopportunityid",
             identifier: campaign.identifier ? campaign.identifier : "defaultidentifier",
+            mainParameter: DynamicDataService.generateMainParameter(campaign),
         };
-        return await DynamicDataService.#getDynamicData(campaignParameters);
+        return campaignParameters;
+    }
+    static generateMainParameter(campaign) {
+        let targetToken;
+        let parsedParams;
+        if (campaign.type === "CLAMM") {
+            parsedParams = campaign.params;
+            targetToken = parsedParams.poolAddress;
+        }
+        else {
+            parsedParams = campaign.params;
+            targetToken = parsedParams.targetToken;
+        }
+        return utils
+            .keccak256(utils.defaultAbiCoder.encode(["string", "address[]"], [targetToken, parsedParams.whitelist.sort()]))
+            .slice(0, 42);
+    }
+    static async queryDynamicData(campaign) {
+        const campaignParameters = DynamicDataService.generateDummyData(campaign);
+        return await DynamicDataService.#getMultipleDynamicData([campaignParameters]);
     }
     static async queryDynamicDataFromCampaignId(query) {
         const campaigns = await CampaignRepository.findMany(query);
         const campaign = campaigns[0];
         return DynamicDataService.queryDynamicData(CampaignService.format(campaign));
     }
+    static async queryDynamicDataFromManyCampaignId(query) {
+        const campaigns = await CampaignRepository.findMany(query);
+        const formattedCampaigns = campaigns.map(campaign => DynamicDataService.generateDummyData(CampaignService.format(campaign)));
+        return DynamicDataService.#getMultipleDynamicData(formattedCampaigns);
+    }
     /**
      * Returns the campaign type index from the CampaignType enum
      * @param type CampaignType as db-related enum for v4
@@ -87,15 +114,29 @@ export class DynamicDataService {
     static getV3FromType(type) {
         return Object.entries(campaignTypeToEnumMap).find(([v4]) => v4 === type)?.[1];
     }
-    /**
-     * build/fetch metadata of a campaign's opportunity
-     * @param campaign
-     * @returns {OpportunityMetadata}
-     */
     static async #getDynamicData(campaign) {
         // const campaignType = DynamicDataService.getV3FromType(campaign.type);
         if (campaign.type !== CampaignType.INVALID) {
             return await CampaignService.fetchDynamicData(campaign.computeChainId, campaign.type, [campaign]);
         }
     }
+    static async #getMultipleDynamicData(campaigns) {
+        const result = [];
+        // const campaignType = DynamicDataService.getV3FromType(campaign.type);
+        const campaign = campaigns[0];
+        const filteredCampaigns = campaigns.filter(c => c.type === campaign.type);
+        if (campaign.type !== CampaignType.INVALID) {
+            const resultDynamicData = await CampaignService.fetchDynamicData(campaign.computeChainId, campaign.type, filteredCampaigns);
+            for (const campaign of campaigns) {
+                const resultMetaData = await OpportunityService.fakeCreateFromCampaign({
+                    ...campaign,
+                    type: campaignTypeToEnumMap[campaign.type],
+                    params: JSON.stringify(campaign.campaignParameters),
+                    creator: campaign.creatorAddress,
+                });
+                result.push({ ...resultDynamicData.find(data => data.campaignId === campaign.campaignId), ...resultMetaData });
+            }
+        }
+        return result;
+    }
 }