@merkl/api 0.10.92 → 0.10.94

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

@@ -685,18 +685,17 @@ declare const eden: {
                 query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
             } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: ({
-                    Explorer: {
+                200: {
+                    id: number;
+                    name: string;
+                    icon: string;
+                    explorers: {
                         id: string;
                         type: import("../../database/api/.generated").$Enums.ExplorerType;
                         url: string;
                         chainId: number;
                     }[];
-                } & {
-                    id: number;
-                    name: string;
-                    icon: string;
-                }) | null;
+                } | null;
             }>>;
         }) & {
             index: {
@@ -707,18 +706,17 @@ declare const eden: {
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: ({
-                        Explorer: {
+                    200: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                        explorers: {
                             id: string;
                             type: import("../../database/api/.generated").$Enums.ExplorerType;
                             url: string;
                             chainId: number;
                         }[];
-                    } & {
-                        id: number;
-                        name: string;
-                        icon: string;
-                    })[];
+                    }[];
                 }>>;
             };
             count: {
@@ -732,6 +730,26 @@ declare const eden: {
                     200: number;
                 }>>;
             };
+            explorers: {
+                post: (body: {
+                    type: "ETHERSCAN" | "BLOCKSCOUT";
+                    url: string;
+                    chainId: number;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        id: string;
+                        type: import("../../database/api/.generated").$Enums.ExplorerType;
+                        url: string;
+                        chainId: number;
+                    };
+                }>>;
+            };
         };
         prices: {
             index: {
@@ -2387,24 +2405,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     query: unknown;
                     headers: unknown;
                     response: {
-                        200: ({
-                            Explorer: {
+                        200: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                            explorers: {
                                 id: string;
                                 type: import("../../database/api/.generated").$Enums.ExplorerType;
                                 url: string;
                                 chainId: number;
                             }[];
-                        } & {
-                            id: number;
-                            name: string;
-                            icon: string;
-                        }) | null;
+                        } | null;
                     };
                 };
             };
-        };
-    } & {
-        chains: {
+        } & {
             index: {
                 get: {
                     body: unknown;
@@ -2414,24 +2429,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                     headers: unknown;
                     response: {
-                        200: ({
-                            Explorer: {
+                        200: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                            explorers: {
                                 id: string;
                                 type: import("../../database/api/.generated").$Enums.ExplorerType;
                                 url: string;
                                 chainId: number;
                             }[];
-                        } & {
-                            id: number;
-                            name: string;
-                            icon: string;
-                        })[];
+                        }[];
                     };
                 };
             };
-        };
-    } & {
-        chains: {
+        } & {
             count: {
                 get: {
                     body: unknown;
@@ -2445,6 +2457,29 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
+        } & {
+            explorers: {
+                post: {
+                    body: {
+                        type: "ETHERSCAN" | "BLOCKSCOUT";
+                        url: string;
+                        chainId: number;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            id: string;
+                            type: import("../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            chainId: number;
+                        };
+                    };
+                };
+            };
         };
     };
 } & {
@@ -4209,18 +4244,17 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
             } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: ({
-                    Explorer: {
+                200: {
+                    id: number;
+                    name: string;
+                    icon: string;
+                    explorers: {
                         id: string;
                         type: import("../../database/api/.generated").$Enums.ExplorerType;
                         url: string;
                         chainId: number;
                     }[];
-                } & {
-                    id: number;
-                    name: string;
-                    icon: string;
-                }) | null;
+                } | null;
             }>>;
         }) & {
             index: {
@@ -4231,18 +4265,17 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: ({
-                        Explorer: {
+                    200: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                        explorers: {
                             id: string;
                             type: import("../../database/api/.generated").$Enums.ExplorerType;
                             url: string;
                             chainId: number;
                         }[];
-                    } & {
-                        id: number;
-                        name: string;
-                        icon: string;
-                    })[];
+                    }[];
                 }>>;
             };
             count: {
@@ -4256,6 +4289,26 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     200: number;
                 }>>;
             };
+            explorers: {
+                post: (body: {
+                    type: "ETHERSCAN" | "BLOCKSCOUT";
+                    url: string;
+                    chainId: number;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        id: string;
+                        type: import("../../database/api/.generated").$Enums.ExplorerType;
+                        url: string;
+                        chainId: number;
+                    };
+                }>>;
+            };
         };
         prices: {
             index: {
@@ -5082,6 +5135,7 @@ export type Opportunity = FromPromise<Api["v4"]["opportunities"]["index"]["get"]
 export type Protocol = FromPromise<Api["v4"]["protocols"]["index"]["get"]>;
 export type Campaign<C extends CampaignType = CampaignType> = CampaignResource<C>["model"];
 export type Chain = FromPromise<Api["v4"]["chains"]["index"]["get"]>;
+export type Explorer = FromPromise<Api["v4"]["chains"]["index"]["get"]>["explorers"][number];
 export type Token = FromPromise<Api["v4"]["tokens"]["index"]["get"]>;
 export type Reward = NonNullable<Awaited<ReturnType<ReturnType<Api["v4"]["users"]>["rewards"]["full"]["get"]>>["data"]>[number];
 export {};

package/dist/src/index.d.ts

@@ -824,24 +824,21 @@ declare const app: Elysia<"", false, {
                     query: unknown;
                     headers: unknown;
                     response: {
-                        200: ({
-                            Explorer: {
+                        200: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                            explorers: {
                                 id: string;
                                 type: import("../database/api/.generated").$Enums.ExplorerType;
                                 url: string;
                                 chainId: number;
                             }[];
-                        } & {
-                            id: number;
-                            name: string;
-                            icon: string;
-                        }) | null;
+                        } | null;
                     };
                 };
             };
-        };
-    } & {
-        chains: {
+        } & {
             index: {
                 get: {
                     body: unknown;
@@ -851,24 +848,21 @@ declare const app: Elysia<"", false, {
                     };
                     headers: unknown;
                     response: {
-                        200: ({
-                            Explorer: {
+                        200: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                            explorers: {
                                 id: string;
                                 type: import("../database/api/.generated").$Enums.ExplorerType;
                                 url: string;
                                 chainId: number;
                             }[];
-                        } & {
-                            id: number;
-                            name: string;
-                            icon: string;
-                        })[];
+                        }[];
                     };
                 };
             };
-        };
-    } & {
-        chains: {
+        } & {
             count: {
                 get: {
                     body: unknown;
@@ -882,6 +876,29 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
+        } & {
+            explorers: {
+                post: {
+                    body: {
+                        type: "ETHERSCAN" | "BLOCKSCOUT";
+                        url: string;
+                        chainId: number;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            id: string;
+                            type: import("../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            chainId: number;
+                        };
+                    };
+                };
+            };
         };
     };
 } & {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.d.ts

@@ -1,51 +1,51 @@
 import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
 export declare enum tokenType {
-    uniswapv2 = "uniswapv2",
+    aura = "aura",
     poolside = "poolside",
     balancerGauge = "balancerGauge",
-    balancerPool = "balancerPool",
-    unknown = "unknown",
     gearbox = "gearbox",
+    euler_borrow = "euler_borrow",
+    euler_lend = "euler_lend",
+    filament = "filament",
+    fluid = "fluid",
     compound = "compound",
-    radiant_borrow = "radiant_borrow",
     radiant_lend = "radiant_lend",
-    fluid = "fluid",
+    radiant_borrow = "radiant_borrow",
     ionic = "ionic",
-    metamorpho = "metamorpho",
-    aerodrome = "aerodrome",
-    velodrome = "velodrome",
+    layerbank = "layerbank",
     moonwell = "moonwell",
-    aave_lending = "aave_lending",
+    yei_borrowing = "yei_borrowing",
+    ironclad_borrowing = "ironclad_borrowing",
+    zerolend_borrowing = "zerolend_borrowing",
+    yei_lending = "yei_lending",
+    ironclad_lending = "ironclad_lending",
+    zerolend_lending = "zerolend_lending",
     aave_borrowing = "aave_borrowing",
-    fraxlend = "fraxlend",
-    curve = "curve",
+    aave_lending = "aave_lending",
     sturdy_aggregator = "sturdy_aggregator",
     sturdy_silo = "sturdy_silo",
+    fraxlend = "fraxlend",
+    uniswapv2 = "uniswapv2",
+    fenix = "fenix",
+    ra = "ra",
+    syncswap = "syncswap",
+    curve_2 = "curve_2",
+    silostaking = "silostaking",
+    beefy = "beefy",
+    balancerPool = "balancerPool",
+    unknown = "unknown",
+    metamorpho = "metamorpho",
+    aerodrome = "aerodrome",
+    velodrome = "velodrome",
+    curve = "curve",
     splice = "splice",// todo
     toros = "toros",// todo
-    curve_2 = "curve_2",
-    aura = "aura",
     akron = "akron",
     enzyme = "enzyme",
     dragonswap = "dragonswap",
-    silostaking = "silostaking",
-    euler_lend = "euler_lend",
-    euler_borrow = "euler_borrow",
     koi = "koi",
     baseswap = "baseswap",
-    layerbank = "layerbank",
-    beefy = "beefy",
-    fenix = "fenix",
     zkswap = "zkswap",
-    filament = "filament",
-    syncswap = "syncswap",
-    ra = "ra",
-    yei_borrowing = "yei_borrowing",
-    yei_lending = "yei_lending",
-    zerolend_borrowing = "zerolend_borrowing",
-    zerolend_lending = "zerolend_lending",
-    ironclad_lending = "ironclad_lending",
-    ironclad_borrowing = "ironclad_borrowing",
     pendle = "pendle",
     ironcladStaking = "ironcladStaking"
 }

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/AaveProcessor.d.ts

@@ -1,5 +1,5 @@
 import type { Pricer } from "../../../../../utils/pricer";
-import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Campaign, CampaignParameters } from "@sdk";
 import type { tokenType } from "../helpers/tokenType";
 import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
 type callType = {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GenericProcessor.d.ts

@@ -20,11 +20,13 @@ export type callKeys = {
     tokenAddress: string;
     blacklistedSupply: string;
     totalSupply: string;
+    whitelistedSupply: string;
 };
 export type dataRaw = {
     tokenAddress: string;
     blacklistedSupply: string;
     totalSupply: string;
+    whitelistedSupply: string;
 };
 export type dataType = {
     tokenAddress: string;
@@ -33,6 +35,7 @@ export type dataType = {
     tvl: number;
     cardName: string;
     priceTargetToken: number;
+    whitelistedSupplyTargetToken: number;
 };
 export declare class GenericProcessor<Input extends callKeys, DataRaw extends dataRaw, Output extends dataType> {
     rounds: {
@@ -46,14 +49,20 @@ export declare class GenericProcessor<Input extends callKeys, DataRaw extends da
     processingRound2(typeInfo: DataRaw): void;
     processingRound3(typeInfo: DataRaw): void;
     processingRound4(typeInfo: DataRaw): void;
+    handleWhiteListBlacklistRound5(typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): {
+        whitelistedSupplyTargetToken: number;
+        totalSupply: any;
+        blacklistedSupply: number;
+    };
     processingRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<Output>;
     computeRound1(type: tokenType, typeInfo: DataRaw): tokenTypeStruct;
     computeRound2(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
     computeRound3(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
     computeRound4(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
     computeRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+    generateWhitelistCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20>): Multicall3.Call3Struct[];
     generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20>): Multicall3.Call3Struct[];
-    decodeBlackListedSupply(index: number, decimals: number, blacklist: string[], calls: string[]): string;
+    decodeListedSupply(index: number, decimals: number, list: string[], calls: string[]): string;
     decodeRound(round: callType[], index: number, calls: string[], type: tokenType, data: DataRaw): void;
     decodePreviousRound(round: roundType, calls: string[], data: DataRaw, type: tokenType, index: number): void;
     encodeRound(round: callType[], callInfo: Input, type: tokenType): Multicall3.Call3Struct[];

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/MetamorphoProcessor.d.ts

@@ -1,5 +1,5 @@
 import type { Pricer } from "../../../../../utils/pricer";
-import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Campaign, CampaignParameters } from "@sdk";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
 type callType = {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SpliceProcessor.d.ts

@@ -1,5 +1,5 @@
 import type { Pricer } from "../../../../../utils/pricer";
-import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Campaign, CampaignParameters } from "@sdk";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
 type callKeysSplice = callKeys & {

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

@@ -21,24 +21,21 @@ export declare const ChainController: Elysia<"/chains", false, {
                 query: unknown;
                 headers: unknown;
                 response: {
-                    200: ({
-                        Explorer: {
+                    200: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                        explorers: {
                             id: string;
                             type: import("../../../../database/api/.generated").$Enums.ExplorerType;
                             url: string;
                             chainId: number;
                         }[];
-                    } & {
-                        id: number;
-                        name: string;
-                        icon: string;
-                    }) | null;
+                    } | null;
                 };
             };
         };
-    };
-} & {
-    chains: {
+    } & {
         index: {
             get: {
                 body: unknown;
@@ -48,24 +45,21 @@ export declare const ChainController: Elysia<"/chains", false, {
                 };
                 headers: unknown;
                 response: {
-                    200: ({
-                        Explorer: {
+                    200: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                        explorers: {
                             id: string;
                             type: import("../../../../database/api/.generated").$Enums.ExplorerType;
                             url: string;
                             chainId: number;
                         }[];
-                    } & {
-                        id: number;
-                        name: string;
-                        icon: string;
-                    })[];
+                    }[];
                 };
             };
         };
-    };
-} & {
-    chains: {
+    } & {
         count: {
             get: {
                 body: unknown;
@@ -79,6 +73,29 @@ export declare const ChainController: Elysia<"/chains", false, {
                 };
             };
         };
+    } & {
+        explorers: {
+            post: {
+                body: {
+                    type: "ETHERSCAN" | "BLOCKSCOUT";
+                    url: string;
+                    chainId: number;
+                };
+                params: Record<never, string>;
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        id: string;
+                        type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+                        url: string;
+                        chainId: number;
+                    };
+                };
+            };
+        };
     };
 }, {
     derive: {};

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

@@ -14,6 +14,14 @@ export declare const ChainUniqueDto: import("@sinclair/typebox").TObject<{
 export declare const ChainArrayDto: import("@sinclair/typebox").TObject<{
     chainId: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
 }>;
+export declare const CreateChainExplorerDto: import("@sinclair/typebox").TObject<{
+    type: import("@sinclair/typebox").TEnum<{
+        ETHERSCAN: "ETHERSCAN";
+        BLOCKSCOUT: "BLOCKSCOUT";
+    }>;
+    chainId: import("@sinclair/typebox").TNumber;
+    url: import("@sinclair/typebox").TString;
+}>;
 export type ChainUniqueModel = typeof ChainUniqueDto.static;
 export type ChainSearchDto = typeof GetChainQueryDto.static;
 export type ChainsArrayModel = typeof ChainArrayDto.static;

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

@@ -0,0 +1,7 @@
+import type { Resource } from "../prisma";
+/**
+ * Explorer
+ * @description A chain explorer
+ * @see {@link Resource}
+ */
+export type Explorer = Resource<"Explorer", "id">;

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

@@ -1,3 +1,4 @@
+import type { ExplorerType } from "../../../../database/api/.generated";
 export declare abstract class ExplorerRepository {
     static getByChainId(chainId: number): Promise<{
         id: string;
@@ -5,4 +6,16 @@ export declare abstract class ExplorerRepository {
         url: string;
         chainId: number;
     }>;
+    /**
+     * Creates an explorer
+     * @param chainId to attach explorer to
+     * @param type that defines the subsequents links for transactions, addresses...
+     * @param url base url without / suffix
+     */
+    static create(chainId: number, type: ExplorerType, url: string): Promise<{
+        id: string;
+        type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    }>;
 }

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

@@ -1,8 +1,28 @@
+import type { ExplorerType } from "../../../../database/api/.generated";
+import type { Explorer } from "./explorer.model";
 export declare abstract class ExplorerService {
+    static hashId(type: ExplorerType, chainId: number): string;
     static getByChainId(chainId: number): Promise<{
         id: string;
         type: import("../../../../database/api/.generated").$Enums.ExplorerType;
         url: string;
         chainId: number;
     }>;
+    static format(explorer: Explorer["raw"]): {
+        type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    };
+    /**
+     * Creates an explorer
+     * @param chainId to attach explorer to
+     * @param type that defines the subsequents links for transactions, addresses...
+     * @param url base url without / suffix
+     */
+    static create(chainId: number, type: ExplorerType, url: string): Promise<{
+        id: string;
+        type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    }>;
 }