@merkl/api 0.21.46 → 1.0.0

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

@@ -1,79 +0,0 @@
-import { apiDbClient } from "@db";
-import { ExplorerRepository } from "../explorer/explorer.repository";
-export class ChainRepository {
-    /**
-     * @param id ChainId
-     * @returns
-     */
-    static async read(id) {
-        //TODO: tweak query to not have 5
-        return await apiDbClient.chain.findUnique({ where: { id }, include: { Explorer: { take: 5 } } });
-    }
-    static transformQueryToPrismaFilters(query) {
-        return {
-            where: {
-                name: query.name ? { contains: query.name, mode: "insensitive" } : undefined,
-                Opportunity: query.name || query.test ? undefined : { some: { Campaigns: { some: { RewardToken: { isTest: false } } } } },
-            },
-        };
-    }
-    /** Returns many chains based on query
-     * @param query object with fields to search for
-     * @returns
-     */
-    static async findMany(query) {
-        const args = ChainRepository.transformQueryToPrismaFilters(query);
-        return apiDbClient.chain.findMany({
-            include: { Explorer: { take: 5 } },
-            ...args,
-        });
-    }
-    static async findAll() {
-        return await apiDbClient.chain.findMany({
-            include: { Explorer: { take: 5 } },
-            orderBy: { id: "asc" },
-        });
-    }
-    static async countMany(query) {
-        const args = ChainRepository.transformQueryToPrismaFilters(query);
-        return apiDbClient.chain.count({
-            ...args,
-        });
-    }
-    /** Returns all chainIds in the database
-     */
-    static async findManyIds() {
-        return (await apiDbClient.chain.findMany({
-            select: { id: true },
-        })).map(({ id }) => id);
-    }
-    /**
-     * Creates a new chain
-     * @param template for chain creation
-     * @returns
-     */
-    static async create(data) {
-        await apiDbClient.chain.create({
-            data: {
-                id: data.id,
-                icon: data.icon,
-                name: data.name,
-            },
-        });
-        await ExplorerRepository.create(data.id, data.explorerType, data.explorerUrl);
-        return await ChainRepository.findUniqueOrThrow(data.id);
-    }
-    static async findUniqueOrThrow(id) {
-        return await apiDbClient.chain.findUniqueOrThrow({
-            where: {
-                id,
-            },
-            include: {
-                Explorer: true,
-            },
-        });
-    }
-    static async update(id, data) {
-        return await apiDbClient.chain.update({ where: { id }, data });
-    }
-}

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

@@ -1,55 +0,0 @@
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { DistributorService } from "@sdk";
-import { TTLPresets } from "../cache/cache.model";
-import { ChainRepository } from "./chain.repository";
-export class ChainService {
-    static async get(chainId) {
-        return ChainRepository.read(chainId);
-    }
-    static async findAll() {
-        return await CacheService.wrap(TTLPresets.MIN_10, ChainRepository.findAll);
-    }
-    static async findMany(query) {
-        // Bypass cache in test mode
-        if (query.test)
-            return ChainRepository.findMany(query);
-        return await CacheService.wrap(TTLPresets.MIN_10, ChainRepository.findMany, query);
-    }
-    static async findUniqueOrThrow(id) {
-        return await ChainRepository.findUniqueOrThrow(id);
-    }
-    static async countMany(query) {
-        return await ChainRepository.countMany(query);
-    }
-    /** List all chainIds available in the databse
-     * @warning some chains may not be fully integrated yet
-     * @returns an array of chainId
-     */
-    static async findManyIds() {
-        return ChainRepository.findManyIds();
-    }
-    /** List all chainIds which have a distribituor (i.e. which is fully integrated)
-     * @returns an array of chainId
-     */
-    static async getSupportedIds() {
-        const ids = await ChainService.findManyIds();
-        const supportedIds = [];
-        for (const chainId of ids) {
-            try {
-                DistributorService(chainId);
-                supportedIds.push(chainId);
-            }
-            catch { }
-        }
-        return supportedIds;
-    }
-    static async create(chain) {
-        return await ChainRepository.create(chain);
-    }
-    static async update(id, data) {
-        return await ChainRepository.update(id, data);
-    }
-    static async updateDailyRewards(id, dailyRewards) {
-        return await ChainRepository.update(id, { dailyRewards });
-    }
-}

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

@@ -1,4 +0,0 @@
-import { TracerService } from "@/modules/v4/tracer/tracer.service";
-import { ChainInteractionService } from "@sdk";
-const ChainInteractionServiceWrapper = TracerService.createTracedProxy(ChainInteractionService, "ChainInteractionService");
-export { ChainInteractionServiceWrapper as ChainInteractionService };

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

@@ -1,19 +0,0 @@
-import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
-import Elysia from "elysia";
-import { ChainArrayOptionalDto } from "../chain/chain.model";
-import { UserUniqueDto } from "../user/user.model";
-import { ClaimService } from "./claims.service";
-// ─── Claim Controller ───────────────────────────────────────────────────────
-export const ClaimController = new Elysia({ prefix: "/claims", detail: { tags: ["Claims"] } })
-    // ─── Get Historical Claims ────────────────────────────────────────────
-    .get("/:address", async ({ params, query }) => await ClaimService.getHistoricalClaims(params, query.chainIds.map(Number)), {
-    params: UserUniqueDto,
-    query: ChainArrayOptionalDto,
-    beforeHandle: ({ params, query }) => {
-        params.address = throwOnInvalidRequiredAddress(params.address);
-        query.chainIds = query.chainIds.flatMap(x => x.split(","));
-        for (const chainId of query.chainIds) {
-            throwOnUnsupportedChainId(Number(chainId));
-        }
-    },
-});

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

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

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

@@ -1,39 +0,0 @@
-import { merklSubgraphClaimsEndpoints } from "@sdk";
-import request, { gql } from "graphql-request";
-export class ClaimRepository {
-    static async fetch(chainId, address) {
-        try {
-            return (await request(merklSubgraphClaimsEndpoints[chainId], 
-            // Request is limited to first 100 by default so needs to be sorted
-            gql `query MerklClaims($user: String) {
-              merklClaims(where: {user: $user }, orderBy: timestamp, orderDirection: desc) {
-                timestamp
-                token
-                user
-                amount
-                rawAmount
-                root
-                id
-                txHash
-              }
-            }
-    `, { user: address?.toLowerCase() })).merklClaims;
-        }
-        catch {
-            return (await request(merklSubgraphClaimsEndpoints[chainId], 
-            // Request is limited to first 100 by default so needs to be sorted
-            gql `query MerklClaims($user: String) {
-                merklClaims(where: {user: $user }, orderBy: timestamp, orderDirection: desc) {
-                  timestamp
-                  token
-                  user
-                  amount
-                  rawAmount
-                  root
-                  id
-                }
-              }
-      `, { user: address?.toLowerCase() })).merklClaims;
-        }
-    }
-}

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

@@ -1,40 +0,0 @@
-import { MerklRootService } from "@/modules/v4/merklRoot/merklRoot.service";
-import { RewardService } from "@/modules/v4/reward/reward.service";
-import { ClaimRepository } from "./claims.repository";
-export class ClaimService {
-    // ─── Get Historical Claims ─────────────────────────────────────────────────
-    static async getHistoricalClaims(params, chainFilter = []) {
-        const roots = Object.values(await MerklRootService.fetchAll()).map(r => r.live);
-        const rewards = await RewardService.getByRecipient(params.address, roots, true, true, chainFilter);
-        const filteredRewards = chainFilter.length
-            ? rewards.filter(reward => chainFilter.includes(reward.RewardToken.chainId))
-            : rewards;
-        const chainIds = [];
-        for (const reward of filteredRewards) {
-            if (!chainIds.includes(reward.RewardToken.chainId)) {
-                chainIds.push(reward.RewardToken.chainId);
-            }
-        }
-        const tokens = filteredRewards.reduce((acc, reward) => {
-            acc[reward.RewardToken.address.toLowerCase()] = reward.RewardToken;
-            return acc;
-        }, {});
-        const promises = await Promise.allSettled(chainIds.map(chainId => ClaimRepository.fetch(chainId, params.address)));
-        const claims = promises.filter(p => p.status === "fulfilled")
-            .flatMap(p => p.value ?? []) // null/undefined claim arrays
-            .filter(claim => {
-            // Ensure the claim's token exists and matches the chainFilter
-            const token = claim?.token ? tokens[claim.token.toLowerCase()] : undefined;
-            return token && (!chainFilter.length || chainFilter.includes(token.chainId));
-        })
-            .map(claim => {
-            const token = claim?.token ? tokens[claim.token.toLowerCase()] : undefined;
-            return {
-                ...claim,
-                amount: claim.rawAmount,
-                token,
-            };
-        });
-        return claims.sort((a, b) => Number(b.timestamp) - Number(a.timestamp));
-    }
-}

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

@@ -1 +0,0 @@
-"use strict";

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

@@ -1,9 +0,0 @@
-import axios from "axios";
-export class CoingeckoRepository {
-    static async findList() {
-        return (await axios.get("https://api.coingecko.com/api/v3/coins/list")).data;
-    }
-    static async findMarkets(ids) {
-        return (await axios.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&per_page=250${!!ids ? `&ids=${ids.join(",")}` : ""}`)).data;
-    }
-}

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

@@ -1,65 +0,0 @@
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { PriceService } from "@/modules/v4/price/price.service";
-import { log } from "@/utils/logger";
-import { NETWORK_LABELS } from "@sdk";
-import { TTLPresets } from "../cache/cache.model";
-import { TokenService } from "../token/token.service";
-import { CoingeckoRepository } from "./coingecko.repository";
-export class CoingeckoService {
-    static findList() {
-        return CacheService.wrap(TTLPresets.HOUR_1, CoingeckoRepository.findList);
-    }
-    static findMarkets(ids) {
-        return CacheService.wrap(TTLPresets.MIN_5, CoingeckoRepository.findMarkets, ids);
-    }
-    static async createPriceSourceForSymbolIfMissing(symbol, ticker) {
-        try {
-            await PriceService.getPriceSourceBySymbol(symbol);
-        }
-        catch {
-            await PriceService.createPriceSource({
-                symbol: symbol,
-                method: "COINGECKO",
-                args: {
-                    ticker,
-                },
-            });
-            log.info(`added coingecko price source for token ${symbol}: ${ticker}`);
-        }
-    }
-    static async fillTokensWithCoingeckoData() {
-        // 1 - Get coingecko token list
-        const coingeckoData = CoingeckoService.findList();
-        // 2 - Find tokens with missing prices and try to add the sources
-        const missingPriceTokens = await TokenService.findMany({ missingPrice: true });
-        for (const token of missingPriceTokens) {
-            const coingeckoToken = (await coingeckoData).find(t => t.symbol === token.symbol && t.name === token.name);
-            if (!!coingeckoToken) {
-                await CoingeckoService.createPriceSourceForSymbolIfMissing(token.symbol, coingeckoToken.id);
-            }
-        }
-        // 3 - Find tokens with missing logos and gather their ids
-        const missingIconsTokens = await TokenService.findMany({ missingIcons: true });
-        const coingeckoIds = [];
-        for (const token of missingIconsTokens) {
-            const coingeckoToken = (await coingeckoData).find(t => t.symbol === token.symbol && t.name === token.name);
-            if (!!coingeckoToken) {
-                coingeckoIds.push(coingeckoToken.id);
-            }
-        }
-        // Avoid rate limits, wait 2 min
-        await new Promise(resolve => setTimeout(resolve, 120_000));
-        // 4 - Get images and fill them
-        const coingeckoMarkets = await CoingeckoService.findMarkets(coingeckoIds);
-        for (const market of coingeckoMarkets) {
-            for (const token of missingIconsTokens) {
-                if (token.symbol === market.symbol && token.name === market.name) {
-                    await TokenService.update(token.id, {
-                        icon: market.image,
-                    });
-                    log.info(`updated token ${token.symbol} on ${NETWORK_LABELS[token.chainId]} with icon ${market.image}`);
-                }
-            }
-        }
-    }
-}

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

@@ -1,46 +0,0 @@
-import { AuthorizationHeadersDto, EngineGuard } from "@/guards/Engine.guard";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { throwOnInvalidRequiredAddress } from "@/utils/throw";
-import Elysia from "elysia";
-import { GetCampaignComputedValue, GetUserComputedValues, UpsertCampaignComputedValue, UpsertUserComputedValues, } from "./computedValue.model";
-import { ComputedValueService } from "./computedValue.service";
-export const ComputedValueController = new Elysia({
-    prefix: "/value",
-    detail: { tags: ["Value"] },
-})
-    // ─── Get a Campaign Value ──────────────────────────────────────
-    .get("/campaign/:campaignId/:field", async ({ params }) => CampaignService.findCampaignValue(params), {
-    params: GetCampaignComputedValue,
-    detail: { description: "Gets campaign-level values computed by Merkl Engine (for example average boost)" },
-})
-    // ─── Get user Values ──────────────────────────────────────
-    .get("/user/:address/:field", async ({ params }) => ComputedValueService.findUserValues(params), {
-    params: GetUserComputedValues,
-    beforeHandle: ({ params }) => {
-        params.address = throwOnInvalidRequiredAddress(params.address);
-    },
-    detail: {
-        description: "Gets campaign-level values computed by Merkl Engine (for example position specific boosts)",
-    },
-})
-    // ─── Update a Campaign Value ──────────────────────────────────────
-    .post("/engine/campaign", async ({ body }) => await ComputedValueService.upsertCampaignComputedValue(body), {
-    headers: AuthorizationHeadersDto,
-    body: UpsertCampaignComputedValue,
-    beforeHandle: ({ headers }) => {
-        EngineGuard({ headers });
-    },
-    detail: { hide: true },
-})
-    // ─── Update some User Values ──────────────────────────────────────
-    .post("/engine/user", async ({ body }) => await ComputedValueService.upsertUserComputedValues(body), {
-    headers: AuthorizationHeadersDto,
-    body: UpsertUserComputedValues,
-    beforeHandle: async ({ headers, body }) => {
-        await EngineGuard({ headers });
-        for (const item of body) {
-            item.address = throwOnInvalidRequiredAddress(item.address);
-        }
-    },
-    detail: { hide: true },
-});

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

@@ -1,30 +0,0 @@
-import { t } from "elysia";
-// ─── DTOs ────────────────────────────────────────────────────────────────────
-export const GetCampaignComputedValue = t.Object({
-    campaignId: t.String({
-        description: "The campaign Id to get the computed value for. Can be either of the for '0x1234...5678' (solidity id) or '0x1234...5678_<DISTRIBUTION_CHAIN>' or '22222' (Database id).",
-    }),
-    field: t.String({
-        description: "The field you're querying for. Example includes 'averageBoost', 'totalDistributedInUSD', 'forfeitingBoost'. Note that these aren't always available and depend on the campaign type.",
-    }),
-});
-export const UpsertCampaignComputedValue = t.Object({
-    campaignId: t.String(),
-    value: t.Number(),
-    field: t.String(),
-});
-export const GetUserComputedValues = t.Object({
-    address: t.String({
-        description: "The user's address to get the computed values for.",
-    }),
-    field: t.String({
-        description: "The field you're querying for. Example includes 'boost'.",
-    }),
-});
-export const UpsertUserComputedValues = t.Array(t.Object({
-    campaignId: t.String(),
-    address: t.String(),
-    reason: t.String(),
-    value: t.Number(),
-    field: t.String(),
-}));

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

@@ -1,48 +0,0 @@
-import { apiDbClient } from "@db";
-import { UserRepository } from "../user/user.repository";
-export class ComputedValueRepository {
-    static async findCampaignValue(params) {
-        return await apiDbClient.campaignComputedValue.findUnique({
-            where: { campaignId: params.campaignId },
-            select: { [params.field]: true },
-        });
-    }
-    static async upsertCampaignComputedValue(data) {
-        await apiDbClient.campaignComputedValue.upsert({
-            where: { campaignId: data.campaignId },
-            update: { [data.field]: data.value },
-            create: {
-                campaignId: data.campaignId,
-                [data.field]: data.value,
-            },
-        });
-    }
-    static async findUserValues(data) {
-        return await apiDbClient.userComputedValue.findMany({
-            where: { address: data.address },
-            select: {
-                campaignId: true,
-                reason: true,
-                [data.field]: true,
-            },
-        });
-    }
-    static async upsertUserComputedValues(data) {
-        // Make sure user foreign keys exist
-        await UserRepository.createMany(data.map(item => ({ address: item.address, tags: [] })));
-        await apiDbClient.$transaction(data.map(item => {
-            return apiDbClient.userComputedValue.upsert({
-                where: {
-                    campaignId_address_reason: { campaignId: item.campaignId, address: item.address, reason: item.reason },
-                },
-                update: { [item.field]: item.value },
-                create: {
-                    campaignId: item.campaignId,
-                    address: item.address,
-                    reason: item.reason,
-                    [item.field]: item.value,
-                },
-            });
-        }));
-    }
-}

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

@@ -1,23 +0,0 @@
-import { log } from "@/utils/logger";
-import { ComputedValueRepository } from "./computedValue.repository";
-export class ComputedValueService {
-    static hashUserComputedValueId(campaignId, address, reason) {
-        return Bun.hash(`${campaignId}${address}${reason}`).toString();
-    }
-    static async findCampaignValue(campaignId, field) {
-        return await ComputedValueRepository.findCampaignValue({
-            campaignId,
-            field,
-        });
-    }
-    static async upsertCampaignComputedValue(data) {
-        await ComputedValueRepository.upsertCampaignComputedValue(data);
-    }
-    static async findUserValues(params) {
-        return await ComputedValueRepository.findUserValues(params);
-    }
-    static async upsertUserComputedValues(data) {
-        await ComputedValueRepository.upsertUserComputedValues(data);
-        log.info(`Upserted ${data.length} users computed values`);
-    }
-}

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

@@ -1,43 +0,0 @@
-import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { Elysia } from "elysia";
-import { CampaignIdDto, CampaignQueryDto, CreateCreatorDto, CreatorAddressDto, CreatorIdDto, GetManyCreatorQuery, UpdateCreatorDto, } from "./creator.model";
-import { CreatorService } from "./creator.service";
-// ─── Creators Controller ─────────────────────────────────────────────────────
-export const CreatorController = new Elysia({ prefix: "/creators", detail: { tags: ["Creator"] } })
-    // ─── CRUD OPS ────────────────────────────────────────────────────────────────
-    // ─── Create A Creator ────────────────────────────────────────────────
-    .post("/", async ({ body }) => await CreatorService.create(body), {
-    headers: AuthorizationHeadersDto,
-    body: CreateCreatorDto,
-    beforeHandle: BackOfficeGuard,
-})
-    // ─── Get Many Creators ───────────────────────────────────────────────
-    .get("/", async ({ query }) => await CreatorService.findMany(query), { query: GetManyCreatorQuery })
-    // ─── Get A Unique Creator By Id ──────────────────────────────────────
-    .get("/:creatorId", async ({ params: { creatorId } }) => CreatorService.findUnique(creatorId), {
-    params: CreatorIdDto,
-})
-    // ─── Update A Creator ────────────────────────────────────────────────
-    .patch("/:creatorId", async ({ params: { creatorId }, body }) => CreatorService.update(creatorId, body), {
-    headers: AuthorizationHeadersDto,
-    body: UpdateCreatorDto,
-    params: CreatorIdDto,
-    beforeHandle: BackOfficeGuard,
-})
-    // ─── Delete A Creator ────────────────────────────────────────────────
-    .delete("/:creatorId", async ({ params: { creatorId } }) => CreatorService.delete(creatorId), {
-    headers: AuthorizationHeadersDto,
-    params: CreatorIdDto,
-    beforeHandle: BackOfficeGuard,
-})
-    // ─── Service Specific Methods ────────────────────────────────────────────────
-    .get("/user/:address/dashboard", async ({ params }) => CreatorService.getGlobalDashboard(params.address), {
-    params: CreatorAddressDto,
-})
-    .get("/user/:address/campaigns", async ({ params: { address }, query }) => CreatorService.getCampaignsFor(address, query.status), {
-    params: CreatorAddressDto,
-    query: CampaignQueryDto,
-})
-    .get("/campaigns/:campaignId", async ({ params: { campaignId } }) => CreatorService.getCampaignMetrics(campaignId), {
-    params: CampaignIdDto,
-});

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

@@ -1,42 +0,0 @@
-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(),
-    rebateFee: t.Optional(t.Number({ maximum: 100, minimum: 0 })),
-});
-export const CreateCreatorDto = t.Object({
-    id: t.String(),
-    addresses: t.Array(t.String()),
-    icon: t.Optional(t.String()),
-    name: t.String(),
-});
-export const GetManyCreatorQuery = t.Object({
-    id: t.Optional(t.String()),
-    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(),
-});
-export const CreatorAddressDto = t.Object({
-    address: t.String(),
-});
-export const CampaignIdDto = t.Object({
-    campaignId: t.String(),
-});
-export const CampaignStatusDto = t.Enum({ PAST: "PAST", LIVE: "LIVE", FUTURE: "FUTURE" });
-export const CampaignQueryDto = t.Object({
-    status: t.Optional(CampaignStatusDto),
-});
-export const CreatorIdDto = t.Object({
-    creatorId: t.String(),
-});
-export const UpdateCreatorRebateDto = t.Object({
-    rebate: t.Number({ maximum: 100, minimum: 0 }),
-});

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

@@ -1,69 +0,0 @@
-import { apiDbClient } from "@db";
-// ─── Users Repository ────────────────────────────────────────────────────────
-export class CreatorRepository {
-    static async findUnique(id) {
-        return await apiDbClient.creator.findUniqueOrThrow({ 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, address, ...filters } = query;
-        const page = _page ? _page : 0;
-        const items = _items ? _items : 20;
-        return await apiDbClient.creator.findMany({
-            take: items,
-            skip: page * items,
-            include: { Users: { select: { address: true } } },
-            where: {
-                ...filters,
-                Users: address
-                    ? {
-                        some: {
-                            address: {
-                                equals: 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 },
-                    })),
-                },
-            },
-        });
-    }
-    static async delete(id) {
-        return await apiDbClient.creator.delete({ where: { id } });
-    }
-    static async getCampaignsFor(creatorAddress) {
-        return await apiDbClient.campaign.findMany({
-            where: { creatorAddress },
-            include: { Opportunity: true },
-        });
-    }
-    static async updateRebate(id, rebate) {
-        return await apiDbClient.creator.update({ where: { id }, data: { rebateFee: rebate } });
-    }
-}