@merkl/api 1.0.78 → 1.0.80

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

@@ -0,0 +1,138 @@
+import { type ChainId } from "@angleprotocol/sdk/ts";
+import type { GetTokenQueryModel, Token, TokenModel, UpdateTokenModel } from "./token.model";
+export declare abstract class TokenRepository {
+    #private;
+    /**
+     * Fetch token metadata from onchain
+     * @param chainId
+     * @param address
+     */
+    static getTokenInfo(token: TokenModel): Promise<{
+        name: string;
+        symbol: string;
+        decimals: number;
+    }>;
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static findUnique(id: string): Promise<Token["model"] | undefined>;
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static findUniqueOrThrow(id: string): Promise<Token["model"]>;
+    /**
+     * Read token from database by its symbol
+     * @param symbol
+     */
+    static findMany(query: GetTokenQueryModel): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    }[]>;
+    static findFirst(query: Omit<GetTokenQueryModel, "page" | "items">): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    } | null>;
+    static findList(chainId: number, addresses: string[]): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    }[]>;
+    static countMany(query: GetTokenQueryModel): Promise<number>;
+    /**
+     * upsert a token on database
+     * @param token
+     */
+    static upsert(token: Token["model"]): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    }>;
+    /**
+     * Updates price of tokens that share the same symbol
+     * @param symbol
+     * @param price value
+     * @param excludeAddresses to not update even if symbol match
+     */
+    static updateSymbolPrices(symbol: string, price: number, excludeAddresses: string[]): Promise<import("@package/databases").BatchPayload>;
+    /**
+     * Updates price of tokens that share the same address
+     * @param address
+     * @param price value
+     * @param chainId
+     */
+    static updateAddressPrices(address: string, price: number, chainId?: number): Promise<import("@package/databases").BatchPayload>;
+    static updateMissingIconsPerSymbol(symbol: string, icon: string): Promise<import("@package/databases").BatchPayload>;
+    static fetchIconFromCoingeckoTicker(coingeckoTicker: string): Promise<any>;
+    static findChains(): Promise<Record<string, ChainId>>;
+    /**
+     * create a token on database
+     * @param token
+     */
+    static create(token: Token["model"]): Promise<Token["model"] | undefined>;
+    static update(id: string, data: UpdateTokenModel): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    }>;
+}

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

@@ -0,0 +1,361 @@
+import { type Campaign, type CampaignParameters, type ChainId } from "@angleprotocol/sdk/ts";
+import { Prisma } from "@package/databases/api";
+import type { Pricer } from "../../../utils/pricer";
+import type { CreateTokenModel, NotionWebhookModel } from "./token.model";
+import type { GetTokenQueryModel, Token, TokenModel, TokenUnique, UpdateTokenModel } from "./token.model";
+import { TokenRepository } from "./token.repository";
+export declare abstract class TokenService {
+    static hashId(token: TokenUnique): string;
+    static format(token: Awaited<ReturnType<typeof TokenRepository.findMany>>[number]): Token["model"];
+    static fetchNativeBalance(chainId: number, userAddress: string): Promise<import("ethers").BigNumber>;
+    /**
+     * Fetches balances of provided tokens
+     */
+    static fetchBalances(chainId: number, userAddress: string, tokens: Token["model"][]): Promise<(Token["model"] & {
+        balance: bigint;
+    })[]>;
+    /**
+     * Fetches tokens and include balances
+     */
+    static fetchTokensAndBalances(chainId: number, userAddress: string, addresses: string[]): Promise<({
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+        isTokenWrapper?: boolean | undefined;
+        tokenWrapperAddress?: string | undefined;
+    } & {
+        balance: bigint;
+    })[]>;
+    /**
+     * Fetches balances of verified tokens
+     * @info tokens that are popular and must be detected in the app are marked as 'verified'
+     * @param additionalTokens balances along with the verified ones
+     */
+    static fetchVerifiedAndNativeBalances(chainId: number, userAddress: string, additionalTokenAddresses?: string[]): Promise<({
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+        isTokenWrapper?: boolean | undefined;
+        tokenWrapperAddress?: string | undefined;
+    } & {
+        balance: bigint;
+    })[]>;
+    static fetchOnChain(token: TokenModel): Promise<Omit<Token["model"], "id">>;
+    static fetchManyOnChain(chainId: ChainId, addresses: string[]): Promise<{
+        [address: string]: Omit<{
+            symbol: string;
+            name: string | null;
+            decimals: number;
+            address: string;
+            id: string;
+            chainId: number;
+            icon: string;
+            isNative: boolean;
+            isPoint: boolean;
+            isPreTGE: boolean;
+            isTest: boolean;
+            verified: boolean;
+        } & {
+            price?: number | null | undefined;
+            isTokenWrapper?: boolean | undefined;
+            tokenWrapperAddress?: string | undefined;
+        }, "id">;
+    }>;
+    /**
+     * Updates price of tokens that share the same symbol
+     * @param symbol
+     * @param price value
+     * @param excludeAddresses to not update symbols that defined using addresses
+     */
+    static updateSymbolPrices(symbol: string, price: number, excludeAddresses: string[]): Promise<Prisma.BatchPayload>;
+    /**
+     * Updates price of tokens that share the same address
+     * @param address
+     * @param price value
+     * @param chainId
+     */
+    static updateAddressPrices(address: string, price: number, chainId?: number): Promise<Prisma.BatchPayload>;
+    /**
+     * Updates price of tokens that share the same symbol
+     * @param symbol
+     * @param price value
+     * @param excludeAddresses to not update symbols that defined using addresses
+     */
+    static updatePrices(pricer: Pricer): Promise<void>;
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static findUniqueOrThrow(token: TokenUnique | string): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+        isTokenWrapper?: boolean | undefined;
+        tokenWrapperAddress?: string | undefined;
+    }>;
+    /**
+     * Read token from database, tries to fill it if unexistant
+     * @param chainId
+     * @param address
+     */
+    static findUniqueFillOrThrow(token: TokenUnique): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+        isTokenWrapper?: boolean | undefined;
+        tokenWrapperAddress?: string | undefined;
+    }>;
+    /**
+     * Checks if two tokens are the same based on chainId/address combo
+     * @param a token
+     * @param b token
+     * @returns true if both tokens are the same
+     */
+    static isSame(a: Pick<Token["model"], "chainId" | "address">, b: Pick<Token["model"], "chainId" | "address">): boolean;
+    /**
+     * Get the list of tokens satisfying the query
+     * @param query
+     * @returns A list of tokens
+     */
+    static findMany(query: GetTokenQueryModel): Promise<({
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+        isTokenWrapper?: boolean | undefined;
+        tokenWrapperAddress?: string | undefined;
+    })[]>;
+    /**
+     * Get the list of tokens satisfying the query or fetch if chainId and address are provided
+     * @param query
+     * @returns A list of tokens
+     */
+    static findManyOrFetch(query: GetTokenQueryModel): Promise<({
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+        isTokenWrapper?: boolean | undefined;
+        tokenWrapperAddress?: string | undefined;
+    })[]>;
+    static getPrice(query: Omit<GetTokenQueryModel, "page" | "items">): Promise<number>;
+    static findManyObjectPerAddress(query: GetTokenQueryModel): Promise<Record<string, {
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+        isTokenWrapper?: boolean | undefined;
+        tokenWrapperAddress?: string | undefined;
+    }>>;
+    static getRewardTokenPrice(campaign: CampaignParameters<Campaign>): Promise<number>;
+    /**
+     * Get value of tokens
+     * @param tokenAmounts address/chain + amount of token
+     * @returns the cumulated dollar value of all tokens
+     */
+    static getValue(tokenAmounts: {
+        amount?: bigint;
+        address: string;
+        chainId: number;
+    }[]): Promise<number>;
+    static getValueByTokenId(id: string, amount: bigint): Promise<number>;
+    /**
+     * Counts the number of tokens that complies to query
+     * @description used for pagination purposes
+     * @param query
+     * @returns the number of tokens
+     */
+    static countMany(query: GetTokenQueryModel): Promise<number>;
+    static findChains(): Promise<Record<string, ChainId>>;
+    /**
+     * Read token from DB or fetch onchain
+     * @param chainId
+     * @param address
+     */
+    static findManyOrCreate(tokens: TokenModel[]): Promise<({
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+        isTokenWrapper?: boolean | undefined;
+        tokenWrapperAddress?: string | undefined;
+    })[]>;
+    static getAllValidRewardTokens(query: {
+        chainId?: string;
+    }): Promise<Record<number, {
+        minimumAmountPerHour: string | undefined;
+        isTokenWrapper: true | undefined;
+        tokenWrapperAddress: string | undefined;
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    }[]>>;
+    static getValidRewardTokens(chainId: number): Promise<{
+        minimumAmountPerHour: string | undefined;
+        isTokenWrapper: true | undefined;
+        tokenWrapperAddress: string | undefined;
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    }[]>;
+    static update(id: string, data: UpdateTokenModel): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    }>;
+    static notionWebhook(body: NotionWebhookModel): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    }>;
+    /**
+     * Fetches symbol, address, decimals and creates token on database
+     * @param chainId
+     * @param address
+     */
+    static fillAndCreate(token: CreateTokenModel): Promise<{
+        symbol: string;
+        name: string | null;
+        decimals: number;
+        price: number | null;
+        address: string;
+        id: string;
+        chainId: number;
+        icon: string;
+        isNative: boolean;
+        isPoint: boolean;
+        isPreTGE: boolean;
+        isTest: boolean;
+        verified: boolean;
+        displaySymbol: string;
+    }>;
+}

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

@@ -0,0 +1,3 @@
+export declare class TracerService {
+    static createTracedProxy<T extends object>(target: T, serviceName: string): T;
+}

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

@@ -0,0 +1,81 @@
+import Elysia from "elysia";
+export declare const TurtleController: Elysia<"/turtle", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    turtle: {
+        tac: {
+            total: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            total: number;
+                            breakdown: {
+                                [key: string]: number;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    turtle: {
+        tac: {
+            ":address": {
+                get: {
+                    body: unknown;
+                    params: {
+                        address: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            [x: string]: {
+                                vaultSymbol: string;
+                                balance: number;
+                                maxBalance: number;
+                                turtle: number;
+                            };
+                        };
+                        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/turtle/turtle.repository.d.ts

@@ -0,0 +1,14 @@
+export declare class TurtleRepository {
+    static fetchUserBalances(address: string): Promise<{
+        balance: string;
+        maxBalance: string;
+        tokenSymbol: string;
+        token: string;
+        turtleDepositBonus: string;
+        user: string;
+    }[]>;
+    static fetchTotals(): Promise<{
+        amount: number;
+        id: string;
+    }[]>;
+}

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

@@ -0,0 +1,17 @@
+import type { UserUniqueModel } from "../user/user.model";
+export declare abstract class TurtleService {
+    static getUserData(params: UserUniqueModel): Promise<{
+        [key: string]: {
+            vaultSymbol: string;
+            balance: number;
+            maxBalance: number;
+            turtle: number;
+        };
+    }>;
+    static getTotalDistributed(): Promise<{
+        total: number;
+        breakdown: {
+            [key: string]: number;
+        };
+    }>;
+}

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

@@ -0,0 +1,35 @@
+import type { ResourceAPI } from "../../../modules/v4/prisma";
+/**
+ * Tvl Record
+ * @description Describes one tvl snapshot for an opportunity
+ * @see {@link ResourceAPI}
+ */
+export type TvlRecord = ResourceAPI<"TVLRecord", "id" | "opportunityId", {
+    breakdowns: TvlBreakdown["model"][];
+}>;
+/**
+ * Tvl Breakdown
+ * @description Describes one tvl fraction of record
+ * @see {@link ResourceAPI}
+ */
+export type TvlBreakdown = ResourceAPI<"TVLBreakdown", "id" | "tvlRecordId">;
+export declare const TvlBreakdownResourceDto: import("@sinclair/typebox").TObject<{
+    identifier: import("@sinclair/typebox").TString;
+    type: import("@sinclair/typebox").TEnum<{
+        readonly TOKEN: "TOKEN";
+        readonly PROTOCOL: "PROTOCOL";
+    }>;
+    value: import("@sinclair/typebox").TNumber;
+}>;
+export declare const TvlRecordResourceDto: import("@sinclair/typebox").TObject<{
+    total: import("@sinclair/typebox").TNumber;
+    timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
+    breakdowns: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        identifier: import("@sinclair/typebox").TString;
+        type: import("@sinclair/typebox").TEnum<{
+            readonly TOKEN: "TOKEN";
+            readonly PROTOCOL: "PROTOCOL";
+        }>;
+        value: import("@sinclair/typebox").TNumber;
+    }>>;
+}>;

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

@@ -0,0 +1,9 @@
+import { Campaign, type CampaignDynamicData } from "@angleprotocol/sdk/ts";
+import type { TvlRecord } from "./tvl.model";
+export declare abstract class TvlService {
+    static hashId(opportunityId: string, timestamp: bigint): string;
+    /**
+     * @deprecated
+     */
+    static extractFromDynamicData<C extends Campaign>(type: C, dynamicData: CampaignDynamicData<C>[], timestamp?: bigint): TvlRecord["model"];
+}