@merkl/api 1.0.78 → 1.0.80

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

@@ -0,0 +1,194 @@
+import Elysia from "elysia";
+export declare const ChainController: Elysia<"/chains", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    chains: {
+        ":chainId": {
+            get: {
+                body: unknown;
+                params: {
+                    chainId: number;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        name: string;
+                        id: number;
+                        icon: string;
+                        explorers: {
+                            id: string;
+                            chainId: number;
+                            type: import("@package/databases").ExplorerType;
+                            url: string;
+                        }[];
+                    } | null;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                name?: string | undefined;
+                test?: boolean | undefined;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    explorers?: {
+                        chainId: number;
+                        type: "ETHERSCAN" | "BLOCKSCOUT";
+                        url: string;
+                    }[] | undefined;
+                    name: string;
+                    id: number;
+                    icon: string;
+                }[];
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        count: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    name?: string | undefined;
+                    test?: boolean | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: number;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        ":chainId": {
+            patch: {
+                body: {
+                    icon?: string | undefined;
+                    dailyRewards?: number | undefined;
+                    liveCampaigns?: number | undefined;
+                };
+                params: {
+                    chainId: number;
+                };
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        name: string;
+                        id: number;
+                        icon: string;
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        post: {
+            body: {
+                name: string;
+                id: number;
+                icon: string;
+                explorerType: "ETHERSCAN" | "BLOCKSCOUT";
+                explorerUrl: string;
+            };
+            params: {};
+            query: unknown;
+            headers: {
+                authorization: string;
+            };
+            response: {
+                200: {
+                    Explorer: {
+                        id: string;
+                        chainId: number;
+                        type: import("@package/databases").ExplorerType;
+                        url: string;
+                    }[];
+                    name: string;
+                    id: number;
+                    icon: string;
+                };
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}>;

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

@@ -0,0 +1,52 @@
+import type { ResourceAPI } from "../../../modules/v4/prisma";
+/**
+ * Chain
+ * @description Metadata for each supported network
+ * @see {@link ResourceAPI}
+ */
+export type Chain = ResourceAPI<"Chain">;
+export declare const ChainResourceDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TNumber;
+    name: import("@sinclair/typebox").TString;
+    icon: import("@sinclair/typebox").TString;
+    explorers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        type: import("@sinclair/typebox").TEnum<{
+            readonly ETHERSCAN: "ETHERSCAN";
+            readonly BLOCKSCOUT: "BLOCKSCOUT";
+        }>;
+        url: import("@sinclair/typebox").TString;
+        chainId: import("@sinclair/typebox").TNumber;
+    }>>>;
+}>;
+export declare const GetChainQueryDto: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    test: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+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").TArray<import("@sinclair/typebox").TString>;
+}>;
+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<{
+        readonly ETHERSCAN: "ETHERSCAN";
+        readonly 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.repository.d.ts

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

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

@@ -0,0 +1,83 @@
+import type { ChainSearchDto, CreateChainModel, UpdateChainModel } from "./chain.model";
+export declare abstract class ChainService {
+    static get(chainId: number): Promise<({
+        Explorer: {
+            id: string;
+            chainId: number;
+            type: import("@package/databases").ExplorerType;
+            url: string;
+        }[];
+    } & {
+        name: string;
+        id: number;
+        icon: string;
+    }) | null>;
+    static findAll(): Promise<({
+        Explorer: {
+            id: string;
+            chainId: number;
+            type: import("@package/databases").ExplorerType;
+            url: string;
+        }[];
+    } & {
+        name: string;
+        id: number;
+        icon: string;
+    })[]>;
+    static findMany(query: ChainSearchDto): Promise<({
+        Explorer: {
+            id: string;
+            chainId: number;
+            type: import("@package/databases").ExplorerType;
+            url: string;
+        }[];
+    } & {
+        name: string;
+        id: number;
+        icon: string;
+    })[]>;
+    static findUniqueOrThrow(id: number): Promise<{
+        Explorer: {
+            id: string;
+            chainId: number;
+            type: import("@package/databases").ExplorerType;
+            url: string;
+        }[];
+    } & {
+        name: string;
+        id: number;
+        icon: string;
+    }>;
+    static countMany(query: ChainSearchDto): Promise<number>;
+    /** List all chainIds available in the databse
+     * @warning some chains may not be fully integrated yet
+     * @returns an array of chainId
+     */
+    static findManyIds(): Promise<number[]>;
+    /** List all chainIds which have a distribituor (i.e. which is fully integrated)
+     * @returns an array of chainId
+     */
+    static getSupportedIds(): Promise<number[]>;
+    static create(chain: CreateChainModel): Promise<{
+        Explorer: {
+            id: string;
+            chainId: number;
+            type: import("@package/databases").ExplorerType;
+            url: string;
+        }[];
+    } & {
+        name: string;
+        id: number;
+        icon: string;
+    }>;
+    static update(id: number, data: UpdateChainModel): Promise<{
+        name: string;
+        id: number;
+        icon: string;
+    }>;
+    static updateDailyRewards(id: number, dailyRewards: number): Promise<{
+        name: string;
+        id: number;
+        icon: string;
+    }>;
+}

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

@@ -0,0 +1,2 @@
+declare const ChainInteractionServiceWrapper: (chainId: import("@angleprotocol/sdk/ts").ChainId) => import("@angleprotocol/sdk/ts").ChainInteractionServiceInterface;
+export { ChainInteractionServiceWrapper as ChainInteractionService };

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

@@ -0,0 +1,55 @@
+import Elysia from "elysia";
+export declare const ClaimController: Elysia<"/claims", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    claims: {
+        ":address": {
+            get: {
+                body: unknown;
+                params: {
+                    address: string;
+                };
+                query: {
+                    chainIds: string[];
+                };
+                headers: unknown;
+                response: {
+                    200: (import("./claims.model").ClaimModel & {
+                        token?: import("../token/token.model").Token["model"];
+                    })[];
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}>;

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

@@ -0,0 +1,9 @@
+export type ClaimModel = {
+    timestamp: number;
+    token: string;
+    user: string;
+    amount: string;
+    rawAmount: string;
+    root: string;
+    txHash?: string;
+};

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

@@ -0,0 +1,5 @@
+import { type MerklChainId } from "@angleprotocol/sdk/ts";
+import type { ClaimModel } from "./claims.model";
+export declare class ClaimRepository {
+    static fetch(chainId: MerklChainId, address: string): Promise<ClaimModel[]>;
+}

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

@@ -0,0 +1,9 @@
+import type { ChainId } from "@angleprotocol/sdk/ts";
+import type { Token } from "../../../modules/v4/token/token.model";
+import type { UserUniqueModel } from "../../../modules/v4/user/user.model";
+import type { ClaimModel } from "./claims.model";
+export declare abstract class ClaimService {
+    static getHistoricalClaims(params: UserUniqueModel, chainFilter?: ChainId[]): Promise<(ClaimModel & {
+        token?: Token["model"];
+    })[]>;
+}

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

@@ -0,0 +1,14 @@
+export declare abstract class CoingeckoRepository {
+    static findList(): Promise<{
+        id: string;
+        symbol: string;
+        name: string;
+    }[]>;
+    static findMarkets(ids?: string[]): Promise<{
+        id: string;
+        symbol: string;
+        name: string;
+        image: string;
+        current_price: number;
+    }[]>;
+}

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

@@ -0,0 +1,16 @@
+export declare class CoingeckoService {
+    static findList(): Promise<{
+        id: string;
+        symbol: string;
+        name: string;
+    }[]>;
+    static findMarkets(ids?: string[]): Promise<{
+        id: string;
+        symbol: string;
+        name: string;
+        image: string;
+        current_price: number;
+    }[]>;
+    static createPriceSourceForSymbolIfMissing(symbol: string, ticker: string): Promise<void>;
+    static fillTokensWithCoingeckoData(): Promise<void>;
+}