@merkl/api 0.15.40 → 0.15.42

package/dist/src/eden/index.d.ts

@@ -1739,6 +1739,28 @@ declare const eden: {
                         }[];
                     }[];
                 }>>;
+                post: (body: {
+                    name: string;
+                    id: number;
+                    icon: string;
+                    explorerType: "ETHERSCAN" | "BLOCKSCOUT";
+                    explorerUrl: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        Explorer: {
+                            type: import("../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            id: string;
+                            chainId: number;
+                        }[];
+                    };
+                }>>;
             };
             count: {
                 get: (options: {
@@ -4839,6 +4861,28 @@ declare const eden: {
                         }[];
                     }[];
                 }>>;
+                post: (body: {
+                    name: string;
+                    id: number;
+                    icon: string;
+                    explorerType: "ETHERSCAN" | "BLOCKSCOUT";
+                    explorerUrl: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        Explorer: {
+                            type: import("../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            id: string;
+                            chainId: number;
+                        }[];
+                    };
+                }>>;
             };
             count: {
                 get: (options: {
@@ -9006,6 +9050,35 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
+    } & {
+        chains: {
+            index: {
+                post: {
+                    body: {
+                        name: string;
+                        id: number;
+                        icon: string;
+                        explorerType: "ETHERSCAN" | "BLOCKSCOUT";
+                        explorerUrl: string;
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            Explorer: {
+                                type: import("../../database/api/.generated").$Enums.ExplorerType;
+                                url: string;
+                                id: string;
+                                chainId: number;
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {
@@ -13388,6 +13461,28 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         }[];
                     }[];
                 }>>;
+                post: (body: {
+                    name: string;
+                    id: number;
+                    icon: string;
+                    explorerType: "ETHERSCAN" | "BLOCKSCOUT";
+                    explorerUrl: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        Explorer: {
+                            type: import("../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            id: string;
+                            chainId: number;
+                        }[];
+                    };
+                }>>;
             };
             count: {
                 get: (options: {
@@ -16488,6 +16583,28 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         }[];
                     }[];
                 }>>;
+                post: (body: {
+                    name: string;
+                    id: number;
+                    icon: string;
+                    explorerType: "ETHERSCAN" | "BLOCKSCOUT";
+                    explorerUrl: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        Explorer: {
+                            type: import("../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            id: string;
+                            chainId: number;
+                        }[];
+                    };
+                }>>;
             };
             count: {
                 get: (options: {

package/dist/src/index.d.ts

@@ -2108,6 +2108,35 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        chains: {
+            index: {
+                post: {
+                    body: {
+                        name: string;
+                        id: number;
+                        icon: string;
+                        explorerType: "ETHERSCAN" | "BLOCKSCOUT";
+                        explorerUrl: string;
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            Explorer: {
+                                type: import("../database/api/.generated").$Enums.ExplorerType;
+                                url: string;
+                                id: string;
+                                chainId: number;
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/jobs/etl/reward-breakdowns.js

@@ -1,9 +1,9 @@
 // ─── Reward Breakdowns ETL ───────────────────────────────────────────────────
-if (!process.env.ENV || !process.env.CHAIN_ID || !process.env.ROOT)
+if (!process.env.DATABASE_API_URL || !process.env.ENV || !process.env.CHAIN_ID || !process.env.ROOT)
     throw new Error("[ENV]: missing variable");
+import { BucketService } from "../../modules/v4/bucket/bucket.service";
 import { log } from "../../utils/logger";
 import { apiDbClient } from "../../utils/prisma";
-import { withRetry } from "@sdk";
 import { S3Client } from "bun";
 import moment from "moment";
 // ─── Global Variables ────────────────────────────────────────
@@ -13,10 +13,9 @@ const gcsClient = new S3Client({
     endpoint: process.env.GCS_ENDPOINT,
     bucket: `merkl-rewards-lake-${process.env.ENV}`,
 });
-let file = gcsClient.file(`breakdowns/${process.env.CHAIN_ID}-${process.env.ROOT}`);
-if (!(await file.exists()))
-    file = gcsClient.file(`breakdowns/${process.env.CHAIN_ID}-${process.env.ROOT}.gz`);
+const file = gcsClient.file(`breakdowns/${process.env.CHAIN_ID}-${process.env.ROOT}`);
 const failedBatches = [];
+const missingCampaigns = [];
 // ─── Extract ─────────────────────────────────────────────────────────────────
 const extract = async () => {
     if (!file.exists())
@@ -30,106 +29,115 @@ const extract = async () => {
         buffer += textDecoder.decode(chunk);
         const lines = buffer.split("\n");
         buffer = lines.pop() || "";
-        for (const line of lines)
-            if (line.trim()) {
+        for (const line of lines) {
+            if (line.trim())
                 data.push(...(await transform(JSON.parse(line))));
-            }
+        }
         if (data.length < 30_000)
             continue;
         try {
-            count += await withRetry(load, [data], 5, 60_000);
+            count += await load(data);
             data = [];
         }
         catch (err) {
-            console.error(`Failed to insert a batch, adding it to the fail queue.\n${err}`);
+            // log.error("Failed to insert a batch, adding it to the fail queue.", err);
             failedBatches.push(data);
             data = [];
         }
     }
     try {
-        count += await withRetry(load, [data], 5, 60_000);
+        count += await load(data);
         data = [];
     }
     catch (err) {
-        console.error(`Failed to insert a batch, adding it to the fail queue.\n${err}`);
+        // log.error("Failed to insert a batch, adding it to the fail queue.", err);
         failedBatches.push(data);
         data = [];
     }
     return count;
 };
 // ─── Transform ───────────────────────────────────────────────────────────────
-const transform = async (rewardBreakdowns) => {
-    const transformedRewardBreakdowns = [];
-    for (const rewardBreakdown of rewardBreakdowns) {
-        const rewardTokenId = Bun.hash(`${process.env.CHAIN_ID}${rewardBreakdown.token}`).toString();
-        const rewardId = Bun.hash(`${process.env.ROOT}${rewardBreakdown.recipient}${rewardTokenId}`).toString();
-        transformedRewardBreakdowns.push({
+const transform = (rewardBreakdowns) => {
+    const transformedBreakdowns = Array(rewardBreakdowns.length);
+    let i = 0;
+    for (i; i < rewardBreakdowns.length; i++) {
+        const rewardTokenId = Bun.hash(`${process.env.CHAIN_ID}${rewardBreakdowns[i].token}`).toString();
+        const rewardId = Bun.hash(`${process.env.ROOT}${rewardBreakdowns[i].recipient}${rewardTokenId}`).toString();
+        const campaignId = Bun.hash(`${process.env.CHAIN_ID}${rewardBreakdowns[i].campaignId}`).toString();
+        transformedBreakdowns[i] = {
             rewardId,
-            protocolId: rewardBreakdown.protocolId ? rewardBreakdown.protocolId : undefined,
-            campaignId: rewardBreakdown.campaignId,
-            reason: rewardBreakdown.reason ? rewardBreakdown.reason : "",
-            amount: rewardBreakdown.amount,
-            claimed: rewardBreakdown.claimed,
-            pending: rewardBreakdown.pending,
-        });
+            protocolId: rewardBreakdowns[i].protocolId ? rewardBreakdowns[i].protocolId : undefined,
+            campaignId,
+            reason: rewardBreakdowns[i].reason ? rewardBreakdowns[i].reason : "",
+            amount: rewardBreakdowns[i].amount,
+            claimed: rewardBreakdowns[i].claimed,
+            pending: rewardBreakdowns[i].pending,
+            merklCampaignId: rewardBreakdowns[i].campaignId,
+        };
     }
-    return transformedRewardBreakdowns;
+    return transformedBreakdowns;
 };
 // ─── Load ────────────────────────────────────────────────────────────────────
 const load = async (rewardBreakdowns) => {
-    log.info(`pushing ${rewardBreakdowns.length} rewardBreakdowns`);
-    // const missingCampaigns: string[] = [];
-    // const foundCampaigns: string[] = [];
-    // const campaigns = rewardBreakdowns.reduce(
-    //   (acc, x) => {
-    //     const campaignUnique = {
-    //       campaignId: x.campaignId,
-    //       distributionChain: Number.parseInt(process.env.CHAIN_ID!),
-    //     };
-    //     if (!Object.keys(acc).includes(CampaignService.hashId(campaignUnique)))
-    //       acc[CampaignService.hashId(campaignUnique)] = {
-    //         campaignId: x.campaignId,
-    //         distributionChain: Number.parseInt(process.env.CHAIN_ID!),
-    //       };
-    //     return acc;
-    //   },
-    //   {} as Record<string, CampaignUnique>
-    // );
-    // for (const campaign of Object.values(campaigns)) {
-    //   const campaignExists = await CampaignService.checkIfExist(campaign);
-    //   if (!campaignExists) {
-    //     const { success, fail } = await CampaignService.fill([campaign]);
-    //     if (fail === 1 || success !== 1) {
-    //       missingCampaigns.push(CampaignService.hashId(campaign));
-    //       log.warn(`createManyBreakdown - Missing campaign: ${campaign.campaignId}`);
-    //       continue;
-    //     }
-    //   }
-    //   foundCampaigns.push(CampaignService.hashId(campaign));
-    // }
-    // if (missingCampaigns.length !== 0) {
-    //   log.warn(`createManyBreakdown - Missing ${missingCampaigns.length} campaigns: ${missingCampaigns.join(", ")}`);
-    // }
-    return (await apiDbClient.rewardBreakdown.createMany({
-        data: rewardBreakdowns.map(x => {
-            const campaignId = Bun.hash(`${process.env.CHAIN_ID}${x.campaignId}`).toString();
-            return { ...x, campaignId };
-        }),
-        // .filter(x => !missingCampaigns.includes(x.campaignId)),
+    const count = (await apiDbClient.rewardBreakdown.createMany({
+        data: rewardBreakdowns,
         skipDuplicates: true,
     })).count;
+    log.info(`Successfully inserted ${rewardBreakdowns.length} reward breakdown(s).`);
+    return count;
+};
+// ─── Retry ───────────────────────────────────────────────────────────────────
+// Using binary search
+const retry = async (batches) => {
+    log.info(`Retrying ${batches.length} batch(es)...`);
+    let inserted = 0;
+    while (batches.length > 0) {
+        const currentBatch = batches.shift();
+        const firstHalf = currentBatch.splice(0, Math.ceil(currentBatch.length / 2));
+        const secondHalf = currentBatch;
+        // Process first half
+        try {
+            inserted += await load(firstHalf);
+        }
+        catch (err) {
+            log.error(JSON.stringify(firstHalf), err);
+            if (firstHalf.length > 1)
+                batches.push(firstHalf);
+            else
+                missingCampaigns.push(firstHalf[0].merklCampaignId);
+        }
+        // Process second half
+        try {
+            inserted += await load(secondHalf);
+        }
+        catch (err) {
+            log.error(JSON.stringify(secondHalf), err);
+            if (secondHalf.length > 1)
+                batches.push(secondHalf);
+            else
+                missingCampaigns.push(secondHalf[0].merklCampaignId);
+        }
+    }
+    return inserted;
 };
 // ─── Main ────────────────────────────────────────────────────────────────────
 export const main = async () => {
     const start = moment().unix();
     const count = await extract();
-    log.info(`✅ Successfully created ${count} new records for ${process.env.CHAIN_ID}-${process.env.ROOT} in ${moment().unix() - start} sec`);
+    log.info(`✅ Successfully created ${count} new record(s) for ${process.env.CHAIN_ID}-${process.env.ROOT} in ${moment().unix() - start} sec.`);
     if (failedBatches.length !== 0) {
-        log.error("breakdowns", `${failedBatches.length} batches failed.`);
-        process.exit(1);
-    }
-    if (failedBatches.length === 0) {
-        // await file.delete();
+        const inserted = await retry(failedBatches);
+        log.info(`Successfully inserted ${inserted} record(s) after retrying.`);
+        if (inserted !== failedBatches.length) {
+            log.error("breakdowns", `${failedBatches.length} breakdown(s) failed to insert.`);
+            // ─── Push Missing Campaigns To Bucket ────────────────
+            const bucket = new BucketService(`merkl-campaigns-lake-${process.env.ENV}`, `merkl-data-${process.env.ENV}`);
+            await bucket.push(`${process.env.CHAIN_ID}_missing_campaigns`, JSON.stringify(missingCampaigns), {
+                type: "application/json",
+            });
+            process.exit(1);
+        }
     }
+    // if (failedBatches.length === 0) await file.delete();
 };
 main();

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

@@ -4,7 +4,7 @@ export declare class BucketService {
     defaultUploadOptions: UploadOptions<unknown>;
     constructor(bucket: string, projectId: string);
     pushArray<T>(filename: string, arr: T[], options?: UploadOptions<T>): Promise<number>;
-    push(filename: string, text: string, options?: Omit<UploadOptions<never>, "transform">): Promise<number>;
+    push(filename: string, text: string, options?: Omit<UploadOptions<never>, "transform" | "separator">): Promise<number>;
     pullArray<T>(filename: string, callback: (elem: string) => T, separator?: string): Promise<T[]>;
     pull(filename: string): Promise<string>;
 }

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

@@ -103,6 +103,35 @@ export declare const ChainController: Elysia<"/chains", false, {
             };
         };
     };
+} & {
+    chains: {
+        index: {
+            post: {
+                body: {
+                    name: string;
+                    id: number;
+                    icon: string;
+                    explorerType: "ETHERSCAN" | "BLOCKSCOUT";
+                    explorerUrl: string;
+                };
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        Explorer: {
+                            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            id: string;
+                            chainId: number;
+                        }[];
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

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

@@ -1,6 +1,6 @@
 import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
 import Elysia, { t } from "elysia";
-import { ChainResourceDto, ChainUniqueDto, GetChainQueryDto, UpdateChainDto } from "./chain.model";
+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"] } })
@@ -35,4 +35,10 @@ export const ChainController = new Elysia({ prefix: "/chains", detail: { tags: [
     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

@@ -25,6 +25,17 @@ export declare const ChainArrayOptionalDto: import("@sinclair/typebox").TObject<
 export declare const UpdateChainDto: import("@sinclair/typebox").TObject<{
     icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
+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

@@ -1,3 +1,4 @@
+import { ExplorerType } from "../../../../database/api/.generated";
 import { t } from "elysia";
 // ─── DTOs ────────────────────────────────────────────────────────────────────
 export const ChainResourceDto = t.Object({
@@ -26,3 +27,10 @@ export const UpdateChainDto = t.Object({
     icon: t.Optional(t.String({ format: "uri" })),
     // 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

@@ -1,5 +1,5 @@
 import type { Campaign, CampaignParameters } from "@sdk";
-import type { Chain, ChainSearchDto, UpdateChainModel } from "./chain.model";
+import type { ChainSearchDto, CreateChainModel, UpdateChainModel } from "./chain.model";
 export declare abstract class ChainRepository {
     #private;
     /**
@@ -45,16 +45,27 @@ export declare abstract class ChainRepository {
      * @param template for chain creation
      * @returns
      */
-    static create(template: Chain["action"]["create"]["args"]): Promise<{
-        name: string;
-        id: number;
-        icon: string;
+    static create(data: CreateChainModel): Promise<{
+        Explorer: {
+            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+            url: string;
+            id: string;
+            chainId: number;
+        }[];
     }>;
     static findMany(): Promise<{
         name: string;
         id: number;
         icon: string;
     }[]>;
+    static findUniqueOrThrow(id: number): Promise<{
+        Explorer: {
+            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+            url: string;
+            id: string;
+            chainId: number;
+        }[];
+    }>;
     /**
      * Fetches the campaign dynamic data for a v3 campaign onchain
      * @param chainId

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

@@ -1,6 +1,7 @@
 import { campaignsDynamicData } from "../../../libs/campaigns/campaignsDynamicData";
 import { executeSimple } from "../../../utils/execute";
 import { apiDbClient } from "../../../utils/prisma";
+import { ExplorerRepository } from "../explorer/explorer.repository";
 export class ChainRepository {
     /**
      * @param id ChainId
@@ -44,12 +45,30 @@ export class ChainRepository {
      * @param template for chain creation
      * @returns
      */
-    static async create(template) {
-        return apiDbClient.chain.create(template);
+    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 findMany() {
         return apiDbClient.chain.findMany();
     }
+    static async findUniqueOrThrow(id) {
+        return apiDbClient.chain.findUniqueOrThrow({
+            where: {
+                id,
+            },
+            select: {
+                Explorer: true,
+            },
+        });
+    }
     /**
      * Fetches the campaign dynamic data for a v3 campaign onchain
      * @param chainId

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

@@ -1,4 +1,4 @@
-import type { ChainSearchDto, UpdateChainModel } from "./chain.model";
+import type { ChainSearchDto, CreateChainModel, UpdateChainModel } from "./chain.model";
 export declare abstract class ChainService {
     static get(chainId: number): Promise<({
         Explorer: {
@@ -39,6 +39,14 @@ export declare abstract class ChainService {
      * @returns an array of chainId
      */
     static getSupportedIds(): Promise<number[]>;
+    static create(chain: CreateChainModel): Promise<{
+        Explorer: {
+            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+            url: string;
+            id: string;
+            chainId: number;
+        }[];
+    }>;
     static update(id: number, data: UpdateChainModel): Promise<{
         name: string;
         id: number;

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

@@ -39,11 +39,10 @@ export class ChainService {
         }
         return supportedIds;
     }
+    static async create(chain) {
+        return await ChainRepository.create(chain);
+    }
     static async update(id, data) {
-        // let iconUri = data.icon;
-        // if (data.iconFile) {
-        //   iconUri = await BucketService.upload("merkl-assets", `/chains/${id}`, data.iconFile.stream(), true);
-        // }
         return await ChainRepository.update(id, data);
     }
 }

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

@@ -25,14 +25,46 @@ export declare abstract class ProtocolRepository {
         tags: string[];
         icon: string;
     }[]>;
-    static findMany(query: GetProtocolsQueryModel): Promise<{
+    static findMany(query: GetProtocolsQueryModel): Promise<({
+        MainOpportunities: ({
+            Campaigns: {
+                type: import("../../../../database/api/.generated").$Enums.CampaignType;
+                id: string;
+                params: import("database/api/.generated/runtime/library").JsonValue;
+                subType: number | null;
+                startTimestamp: bigint;
+                endTimestamp: bigint;
+                computeChainId: number;
+                distributionChainId: number;
+                campaignId: string;
+                rewardTokenId: string;
+                amount: string;
+                opportunityId: string;
+                creatorAddress: string;
+            }[];
+        } & {
+            name: string;
+            type: import("../../../../database/api/.generated").$Enums.CampaignType;
+            id: string;
+            status: import("../../../../database/api/.generated").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            chainId: number;
+            action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        })[];
+    } & {
         name: string;
         url: string;
         description: string;
         id: string;
         tags: string[];
         icon: string;
-    }[]>;
+    })[]>;
     static countMany(query: GetProtocolsQueryModel): Promise<number>;
     static update(id: string, data: UpdateProtocolModel): Promise<{
         name: string;