@merkl/api 0.10.78

package/dist/src/modules/v4/status/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./status.model";
+export * from "./status.controller";
+export * from "./status.service";

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

@@ -0,0 +1,143 @@
+import Elysia from "elysia";
+export declare const StatusController: Elysia<"/campaignStatus", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    campaignStatus: {
+        engine: {
+            post: {
+                body: {
+                    status: {
+                        value: "SUCCESS";
+                        computedUntil: number;
+                    } | {
+                        value: "PROCESSING";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "SKIPPED";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "FAILED";
+                    };
+                    campaignId: string;
+                    distributionChain: number;
+                };
+                params: Record<never, string>;
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: void;
+                };
+            };
+        };
+    };
+} & {
+    campaignStatus: {
+        index: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+                    }[];
+                };
+            };
+        };
+    };
+} & {
+    campaignStatus: {
+        unique: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    identifier: string;
+                    distributionChain: number;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    campaignStatus: {
+        computeChain: {
+            ":chainId": {
+                get: {
+                    body: unknown;
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../../database/api/.generated").Prisma.JsonValue;
+                        }[];
+                    };
+                };
+            };
+        };
+    };
+} & {
+    campaignStatus: {
+        overlaps: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    identifier: string;
+                    distributionChain: number;
+                };
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: boolean;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,23 @@
+export declare const ChainDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+}>;
+export declare const UpdateStatusDto: import("@sinclair/typebox").TObject<{
+    distributionChain: import("@sinclair/typebox").TNumber;
+    campaignId: import("@sinclair/typebox").TString;
+    status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        value: import("@sinclair/typebox").TLiteral<"SUCCESS">;
+        computedUntil: import("@sinclair/typebox").TNumber;
+    }>, import("@sinclair/typebox").TObject<{
+        value: import("@sinclair/typebox").TLiteral<"PROCESSING">;
+    }>, import("@sinclair/typebox").TObject<{
+        value: import("@sinclair/typebox").TLiteral<"SKIPPED">;
+        error: import("@sinclair/typebox").TString;
+        details: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        value: import("@sinclair/typebox").TLiteral<"FAILED">;
+        error: import("@sinclair/typebox").TString;
+        details: import("@sinclair/typebox").TString;
+    }>]>;
+}>;
+export declare const ChainModel: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+export type UpdateStatusModel = typeof UpdateStatusDto.static;

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

@@ -0,0 +1,68 @@
+import type { RunStatus } from "../../../../database/api/.generated";
+import { type CampaignUnique } from "../campaign";
+export declare class StatusRepository {
+    static findMany(): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }[]>;
+    static findManyPerChain(chainId: number): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }[]>;
+    static findUniqueOrThrow(campaignUnique: CampaignUnique): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }>;
+    static findUnique(campaignUnique: CampaignUnique): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    } | null>;
+    static create(campaign: CampaignUnique, startTimestamp: bigint): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }>;
+    static updateSuccess(campaignUnique: CampaignUnique, computedUntil: number): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }>;
+    static updateWithError(campaignUnique: CampaignUnique, status: Exclude<RunStatus, "SUCCESS" | "PROCESSING">, error: string, details: string): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }>;
+    static updateProcessing(campaignUnique: CampaignUnique): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }>;
+}

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

@@ -0,0 +1,38 @@
+import { type CampaignUnique } from "../campaign";
+import type { UpdateStatusModel } from "./status.model";
+export declare class StatusService {
+    static findMany(): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }[]>;
+    static findManyPerChain(chainId: number): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }[]>;
+    static findUniqueOrThrow(campaignUnique: CampaignUnique): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    }>;
+    static findUnique(campaignUnique: CampaignUnique): Promise<{
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    } | null>;
+    static update(x: UpdateStatusModel): Promise<void>;
+    static isSafeForOverlaps(campaignUnique: CampaignUnique): Promise<boolean>;
+}

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

@@ -0,0 +1,3 @@
+export * from "./token.service";
+export * from "./token.model";
+export * from "./token.controller";

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

@@ -0,0 +1,131 @@
+import Elysia from "elysia";
+export declare const TokenController: Elysia<"/tokens", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    tokens: {
+        ":id": {
+            get: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: ({
+                        symbol: string;
+                        name: string | null;
+                        id: string;
+                        chainId: number;
+                        address: string;
+                        icon: string;
+                        decimals: number;
+                        verified: boolean;
+                    } & {
+                        price?: number | null | undefined;
+                    }) | undefined;
+                };
+            };
+        };
+    };
+} & {
+    tokens: {
+        balances: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    tokenAddress?: string | undefined;
+                    additionalTokenAddresses?: string[] | undefined;
+                    chainId: number;
+                    userAddress: string;
+                };
+                headers: unknown;
+                response: {
+                    200: ({
+                        symbol: string;
+                        name: string | null;
+                        id: string;
+                        chainId: number;
+                        address: string;
+                        icon: string;
+                        decimals: number;
+                        verified: boolean;
+                    } & {
+                        price?: number | null | undefined;
+                    } & {
+                        balance: bigint;
+                    })[];
+                };
+            };
+        };
+    };
+} & {
+    tokens: {
+        index: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    symbol?: string | undefined;
+                    name?: string | undefined;
+                    chainId?: any;
+                    address?: string | undefined;
+                    verified?: boolean | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: ({
+                        symbol: string;
+                        name: string | null;
+                        id: string;
+                        chainId: number;
+                        address: string;
+                        icon: string;
+                        decimals: number;
+                        verified: boolean;
+                    } & {
+                        price?: number | null | undefined;
+                    })[];
+                };
+            };
+        };
+    };
+} & {
+    tokens: {
+        count: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    symbol?: string | undefined;
+                    name?: string | undefined;
+                    chainId?: any;
+                    address?: string | undefined;
+                    verified?: boolean | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: number;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,35 @@
+import type { Resource } from "../prisma";
+/**
+ * Token
+ * @description Data of an onchain asset
+ * @see {@link Resource}
+ */
+export type Token = Resource<"Token", never, {
+    price?: number | null;
+}>;
+export type TokenUnique = {
+    chainId: number;
+    address: string;
+};
+export declare const FindUniqueTokenDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+}>;
+export declare const GetTokenQueryDto: import("@sinclair/typebox").TObject<{
+    symbol: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<any>>;
+    address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    verified: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export declare const TokenDto: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    chainId: import("@sinclair/typebox").TNumber;
+}>;
+export declare const GetTokenBalanceDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    userAddress: import("@sinclair/typebox").TString;
+    tokenAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    additionalTokenAddresses: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+}>;
+export type TokenModel = typeof TokenDto.static;
+export type GetTokenQueryModel = typeof GetTokenQueryDto.static;

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

@@ -0,0 +1,59 @@
+import type { ChainId } from "@sdk";
+import type { GetTokenQueryModel, Token, TokenModel } from "./token.model";
+export declare abstract class TokenRepository {
+    #private;
+    /**
+     * Fetch token metadata from onchain
+     * @param chainId
+     * @param address
+     * @returns
+     */
+    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"] | undefined>;
+    /**
+     * Read token from database by its symbol
+     * @param symbol
+     */
+    static findMany(query: GetTokenQueryModel): Promise<Token["model"][]>;
+    static countMany(query: GetTokenQueryModel): Promise<number>;
+    /**
+     * upsert a token on database
+     * @param token
+     */
+    static upsert(token: Token["model"]): Promise<Token["model"] | undefined>;
+    /**
+     * 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("../../../../database/api/.generated").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<import("../../../../database/api/.generated").Prisma.BatchPayload>;
+    static findChains(): Promise<Record<string, ChainId>>;
+    /**
+     * create a token on database
+     * @param token
+     */
+    static create(token: Token["model"]): Promise<Token["model"] | undefined>;
+}

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

@@ -0,0 +1,165 @@
+import type { GetTokenQueryModel, Token, TokenModel, TokenUnique } from "./";
+import type { Pricer } from "../../../utils/pricer";
+import { Prisma } from "../../../../database/api/.generated";
+import { type ChainId } from "@sdk";
+export declare abstract class TokenService {
+    static hashId(token: TokenUnique): string;
+    /**
+     * 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;
+        id: string;
+        chainId: number;
+        address: string;
+        icon: string;
+        decimals: number;
+        verified: boolean;
+    } & {
+        price?: number | null | 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 fetchVerifiedBalances(chainId: number, userAddress: string, additionalTokenAddresses?: string[]): Promise<({
+        symbol: string;
+        name: string | null;
+        id: string;
+        chainId: number;
+        address: string;
+        icon: string;
+        decimals: number;
+        verified: boolean;
+    } & {
+        price?: number | null | 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;
+            id: string;
+            chainId: number;
+            address: string;
+            icon: string;
+            decimals: number;
+            verified: boolean;
+        } & {
+            price?: number | null | 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>;
+    /**
+     * Get all tokens from https://github.com/AngleProtocol/angle-token-list and override icons from it
+     * TODO: use the bucket
+     */
+    static fillTokenAndIconsFromTokenList(): Promise<void>;
+    /**
+     * Create token on database
+     * @param chainId
+     * @param address
+     */
+    static create(token: Omit<Token["model"], "id">): Promise<({
+        symbol: string;
+        name: string | null;
+        id: string;
+        chainId: number;
+        address: string;
+        icon: string;
+        decimals: number;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+    }) | undefined>;
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static findUniqueOrThrow(token: TokenUnique): Promise<({
+        symbol: string;
+        name: string | null;
+        id: string;
+        chainId: number;
+        address: string;
+        icon: string;
+        decimals: number;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+    }) | undefined>;
+    /**
+     * 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;
+        id: string;
+        chainId: number;
+        address: string;
+        icon: string;
+        decimals: number;
+        verified: boolean;
+    } & {
+        price?: number | null | undefined;
+    })[]>;
+    /**
+     * 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>;
+    /**
+     * 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 getManyOrCreate(tokens: TokenModel[]): Promise<(Token["model"] | undefined)[]>;
+}

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

@@ -0,0 +1,2 @@
+export * from "./tvl.model";
+export * from "./tvl.service";