@merkl/api 0.9.15

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

@@ -0,0 +1,309 @@
+import { HttpError } from "@/errors";
+import { OpportunityService } from "@/modules/v4/opportunity";
+import { StatusService } from "@/modules/v4/status/status.service";
+import { TokenRepository } from "@/modules/v4/token/token.repository";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { CannotParseOpportunity, InvalidParameter } from "@/utils/error";
+import { log } from "@/utils/logger";
+import { Campaign as CampaignEnum, NETWORK_LABELS, } from "@sdk";
+import { utils } from "ethers";
+import moment from "moment";
+import { CampaignRepository } from "./campaign.repository";
+export class CampaignService {
+    static hashId(campaign) {
+        return Bun.hash(`${campaign.distributionChain}${campaign.campaignId}`).toString();
+    }
+    static splitIdOrThrow(chainAndCampaignId) {
+        if (!chainAndCampaignId.includes("-"))
+            throw new InvalidParameter("Campaign id should be formatted as chainId-campaignId");
+        const [chainId, campaignId] = chainAndCampaignId.split("-");
+        return { distributionChain: +chainId, campaignId };
+    }
+    static async getPastCampaigns(query) {
+        return await CampaignRepository.getPastCampaigns(query);
+    }
+    static async getFutureCampaigns(query) {
+        return await CampaignRepository.getFutureCampaigns(query);
+    }
+    static async getLiveCampaigns(query) {
+        return await CampaignRepository.getLiveCampaigns(query);
+    }
+    static async countLives(query) {
+        return await CampaignRepository.countLives(query);
+    }
+    static async create(campaign) {
+        const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
+        try {
+            await OpportunityService.createFromCampaign(campaign);
+        }
+        catch {
+            throw new CannotParseOpportunity(campaign.campaignId, campaign.chainId, campaign.type);
+        }
+        return await CampaignRepository.upsert({ id, ...campaign });
+    }
+    /**
+     * @dev back-office function
+     * @dev deprecated should be replaced with a manual override
+     */
+    static async updateMetaData(campaign) {
+        const id = CampaignService.hashId({
+            distributionChain: campaign.distributionChain,
+            campaignId: campaign.campaignId,
+        });
+        const existingCampaign = await CampaignService.findUniqueOrThrow(campaign);
+        const params = existingCampaign.params;
+        if ("url" in params) {
+            params.url = campaign.url;
+        }
+        const updatedParams = JSON.stringify(params);
+        return await CampaignRepository.updateMetaData(id, updatedParams);
+    }
+    /**
+     * @dev back-office function for manual overrides
+     */
+    static async updateCreator(campaign) {
+        const id = CampaignService.hashId({
+            distributionChain: campaign.distributionChain,
+            campaignId: campaign.campaignId,
+        });
+        return await CampaignRepository.updateCreator(id, campaign.creatorAddress);
+    }
+    /**
+     * @dev back-office function
+     */
+    static async moveToOpportunity(campaign, upsert = false) {
+        const id = CampaignService.hashId({
+            distributionChain: campaign.distributionChain,
+            campaignId: campaign.campaignId,
+        });
+        const existingCampaign = await CampaignService.findUniqueOrThrow(campaign);
+        const token = await TokenRepository.findUniqueOrThrow(existingCampaign.rewardTokenId);
+        if (existingCampaign.type === "ERC20" && campaign.opportunityIdentifier === undefined) {
+            const campaignParams = existingCampaign.params;
+            campaign.opportunityIdentifier = utils
+                .keccak256(utils.defaultAbiCoder.encode(["string", "address[]"], [campaignParams.targetToken, campaignParams.whitelist.sort()]))
+                .slice(0, 42);
+        }
+        if (campaign.opportunityIdentifier === undefined) {
+            throw new HttpError("Bad Request: opportunityIdentifier is required for CampaignService campaign type", 400);
+        }
+        const updatedCampaign = {
+            ...existingCampaign,
+            opportunityIdentifier: campaign.opportunityIdentifier,
+            chainId: campaign.distributionChain,
+            creator: existingCampaign.creatorAddress,
+            rewardTokenAddress: token.address,
+            params: JSON.stringify(existingCampaign.params),
+            type: CampaignEnum[existingCampaign.type],
+            subType: existingCampaign.subType ?? undefined,
+            startTimestamp: existingCampaign.startTimestamp.toString(),
+            endTimestamp: existingCampaign.endTimestamp.toString(),
+        };
+        const opportunityId = OpportunityService.hashId({
+            chainId: existingCampaign.computeChainId,
+            identifier: campaign.opportunityIdentifier,
+            type: existingCampaign.type,
+        });
+        const updatedCampaignData = {
+            ...campaign,
+            opportunityId,
+        };
+        // Create new opportunity
+        await OpportunityService.createFromCampaign(updatedCampaign, upsert);
+        // Move campaign to new opportunity
+        await CampaignRepository.updateOpportunity(id, { id, ...updatedCampaignData });
+        // Return new opportunityId
+        return (await CampaignService.findUniqueOrThrow(campaign)).opportunityId;
+    }
+    /**
+     * Get the list of campaigns satisfying the query
+     * @param query
+     * @returns A list of campaigns
+     */
+    static async findMany(query) {
+        if (query.subType && !query.type)
+            throw new HttpError("Bad Request: Cannot specify a subType without a type", 400);
+        const campaigns = await CampaignRepository.findMany(query);
+        return campaigns.map(CampaignService.format);
+    }
+    static async findAndGroupByChains(query) {
+        return Map.groupBy(await CampaignService.findMany(query), campaign => campaign.chain.id);
+    }
+    static async countByChains(query) {
+        return CampaignService.countBy(await CampaignService.findAndGroupByChains({ ...query, items: 0 }));
+    }
+    static async findAndGroupByType(query) {
+        return Map.groupBy(await CampaignService.findMany(query), campaign => campaign.type);
+    }
+    static async countByType(query) {
+        return CampaignService.countBy(await CampaignService.findAndGroupByType({ ...query, items: 0 }));
+    }
+    static async findAndGroupByProtocol(query) {
+        return Map.groupBy(await CampaignService.findMany(query), campaign => campaign.Opportunity.mainProtocolId);
+    }
+    static async countByProtocol(query) {
+        return CampaignService.countBy(await CampaignService.findAndGroupByType({ ...query, items: 0 }));
+    }
+    static countBy(campaignsMap) {
+        const count = {};
+        for (const [key, value] of campaignsMap) {
+            count[key] = value.length;
+        }
+        return count;
+    }
+    /**
+     * Counts the number of campaigns that complies to query
+     * @description used for pagination purposes
+     * @param query
+     * @returns the number of campaigns
+     */
+    static async countMany(query) {
+        if (query.subType && !query.type) {
+            throw new HttpError("Bad Request: Cannot specify a subType without a type", 400);
+        }
+        return await CampaignRepository.countMany(query);
+    }
+    static async checkIfExist(campaign) {
+        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
+        return !!(await CampaignRepository.findUnique(id));
+    }
+    static async findUnique(campaign) {
+        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
+        return await CampaignRepository.findUnique(id);
+    }
+    static async findUniqueOrThrow(campaign, withOpportunity = false) {
+        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
+        return await CampaignRepository.findUniqueOrThrow(id, withOpportunity);
+    }
+    static async removeManualOverride(campaign, field) {
+        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
+        return await CampaignRepository.removeManualOverride(id, field);
+    }
+    static async findCampaignsToProcess(distributionChainId) {
+        return (await CampaignRepository.findCampaignsToProcess(distributionChainId))
+            .filter(campaign => campaign.endTimestamp > (campaign?.CampaignStatus?.[0]?.computedUntil ?? 0n))
+            ?.sort((a, b) => Number((a.CampaignStatus?.[0]?.processingStarted ?? 0n) - (b.CampaignStatus?.[0]?.processingStarted ?? 0n)));
+    }
+    static async findNextCampaignToProcess(chainId) {
+        const campaigns = await CampaignService.findCampaignsToProcess(chainId);
+        return { campaignId: campaigns?.[0]?.campaignId };
+    }
+    static async pickCampaignToProcess(chainId) {
+        const campaigns = await CampaignService.findCampaignsToProcess(chainId);
+        for (const campaign of campaigns) {
+            try {
+                await StatusService.update({
+                    distributionChain: chainId,
+                    campaignId: campaign.campaignId,
+                }, { value: "PROCESSING" });
+                return { campaignId: campaign.campaignId };
+            }
+            catch { }
+        }
+        throw new Error(`No campaign to process found on ${NETWORK_LABELS[chainId]}`);
+    }
+    static async fill(campaigns) {
+        const campaignsFromEngine = await CampaignRepository.getFromEngineDbWithId(campaigns);
+        for (const campaign of campaigns) {
+            if (campaignsFromEngine.findIndex(c => c.campaignId === campaign.campaignId) === -1) {
+                log.warn(`Campaign ${campaign.campaignId} on ${NETWORK_LABELS[campaign.distributionChain]} not found in engine db`);
+            }
+        }
+        let success = 0;
+        let fail = 0;
+        for (const engineCampaign of campaignsFromEngine) {
+            try {
+                await CampaignService.create({
+                    amount: engineCampaign.amount,
+                    chainId: engineCampaign.chainId,
+                    computeChainId: engineCampaign.computeChainId,
+                    creator: engineCampaign.creator,
+                    endTimestamp: engineCampaign.endTimestamp.toString(),
+                    campaignId: engineCampaign.campaignId,
+                    opportunityIdentifier: engineCampaign.mainParameter,
+                    params: JSON.stringify(engineCampaign.campaignParameters),
+                    rewardTokenAddress: engineCampaign.rewardToken,
+                    startTimestamp: engineCampaign.startTimestamp.toString(),
+                    type: engineCampaign.campaignType,
+                    subType: engineCampaign.campaignSubType,
+                });
+                success++;
+            }
+            catch {
+                log.warn(`Failed to create campaign ${engineCampaign.campaignId} on ${NETWORK_LABELS[engineCampaign.chainId]}`);
+                fail++;
+            }
+        }
+        return { success, fail };
+    }
+    static async findChains() {
+        return await CampaignRepository.findChains();
+    }
+    /**
+     * Returns the campaign data
+     * @param type index of Campaign enum from sdk
+     * @returns a string
+     */
+    static getTypeFromV3(type) {
+        return CampaignEnum[type];
+    }
+    /**
+     * Split a campaigns array into three array for each status
+     * @param campaigns
+     * @param timestamp to compare to campaigns timestamps
+     * @returns a status => campaigns map
+     */
+    static splitOnStatus(campaigns, timestamp = moment().unix()) {
+        const past = campaigns.filter(({ endTimestamp: end }) => end <= timestamp);
+        const live = campaigns.filter(({ startTimestamp: start, endTimestamp: end }) => timestamp >= start && timestamp < end);
+        const soon = campaigns.filter(({ startTimestamp: start }) => start > timestamp);
+        return { past, live, soon };
+    }
+    /**
+     * Convert raw
+     * @param query
+     * @returns A list of opportunities
+     * TODO: remove CampaignService function in favor of prisma client extensions
+     */
+    static format(campaign) {
+        const { DistributionChain, ComputeChain, Creator, RewardToken, params, CampaignStatus, createdAt, manualOverrides: _, ...c } = campaign;
+        return {
+            ...c,
+            params: params,
+            chain: ComputeChain,
+            endTimestamp: Number(c.endTimestamp),
+            startTimestamp: Number(c.startTimestamp),
+            rewardToken: TokenService.format(RewardToken),
+            distributionChain: DistributionChain === null ? undefined : DistributionChain,
+            // Todo: need to be change to single 1 to 1 with campaign
+            campaignStatus: CampaignStatus?.[0] ? StatusService.format(CampaignStatus?.[0]) : undefined,
+            creatorAddress: Creator.address,
+            creator: Creator,
+            createdAt: createdAt.toISOString(),
+        };
+    }
+    static formatAsCampaignParameters(campaign) {
+        return {
+            campaignSubType: campaign.subType ?? 0,
+            campaignParameters: campaign.params,
+            computeChainId: campaign.computeChainId,
+            campaignId: campaign.campaignId,
+            rewardToken: campaign.rewardToken.address,
+            amount: campaign.amount,
+        };
+    }
+    /**
+     * Shortcut to get daily amount from total
+     * @param start timestamp
+     * @param end timestamp
+     * @param amount
+     * @returns daily token amount
+     */
+    static getDailyAmount(start, end, amount) {
+        const timespan = Math.abs(Number(end - start));
+        const isWithinTimespan = moment().unix() > start && moment().unix() < end;
+        const dayspan = Math.max(1, Math.floor(timespan / (60 * 60 * 24)));
+        const dailyAmount = isWithinTimespan ? BigInt(amount) / BigInt(dayspan) : 0n;
+        return dailyAmount;
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./campaign.model";
+export * from "./campaign.service";

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

@@ -0,0 +1,2 @@
+export * from "./campaign.model";
+export * from "./campaign.service";

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

@@ -0,0 +1,145 @@
+import Elysia from "elysia";
+export declare const ChainController: Elysia<"/chains", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    chains: {
+        ":chainId": {
+            get: {
+                body: unknown;
+                params: {
+                    chainId: number;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                        explorers: {
+                            id: string;
+                            type: import("@db/api").$Enums.ExplorerType;
+                            url: string;
+                            chainId: number;
+                        }[];
+                    } | null;
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    name?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                        explorers: {
+                            id: string;
+                            type: import("@db/api").$Enums.ExplorerType;
+                            url: string;
+                            chainId: number;
+                        }[];
+                    }[];
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        count: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    name?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: number;
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        ":chainId": {
+            patch: {
+                body: {
+                    icon?: string | undefined;
+                    dailyRewards?: number | undefined;
+                    liveCampaigns?: number | undefined;
+                };
+                params: {
+                    chainId: number;
+                };
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        index: {
+            post: {
+                body: {
+                    id: number;
+                    name: string;
+                    icon: string;
+                    explorerType: "ETHERSCAN" | "BLOCKSCOUT";
+                    explorerUrl: string;
+                };
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        Explorer: {
+                            id: string;
+                            type: import("@db/api").$Enums.ExplorerType;
+                            url: string;
+                            chainId: number;
+                        }[];
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,44 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
+import Elysia, { t } from "elysia";
+import { ChainResourceDto, ChainUniqueDto, CreateChainDto, GetChainQueryDto, UpdateChainDto, } from "./chain.model";
+import { ChainService } from "./chain.service";
+// ─── Chains Controller ───────────────────────────────────────────────────────
+export const ChainController = new Elysia({ prefix: "/chains", detail: { tags: ["Chains"] } })
+    // ─── Get A Chain By Id ───────────────────────────────────────────────
+    .get("/:chainId", async ({ params: { chainId } }) => {
+    const chain = await ChainService.get(chainId);
+    if (!chain)
+        return null;
+    const { Explorer, ...rest } = chain;
+    return { explorers: chain.Explorer, ...rest };
+}, {
+    params: ChainUniqueDto,
+    detail: { hide: true },
+})
+    // ─── Get All Supported Chains ────────────────────────────────────────
+    .get("/", async ({ query }) => {
+    const chains = await ChainService.findMany(query);
+    return chains.map(({ Explorer, ...chain }) => ({ explorers: Explorer, ...chain }));
+}, {
+    query: GetChainQueryDto,
+    response: t.Array(ChainResourceDto),
+    detail: { description: "List chains supported and integrated by Merkl." },
+})
+    // ─── Count Chains ────────────────────────────────────────
+    .get("/count", async ({ query }) => await ChainService.countMany(query), {
+    query: GetChainQueryDto,
+    detail: { hide: true },
+})
+    .patch("/:chainId", async ({ params, body }) => await ChainService.update(params.chainId, body), {
+    params: ChainUniqueDto,
+    body: UpdateChainDto,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: BackOfficeGuard,
+    detail: { hide: true },
+})
+    .post("/", async ({ body }) => await ChainService.create(body), {
+    body: CreateChainDto,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: BackOfficeGuard,
+    detail: { hide: true },
+});

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

@@ -0,0 +1,43 @@
+import type { Resource } from "@/modules/v4/prisma";
+/**
+ * Chain
+ * @description Metadata for each supported network
+ * @see {@link Resource}
+ */
+export type Chain = Resource<"Chain">;
+export declare const ChainResourceDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TNumber;
+    name: import("@sinclair/typebox").TString;
+    icon: import("@sinclair/typebox").TString;
+}>;
+export declare const GetChainQueryDto: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const ChainUniqueDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+}>;
+export declare const ChainUniqueOptionalDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const ChainArrayOptionalDto: import("@sinclair/typebox").TObject<{
+    chainIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>, number[]>>;
+}>;
+export declare const UpdateChainDto: import("@sinclair/typebox").TObject<{
+    icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    dailyRewards: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    liveCampaigns: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const CreateChainDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TNumber;
+    name: import("@sinclair/typebox").TString;
+    icon: import("@sinclair/typebox").TString;
+    explorerType: import("@sinclair/typebox").TEnum<{
+        ETHERSCAN: "ETHERSCAN";
+        BLOCKSCOUT: "BLOCKSCOUT";
+    }>;
+    explorerUrl: import("@sinclair/typebox").TString;
+}>;
+export type ChainUniqueModel = typeof ChainUniqueDto.static;
+export type ChainSearchDto = typeof GetChainQueryDto.static;
+export type UpdateChainModel = typeof UpdateChainDto.static;
+export type CreateChainModel = typeof CreateChainDto.static;

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

@@ -0,0 +1,38 @@
+import { ExplorerType } from "@db/api";
+import { t } from "elysia";
+// ─── DTOs ────────────────────────────────────────────────────────────────────
+export const ChainResourceDto = t.Object({
+    id: t.Number(),
+    name: t.String(),
+    icon: t.String(),
+});
+export const GetChainQueryDto = t.Object({
+    name: t.Optional(t.String({ description: "Search by blockchain name" })),
+});
+export const ChainUniqueDto = t.Object({
+    chainId: t.Numeric(),
+});
+export const ChainUniqueOptionalDto = t.Object({
+    chainId: t.Optional(t.Numeric()),
+});
+export const ChainArrayOptionalDto = t.Object({
+    chainIds: t.Optional(t
+        .Transform(t.Union([t.String(), t.Array(t.Numeric())]))
+        .Decode(value => (typeof value === "string" ? value.split(",").map(v => Number.parseInt(v)) : value))
+        .Encode(value => [...value])),
+}, {
+    description: "A required comma separated list of chain ids.<br>You can get the list of all supported chains by calling [GET /v4/chains](#tag/chains/GET/v4/chains/)",
+});
+export const UpdateChainDto = t.Object({
+    icon: t.Optional(t.String({ format: "uri" })),
+    dailyRewards: t.Optional(t.Number({})),
+    liveCampaigns: t.Optional(t.Number()),
+    // iconFile: t.Optional(t.File()),
+});
+export const CreateChainDto = t.Object({
+    id: t.Numeric(),
+    name: t.String(),
+    icon: t.String({ format: "uri" }),
+    explorerType: t.Enum(ExplorerType),
+    explorerUrl: t.String({ format: "uri" }),
+});

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

@@ -0,0 +1,75 @@
+import type { ChainSearchDto, CreateChainModel, UpdateChainModel } from "./chain.model";
+export declare class ChainRepository {
+    /**
+     * @param id ChainId
+     * @returns
+     */
+    static read(id: number): Promise<({
+        Explorer: {
+            id: string;
+            type: import("@db/api").$Enums.ExplorerType;
+            url: string;
+            chainId: number;
+        }[];
+    } & {
+        id: number;
+        name: string;
+        icon: string;
+    }) | null>;
+    static transformQueryToPrismaFilters(query: ChainSearchDto): {
+        where: {
+            name: {
+                contains: string;
+                mode: "insensitive";
+            } | undefined;
+        };
+    };
+    /** Returns many chains based on query
+     * @param query object with fields to search for
+     * @returns
+     */
+    static findMany(query: ChainSearchDto): Promise<({
+        Explorer: {
+            id: string;
+            type: import("@db/api").$Enums.ExplorerType;
+            url: string;
+            chainId: number;
+        }[];
+    } & {
+        id: number;
+        name: string;
+        icon: string;
+    })[]>;
+    static countMany(query: ChainSearchDto): Promise<number>;
+    /** Returns all chainIds in the database
+     */
+    static readIds(): Promise<{
+        id: number;
+    }[]>;
+    /**
+     * Creates a new chain
+     * @param template for chain creation
+     * @returns
+     */
+    static create(data: CreateChainModel): Promise<{
+        Explorer: {
+            id: string;
+            type: import("@db/api").$Enums.ExplorerType;
+            url: string;
+            chainId: number;
+        }[];
+    }>;
+    static findUniqueOrThrow(id: number): Promise<{
+        Explorer: {
+            id: string;
+            type: import("@db/api").$Enums.ExplorerType;
+            url: string;
+            chainId: number;
+        }[];
+    }>;
+    static update(id: number, data: UpdateChainModel): Promise<{
+        id: number;
+        name: string;
+        icon: string;
+    }>;
+}