@merkl/api 0.9.15

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

@@ -0,0 +1,26 @@
+import { type Campaign, ChainId, type campaignConfig } from "@sdk";
+import type { CampaignParametersStruct } from "libs/sdk/src/generated/CampaignCreator";
+import { type CampaignAmountsInputModel, type CampaignDataDtoModel, type CampaignPayloadInputModel, type ProgramPayloadInputModel, type SinglePayloadInputDtoModel, type approvalTransaction, type createCampaignTransaction, type safePayload } from "./programPayload.model";
+export declare class ProgramPayloadService {
+    static buildConfigTemplate(params: {
+        campaignType: number;
+    }): {
+        [key: string]: string;
+    };
+    static buildConfig(query: CampaignPayloadInputModel): campaignConfig<Campaign>;
+    /** building payload for a single campaign */
+    static buildCampaignData(query: CampaignPayloadInputModel): {
+        args: any;
+    };
+    static buildPayloadFromConfig(config: SinglePayloadInputDtoModel, debug?: boolean): Promise<safePayload | {
+        safePayload: safePayload;
+        nonEncodedConfig: any;
+    }>;
+    static checkMinimumAmount(rewardToken: string, args: CampaignParametersStruct, distributionChainId: ChainId): Promise<boolean>;
+    static createSafePayloadForCampaign(args: CampaignParametersStruct, distributionChainId: ChainId, rewardToken: string, distributionCreator: string, withApproval?: boolean): Promise<[approvalTransaction, createCampaignTransaction] | [createCampaignTransaction]>;
+    static initiateSafePayload(distributionChainId: ChainId, distributionCreator: string, rewardToken: string, approvalAmount?: string): safePayload;
+    static buildPayload(query: CampaignPayloadInputModel, initialCampaignPayload?: safePayload | null, totalAmount?: string): Promise<safePayload>;
+    static buildProgramPayload(query: ProgramPayloadInputModel): Promise<safePayload | null>;
+    static buildProgramPayloadWithAmounts(query: ProgramPayloadInputModel, body: CampaignAmountsInputModel): Promise<safePayload | null>;
+    static buildConfigFromCampaignData(body: CampaignDataDtoModel): Promise<any>;
+}

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

@@ -0,0 +1,218 @@
+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;
+        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];
+        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 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, args, 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");
+        }
+        const tokenAmount = BigInt(args?.amount.toString());
+        const numberOfHours = BigInt(args?.duration.toString()) / 3600n;
+        return tokenAmount / numberOfHours >= 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);
+        if (!(await ProgramPayloadService.checkMinimumAmount(rewardToken, args, distributionChainId))) {
+            throw new Error("Amount is less than minimum");
+        }
+        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);
+        for (const [campaign, amount] of Object.entries(body)) {
+            if (Object.keys(MerklInterfaceCampaigns[query.program]).includes(campaign)) {
+                const queryCampaign = { ...query, campaign, amount: amount };
+                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.d.ts

@@ -0,0 +1,155 @@
+import Elysia from "elysia";
+export declare const ProtocolController: Elysia<"/protocols", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    protocols: {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    id?: string | undefined;
+                    name?: string | undefined;
+                    items?: number | undefined;
+                    tags?: string[] | undefined;
+                    page?: number | undefined;
+                    ids?: string[] | undefined;
+                    opportunityTag?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: ({
+                        id: string;
+                        name: string;
+                        url: string;
+                        description: string;
+                        tags: string[];
+                        icon: string;
+                    } & {
+                        dailyRewards?: number | undefined;
+                        numberOfLiveCampaigns?: number | undefined;
+                        opportunityLiveTags?: string[] | undefined;
+                    })[];
+                };
+            };
+        };
+    };
+} & {
+    protocols: {
+        count: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: number;
+                };
+            };
+        };
+    };
+} & {
+    protocols: {
+        ":id": {
+            get: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        id: string;
+                        name: string;
+                        url: string;
+                        description: string;
+                        tags: string[];
+                        icon: string;
+                        dailyRewards?: number | undefined;
+                        numberOfLiveCampaigns?: number | undefined;
+                        opportunityLiveTags?: string[] | undefined;
+                    } | null;
+                };
+            };
+        };
+    };
+} & {
+    protocols: {
+        ":id": {
+            patch: {
+                body: {
+                    name?: string | undefined;
+                    url?: string | undefined;
+                    description?: string | undefined;
+                    icon?: string | undefined;
+                };
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        id: string;
+                        name: string;
+                        url: string;
+                        description: string;
+                        tags: string[];
+                        icon: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    protocols: {
+        index: {
+            post: {
+                body: {
+                    id: string;
+                    name: string;
+                    url: string;
+                    description: string;
+                    tags: string[];
+                    icon: string;
+                };
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        id: string;
+                        name: string;
+                        url: string;
+                        description: string;
+                        tags: string[];
+                        icon: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,38 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
+import Elysia, { t } from "elysia";
+import { CreateProtocolDto, GetProtocolsQueryDto, 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), {
+    detail: { description: "Get the number of protocols correspoinding to the query." },
+})
+    // ─── Get A Protocol By Its Id Or Name ────────────────────────────────
+    .get("/:id", async ({ params }) => {
+    const fromId = await ProtocolService.getFromId(params.id);
+    if (fromId)
+        return fromId;
+    return await ProtocolService.getFromName(params.id);
+}, { detail: { hide: true } })
+    // ─── Update A Protocol ───────────────────────────────────────────────
+    .patch("/:id", async ({ params, body }) => await ProtocolService.update(params.id, body), {
+    params: ProtocolIdDto,
+    body: UpdateProtocolDto,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: BackOfficeGuard,
+    detail: { hide: true },
+})
+    // ─── Create A Protocol ───────────────────────────────────────────────
+    .post("/", async ({ body }) => await ProtocolService.create(body), {
+    body: CreateProtocolDto,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: BackOfficeGuard,
+    detail: { hide: true },
+});

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

@@ -0,0 +1,55 @@
+import type { Resource } from "@/modules/v4/prisma";
+/**
+ * Protocol
+ * @description Target description of rewards campaigns
+ * @see {@link Resource}
+ */
+export type Protocol = Resource<"Protocol", undefined, {
+    dailyRewards?: number;
+    numberOfLiveCampaigns?: number;
+    opportunityLiveTags?: string[];
+}>;
+declare const protocolTypes: readonly ["uniswap", "ambient", "arthswap", "baseswap", "camelot", "crust", "fenix", "horiza", "izumi", "kim", "pancakeswap", "quickswap", "ramses", "retro", "stryke", "sushiswap", "swapr", "thruster", "voltage", "zero", "koi", "supswap", "zkswap", "thirdtrade", "velodrome", "aerodrome", "balancer", "curve", "cross_curve", "curveNPool", "aura", "akron", "beefy", "dragonswap", "poolside", "koi", "syncswap", "neptune", "zkSwapThreePool", "syncswap", "rfx", "radiant", "aave", "euler", "gearbox", "compound", "sturdy", "frax", "ionic", "moonwell", "fluid", "silo", "morpho", "coumpound", "dolomite", "badger", "ajna", "layerbank", "ion", "venus", "woofi", "reactor_fusion", "eigenlayer", "vest", "zerolend", "hyperdrive", "gamma", "oku", "hourglass", "veda", "kyo", "sonex", "quickswap-algebra", "velodrome"];
+export type ProtocolId = (typeof protocolTypes)[number];
+export declare const ProtocolResourceDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    icon: import("@sinclair/typebox").TString;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    description: import("@sinclair/typebox").TString;
+    url: import("@sinclair/typebox").TString;
+}>;
+export declare const GetProtocolsQueryDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ids: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    opportunityTag: 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 GetProtocolParamsDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+}>;
+export declare const UpdateProtocolDto: import("@sinclair/typebox").TObject<{
+    icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    url: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const CreateProtocolDto: import("@sinclair/typebox").TObject<{
+    icon: import("@sinclair/typebox").TString;
+    url: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TString;
+    id: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+}>;
+export declare const ProtocolIdDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+}>;
+export type GetProtocolsQueryModel = typeof GetProtocolsQueryDto.static;
+export type GetProtocolModel = typeof GetProtocolParamsDto.static;
+export type UpdateProtocolModel = typeof UpdateProtocolDto.static;
+export type CreateProtocolModel = typeof CreateProtocolDto.static;
+export {};

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

@@ -0,0 +1,115 @@
+import { t } from "elysia";
+const protocolTypes = [
+    // ─── AMM ─────────────────────────────────────────────────────────────
+    "uniswap",
+    "ambient",
+    "arthswap",
+    "baseswap",
+    "camelot",
+    "crust",
+    "fenix",
+    "horiza",
+    "izumi",
+    "kim",
+    "pancakeswap",
+    "quickswap",
+    "ramses",
+    "retro",
+    "stryke",
+    "sushiswap",
+    "swapr",
+    "thruster",
+    "voltage",
+    "zero",
+    "koi",
+    "supswap",
+    "zkswap",
+    "thirdtrade",
+    // ─── LP DEX ──────────────────────────────────────────────────────────
+    "velodrome",
+    "aerodrome",
+    "balancer",
+    "curve",
+    "cross_curve",
+    "curveNPool",
+    "aura",
+    "akron",
+    "beefy",
+    "dragonswap",
+    "poolside",
+    "koi",
+    "syncswap",
+    "neptune",
+    "zkSwapThreePool",
+    "syncswap",
+    "rfx",
+    // ─── LP Lending ──────────────────────────────────────────────────────
+    "radiant",
+    "aave",
+    "euler",
+    "gearbox",
+    "compound",
+    "sturdy",
+    "frax",
+    "ionic",
+    "moonwell",
+    "fluid",
+    "silo",
+    "morpho",
+    "coumpound",
+    "dolomite",
+    "badger",
+    "ajna",
+    "layerbank",
+    "ion",
+    "venus",
+    "woofi",
+    "reactor_fusion",
+    "eigenlayer",
+    "vest",
+    "zerolend",
+    "hyperdrive",
+    "gamma",
+    "oku",
+    "hourglass",
+    "veda",
+    "kyo",
+    "sonex",
+    "quickswap-algebra",
+    "velodrome",
+];
+// ─── 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" })),
+    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() });