@merkl/api 0.10.78

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

@@ -0,0 +1,46 @@
+import type { BytesLike } from "ethers";
+export type CampaignFrontend = {
+    chainId: number;
+    index: number;
+    creator: string;
+    campaignId: string;
+    campaignType: string;
+    campaignSubType: string;
+    rewardToken: string;
+    amount: string;
+    amountDecimal: number;
+    startTimestamp: number;
+    endTimestamp: number;
+    lastProcessedTimestamp: number;
+    mainParameter: string;
+    merklApr: string;
+    otherAprs: string[];
+};
+export declare enum Campaign {
+    INVALID = 0,
+    ERC20 = 1,
+    CLAMM = 2
+}
+export type MultiCallDataType = {
+    target: string;
+    callData: BytesLike;
+    allowFailure?: boolean;
+}[];
+export type leafCacheType = {
+    type: "Buffer";
+    data: number[];
+};
+export type MerklChainData = {
+    merkleRoot: string;
+    treeRoot: string;
+    lastTreeRoot: string;
+    endOfDisputePeriod: number;
+    disputeLive: boolean;
+    message: string;
+    validRewardTokens: {
+        token: string;
+        minimumAmountPerEpoch: number;
+        decimals: number;
+        symbol: string;
+    }[];
+};

package/dist/src/types/parameters/Action.d.ts

@@ -0,0 +1,4 @@
+export declare const Action: {
+    isValid: (chain: ChainId) => boolean;
+    type: import("@sinclair/typebox").TUnion<import("elysia").TSchema[]>;
+};

package/dist/src/types/parameters/Chain.d.ts

@@ -0,0 +1,4 @@
+export declare const Chain: {
+    isValid: (chain: ChainId) => boolean;
+    type: import("@sinclair/typebox").TUnion<import("elysia").TSchema[]>;
+};

package/dist/src/types/parameters/ChainCampaignId.d.ts

@@ -0,0 +1,4 @@
+export declare const ChainCampaignId: {
+    isValid: (chain: `${ChainId}_${string}`) => boolean;
+    type: import("@sinclair/typebox").TTemplateLiteral<[import("@sinclair/typebox").TUnion<import("elysia").TSchema[]>, import("@sinclair/typebox").TLiteral<"_">, import("@sinclair/typebox").TString]>;
+};

package/dist/src/types/parameters/MainParameter.d.ts

@@ -0,0 +1,4 @@
+export declare const MainParameter: {
+    isValid: (chain: `${ChainId}_${string}`) => boolean;
+    type: import("@sinclair/typebox").TString;
+};

package/dist/src/types/parameters/OpportunityId.d.ts

@@ -0,0 +1,4 @@
+export declare const OpportunityId: {
+    isValid: (chain: Id) => boolean;
+    type: import("@sinclair/typebox").TTemplateLiteral<[import("@sinclair/typebox").TUnion<import("elysia").TSchema[]>, import("@sinclair/typebox").TLiteral<"_">, import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<"_">, import("@sinclair/typebox").TString]>;
+};

package/dist/src/types/parameters/Timestamp.d.ts

@@ -0,0 +1,4 @@
+export declare const Timestamp: {
+    isValid: (timestamp: number) => true;
+    type: import("@sinclair/typebox").TNumber;
+};

package/dist/src/types/parameters/Type.d.ts

@@ -0,0 +1,4 @@
+export declare const Type: {
+    isValid: (chain: Campaign) => boolean;
+    type: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<any>[]>;
+};

package/dist/src/types/parameters/index.d.ts

@@ -0,0 +1,36 @@
+import type { TSchema } from "elysia";
+export type ApiInput<T> = {
+    isValid: (value: T) => boolean;
+    type: TSchema;
+};
+declare const param: {
+    Chain: {
+        isValid: (chain: ChainId) => boolean;
+        type: import("@sinclair/typebox").TUnion<TSchema[]>;
+    };
+    Type: {
+        isValid: (chain: Campaign) => boolean;
+        type: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<any>[]>;
+    };
+    Action: {
+        isValid: (chain: ChainId) => boolean;
+        type: import("@sinclair/typebox").TUnion<TSchema[]>;
+    };
+    ChainCampaignId: {
+        isValid: (chain: `${ChainId}_${string}`) => boolean;
+        type: import("@sinclair/typebox").TTemplateLiteral<[import("@sinclair/typebox").TUnion<TSchema[]>, import("@sinclair/typebox").TLiteral<"_">, import("@sinclair/typebox").TString]>;
+    };
+    OpportunityId: {
+        isValid: (chain: Id) => boolean;
+        type: import("@sinclair/typebox").TTemplateLiteral<[import("@sinclair/typebox").TUnion<TSchema[]>, import("@sinclair/typebox").TLiteral<"_">, import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<"_">, import("@sinclair/typebox").TString]>;
+    };
+    MainParameter: {
+        isValid: (chain: `${ChainId}_${string}`) => boolean;
+        type: import("@sinclair/typebox").TString;
+    };
+    Timestamp: {
+        isValid: (timestamp: number) => true;
+        type: import("@sinclair/typebox").TNumber;
+    };
+};
+export default param;

package/dist/src/types/returnTypes.d.ts

@@ -0,0 +1,27 @@
+export type CampaignsForMainParameterReturnType = {
+    campaignId: string;
+    rewardToken: string;
+    rewardTokenSymbol: string;
+    amountDecimal: number;
+    startTimestamp: number;
+    endTimestamp: number;
+}[];
+export type OverviewReturnType = {
+    disputes: {
+        [chainId: number]: {
+            root: string;
+            endOfDisputePeriod: number;
+            disputeLive: boolean;
+            treeRoot: string;
+            lastTreeRoot: string;
+        };
+    };
+    rewardTokens: {
+        [chainId: number]: {
+            token: string;
+            minimumAmountPerEpoch: number;
+            decimals: number;
+            symbol: string;
+        }[];
+    };
+};

package/dist/src/types/utils.d.ts

@@ -0,0 +1,5 @@
+import type { ChainId } from "@sdk";
+export type PerChain<T> = {
+    [Chain in ChainId]?: T;
+};
+export type Stringable = string | number | bigint | boolean | null | undefined;

package/dist/src/utils/addString.d.ts

@@ -0,0 +1,2 @@
+export declare const addStrings: (a: number | string | bigint, b: number | string | bigint) => string;
+export declare const subStrings: (a: number | string | bigint, b: number | string | bigint) => string;

package/dist/src/utils/bigintToString.d.ts

@@ -0,0 +1 @@
+export default function bigintToString(obj: object | object[]): object | object[];

package/dist/src/utils/crypto.d.ts

@@ -0,0 +1 @@
+export declare function sha256(x: string): string;

package/dist/src/utils/error.d.ts

@@ -0,0 +1,53 @@
+import { HttpError } from "../errors";
+import { type ChainId } from "@sdk";
+import type Elysia from "elysia";
+import { ValidationError } from "elysia";
+export declare class InvalidParameter extends Error {
+    message: string;
+    constructor(message: string);
+}
+export declare class UnsupportedNetwork extends Error {
+    chainId: ChainId;
+    constructor(chainId: ChainId);
+}
+export declare class OpportunityNotFound extends Error {
+    mainParameter: string;
+    chainId: ChainId;
+    constructor(mainParameter: string, chainId: ChainId);
+}
+export declare class MerkleRootNotFound extends Error {
+    chainId: ChainId;
+    constructor(chainId: ChainId);
+}
+export declare class InvalidCacheCall extends Error {
+    message: string;
+    constructor(message: string);
+}
+export declare const errorHandler: (canLog?: boolean) => (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {
+        readonly InvalidParameter: InvalidParameter;
+        readonly UnsupportedNetwork: UnsupportedNetwork;
+        readonly OpportunityNotFound: OpportunityNotFound;
+        readonly MerkleRootNotFound: MerkleRootNotFound;
+        readonly ValidationError: ValidationError;
+        readonly InvalidCacheCall: InvalidCacheCall;
+        readonly HttpError: HttpError;
+    };
+}, {
+    schema: {};
+    macro: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/utils/execute.d.ts

@@ -0,0 +1,32 @@
+import type { TTLType } from "../cache/redis";
+import type { MultiCallDataType } from "../types";
+/**
+ * Types
+ */
+export type CachedResult<T> = {
+    cached: true;
+    result: T;
+};
+export type UncachedResult<T> = {
+    cached: false;
+    call: {
+        callData: MultiCallDataType;
+        reducer: (result: string[]) => Promise<T>;
+        handler: () => void;
+    };
+};
+export type ComponentReturnType<T> = Promise<CachedResult<T> | UncachedResult<T>>;
+export type ComponentCallWithFallback<T> = {
+    call: ComponentReturnType<T>;
+    fallback: (args: T) => void;
+};
+export type BatchedMulticallComponentType = {
+    args: any[];
+    call: (...args: any[]) => Promise<UncachedResult<any>>;
+    fallback: (args: any) => void;
+    ttl: TTLType;
+};
+/**
+ * Functions
+ */
+export declare function executeSimple<T>(chainId: number, componentCall: ComponentReturnType<T>): Promise<T>;

package/dist/src/utils/generic.d.ts

@@ -0,0 +1,24 @@
+import { type MerklChainId, type Multicall } from "@sdk";
+import { type BigNumberish } from "ethers";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import type { MultiCallDataType } from "../types";
+export declare function multicallContractCall(contract: Multicall, args: {
+    data: MultiCallDataType;
+    blockNumber?: number | undefined;
+    from?: string;
+}): Promise<string[]>;
+export declare function batchMulticallCall(func: (contract: Multicall, args: {
+    data: Multicall3.Call3Struct[];
+    blockNumber?: number;
+}) => Promise<string[]>, contract: Multicall, args: {
+    data: Multicall3.Call3Struct[];
+    blockNumber?: number;
+}, shouldRetry?: boolean): Promise<string[]>;
+export declare function archiveContractMethodCall(contract: Multicall, args: {
+    calls: Multicall3.Call3Struct[];
+    blockNumber?: BigNumberish;
+}): Promise<Multicall3.ResultStructOutput[]>;
+export declare function batchMulticallCallWithRetry(chainId: MerklChainId, args: {
+    calls: Multicall3.Call3Struct[];
+    blockNumber?: BigNumberish;
+}): Promise<Multicall3.ResultStructOutput[]>;

package/dist/src/utils/hashArray.d.ts

@@ -0,0 +1 @@
+export declare function hashArray(...args: any[]): string;

package/dist/src/utils/lastBlockBefore.d.ts

@@ -0,0 +1,3 @@
+import type { MerklChainId } from "@sdk";
+export declare const getBlockTimestamp: (provider: any, blockNumber: number) => Promise<number>;
+export declare const getLastBlockBeforeWithCache: (timestamp: number, chainId: MerklChainId) => Promise<any>;

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,24 @@
+export declare const logger: import("@bogeychan/elysia-logger/types").ElysiaLogger<import("elysia").default<"", {
+    request: {
+        log: import("@bogeychan/elysia-logger/types").Logger;
+    };
+    store: {};
+}, {
+    type: {};
+    error: {};
+}, {}, {}, false, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>>;
+export declare const log: {
+    debug: (message: string) => void;
+    error: (message: string, errorMessage: any, service?: string, url?: string) => void;
+    info: (message: string) => void;
+    local: (message: string) => void;
+    warn: (message: string) => void;
+};

package/dist/src/utils/pricer.d.ts

@@ -0,0 +1,52 @@
+import { ChainId } from "@sdk";
+export type PricerDataType = {
+    prices: {
+        [token: string]: number;
+    };
+    extraPricesData: {
+        method: number;
+        symbol: string;
+        address: string;
+        chainId: ChainId;
+    }[];
+};
+export declare enum PRICING_METHODS {
+    defillama = 0,
+    quickswap = 1,
+    abandonned = -1
+}
+export declare class Pricer {
+    prices: PricerDataType["prices"];
+    extraPricesData: PricerDataType["extraPricesData"];
+    constructor(prices: PricerDataType["prices"], extraPricesData: PricerDataType["extraPricesData"]);
+    static load(): Promise<Pricer>;
+    getArray(): {
+        rate: number;
+        token: string;
+    }[];
+    /** Tries to fetch a given price sequentially using a given method */
+    fetchPerMethod(x: {
+        symbol?: string;
+        address?: string;
+        chainId?: ChainId;
+    }, method: PRICING_METHODS): Promise<number>;
+    /** Tries to fetch a given price sequentially using all available methods */
+    fetch(x: {
+        symbol?: string;
+        address?: string;
+        chainId?: ChainId;
+    }): Promise<{
+        price: number;
+        method: number;
+    }>;
+    /** Returns the price if possible, otherwise tries to fetch it */
+    get(x: {
+        symbol?: string;
+        address?: string;
+        chainId?: ChainId;
+    }): Promise<number | undefined>;
+    /** Saves the current price data in the cache */
+    save(): Promise<void>;
+    /** Recomputes all prices and saves them in the cache */
+    update(): Promise<void>;
+}

package/dist/src/utils/prices/chainlinkRead.d.ts

@@ -0,0 +1,4 @@
+import { type ChainId } from "@sdk";
+type ReturnType = number;
+export declare function getChainlinkLatestPrice(chainId: ChainId, oracle: string): Promise<ReturnType>;
+export {};

package/dist/src/utils/prices/curveVirtualPrice.d.ts

@@ -0,0 +1,4 @@
+import { type ChainId } from "@sdk";
+type ReturnType = number;
+export declare function getVirtualPrice(chainId: ChainId, pool: string): Promise<ReturnType>;
+export {};

package/dist/src/utils/prices/getDQUICK.d.ts

@@ -0,0 +1,4 @@
+import { type ChainId } from "@sdk";
+type ReturnType = number;
+export declare function getDQUICKPrice(chainId: ChainId, contractAddress: string, assetDecimals?: number, vaultDecimals?: number): Promise<ReturnType>;
+export {};

package/dist/src/utils/prices/priceFetcherFactory.d.ts

@@ -0,0 +1,10 @@
+import { PriceSourceMethod } from "../../../database/api/.generated";
+import type PriceFetcher from "./services/priceFetcher";
+/**
+ * @description Factory pattern to get the correct price fetcher
+ */
+export default class PriceFetcherFactory {
+    static readonly instance: PriceFetcherFactory;
+    private constructor();
+    get(type: PriceSourceMethod): PriceFetcher;
+}

package/dist/src/utils/prices/priceService.d.ts

@@ -0,0 +1,13 @@
+export type PriceType = {
+    [token: string]: number;
+};
+export default class PriceService {
+    static readonly instance: PriceService;
+    private _prices;
+    private constructor();
+    get prices(): PriceType;
+    private setPrices;
+    fetchPrices(): Promise<PriceType>;
+    private setConstantPrices;
+    private setEqualsToPrices;
+}

package/dist/src/utils/prices/services/coinGeckoService.d.ts

@@ -0,0 +1,12 @@
+import { type PriceSource } from "../../../../database/api/.generated";
+import type PriceFetcher from "./priceFetcher";
+import type { ResponsePriceType } from "./priceFetcher";
+export default class CoingeckoService implements PriceFetcher {
+    static readonly instance: CoingeckoService;
+    private constructor();
+    private baseUrl;
+    getPrice(tickers: PriceSource[]): Promise<ResponsePriceType[]>;
+    private buildUrl;
+    private fetchprices;
+    private formatResponse;
+}

package/dist/src/utils/prices/services/defillamaService.d.ts

@@ -0,0 +1,12 @@
+import { type PriceSource } from "../../../../database/api/.generated";
+import type PriceFetcher from "./priceFetcher";
+import type { ResponsePriceType } from "./priceFetcher";
+export default class DefillamaService implements PriceFetcher {
+    static readonly instance: DefillamaService;
+    private constructor();
+    private baseUrl;
+    getPrice(sources: PriceSource[]): Promise<ResponsePriceType[]>;
+    private buildUrl;
+    private fetchprices;
+    private formatResponse;
+}

package/dist/src/utils/prices/services/dexScreenerService.d.ts

@@ -0,0 +1,12 @@
+import { type PriceSource } from "../../../../database/api/.generated";
+import type PriceFetcher from "./priceFetcher";
+import type { ResponsePriceType } from "./priceFetcher";
+export default class DexScreenerService implements PriceFetcher {
+    static readonly instance: PriceFetcher;
+    private baseUrl;
+    private constructor();
+    getPrice(tokens: PriceSource[]): Promise<ResponsePriceType[]>;
+    private getTokenByChain;
+    /** @description Create a list by chain dexscreener only supports one chain at a time */
+    private fetchPrices;
+}

package/dist/src/utils/prices/services/erc4626Service.d.ts

@@ -0,0 +1,9 @@
+import { type PriceSource } from "../../../../database/api/.generated";
+import type PriceFetcher from "./priceFetcher";
+import type { ResponsePriceType } from "./priceFetcher";
+export default class ERC4626Service implements PriceFetcher {
+    static readonly instance: PriceFetcher;
+    private constructor();
+    getPrice(tokens: PriceSource[]): Promise<ResponsePriceType[]>;
+    private priceCalculation;
+}

package/dist/src/utils/prices/services/getERC4626.d.ts

@@ -0,0 +1,4 @@
+import { type ChainId } from "@sdk";
+type ReturnType = number;
+export declare function getERC4626Price(chainId: ChainId, contractAddress: string, assetDecimals?: number, vaultDecimals?: number): Promise<ReturnType>;
+export {};

package/dist/src/utils/prices/services/indexCoopService.d.ts

@@ -0,0 +1,12 @@
+import { type PriceSource } from "../../../../database/api/.generated";
+import type PriceFetcher from "./priceFetcher";
+import type { ResponsePriceType } from "./priceFetcher";
+export default class IndexCoop implements PriceFetcher {
+    static readonly instance: IndexCoop;
+    private baseUrl;
+    private constructor();
+    getPrice(tokens: PriceSource[]): Promise<ResponsePriceType[]>;
+    private getTokenByChain;
+    private fetchPrice;
+    private buildUrl;
+}

package/dist/src/utils/prices/services/priceFetcher.d.ts

@@ -0,0 +1,8 @@
+import type { PriceSource } from "../../../../database/api/.generated";
+export default interface PriceFetcher {
+    getPrice(tickers: PriceSource[]): Promise<ResponsePriceType[]>;
+}
+export type ResponsePriceType = {
+    token: string;
+    rate: number;
+};

package/dist/src/utils/prices/uniV2Price.d.ts

@@ -0,0 +1,7 @@
+import { type ChainId } from "@sdk";
+type ReturnType = number;
+export declare function getCurveV2Price(chainId: ChainId, prices: {
+    [t: string]: number;
+}, pool: string, token: string): Promise<ReturnType>;
+export declare function getUniV2Price(chainId: ChainId, priceToken0: number, priceToken1: number, poolAddress: string): Promise<ReturnType>;
+export {};

package/dist/src/utils/prisma.d.ts

@@ -0,0 +1,16 @@
+import { PrismaClient as ApiPrismaClient } from "../../database/api/.generated";
+import { PrismaClient as EnginePrismaClient } from "../../database/engine/.generated";
+export declare const apiDbClient: ApiPrismaClient<{
+    datasources: {
+        db: {
+            url: string;
+        };
+    };
+}, never, import("database/api/.generated/runtime/library").DefaultArgs>;
+export declare const engineDbClient: EnginePrismaClient<{
+    datasources: {
+        db: {
+            url: string;
+        };
+    };
+}, never, import("database/engine/.generated/runtime/library").DefaultArgs>;

package/dist/src/utils/providers.d.ts

@@ -0,0 +1,13 @@
+import { type ethers } from "ethers";
+export declare const providers: {
+    [x: string]: ethers.providers.StaticJsonRpcProvider | ethers.providers.InfuraProvider;
+};
+export declare const archiveProviders: {
+    [x: string]: ethers.providers.StaticJsonRpcProvider | ethers.providers.InfuraProvider;
+};
+export declare const multicalls: {
+    [chainId: number]: Multicall;
+};
+export declare const archiveMulticalls: {
+    [chainId: number]: Multicall;
+};

package/dist/src/utils/queries/activeCampaigns.d.ts

@@ -0,0 +1,3 @@
+import { Prisma } from "../../../database/engine/.generated";
+export declare const ACTIVE_CAMPAIGNS_FOR_CHAIN: (chainId: number, now: number) => Prisma.Sql;
+export declare const ACTIVE_CAMPAIGNS: (now: number) => Prisma.Sql;

package/dist/src/utils/queries/allCampaigns.d.ts

@@ -0,0 +1,6 @@
+import { Prisma } from "../../../database/engine/.generated";
+export declare const ALL_CAMPAIGNS_FOR_CHAIN_AFTER: (chainId: number, after: number) => Prisma.Sql;
+export declare const ALL_CAMPAIGNS_FOR_CHAIN_BEFORE: (chainId: number, before: number) => Prisma.Sql;
+export declare const ALL_CAMPAIGNS_FOR_CHAIN: (chainId: number) => Prisma.Sql;
+export declare const ALL_CAMPAIGNS: () => Prisma.Sql;
+export declare const ALL_CAMPAIGNS_FOR_CHAINS_AND_CREATOR_TAG: (chainIds: number[], creatorTag: string) => Prisma.Sql;

package/dist/src/utils/queries/campaignsForMainParameter.d.ts

@@ -0,0 +1,2 @@
+import { Prisma } from "../../../database/engine/.generated";
+export declare const CAMPAIGNS_BY_MAIN_PARAMETER: (chainId: number, mainParameter: string) => Prisma.Sql;

package/dist/src/utils/queries/claimsOverTime.d.ts

@@ -0,0 +1,8 @@
+import { Prisma } from "../../../database/engine/.generated";
+export declare const CLAIMS_OVER_TIME: (chainId: number, campaignId: string) => Prisma.Sql;
+export declare const CLAIMS_OVER_TIME_GROUPED: (chainId: number, campaignId: string) => Prisma.Sql;
+export declare const CLAIMS_OVER_TIME_V2: (chainId: number, campaignId: string) => Prisma.Sql;
+export declare const CLAIMS_FOR_CREATOR_TAG: (chainIds: number[], user: string, creatorTag: string) => Prisma.Sql;
+export declare const CLAIMS_FOR_CREATOR_TAG_GROUPED: (chainIds: number[], user: string, creatorTag: string) => Prisma.Sql;
+export declare const CLAIMS_FOR_USER: (chainIds: number[], user: string) => Prisma.Sql;
+export declare const CLAIMS_FOR_USER_GROUPED: (chainIds: number[], user: string) => Prisma.Sql;

package/dist/src/utils/queries/endingCampaigns.d.ts

@@ -0,0 +1,10 @@
+import { Prisma } from "../../../database/engine/.generated";
+export type EndingCampaigns = {
+    chainId: number;
+    creator: string;
+    symbol: string;
+    amount: number;
+    endTimestamp: number;
+};
+export declare const ENDING_CAMPAIGNS: (maxEndDate: number, minStartDate: number, minEndDate: number) => Prisma.Sql;
+export declare const NON_RENEWED_CAMPAIGNS: (maxEndDate: number, minStartDate: number, minEndDate: number) => Prisma.Sql;

package/dist/src/utils/queries/futureCampaigns.d.ts

@@ -0,0 +1,3 @@
+import { Prisma } from "../../../database/engine/.generated";
+export declare const FUTURE_CAMPAIGNS_FOR_CHAIN: (chainId: number, now: number) => Prisma.Sql;
+export declare const FUTURE_CAMPAIGNS: (now: number) => Prisma.Sql;

package/dist/src/utils/queries/mainParameterCampaigns.d.ts

@@ -0,0 +1,5 @@
+import { Prisma } from "../../../database/engine/.generated";
+export type CampaignsForMainParameterQueryOutput = {
+    campaignId: string;
+}[];
+export declare const CAMPAIGNS_FOR_MAIN_PARAMETER: (chainId: number, mainParameter: string) => Prisma.Sql;

package/dist/src/utils/queries/rewardsAmount.d.ts

@@ -0,0 +1,10 @@
+import { Prisma } from "../../../database/engine/.generated";
+export type RewardsAmountQueryOutput = {
+    recipient: string;
+    reason: string;
+    rewardToken: string;
+    amount: string;
+}[];
+export declare const REWARDS_DELTA: (chainId: number, campaignIds: string[], fromRoot: string, toRoot: string) => Prisma.Sql;
+export declare const CAMPAIGN_REWARDS_DELTA: (chainId: number, campaignId: string, fromRoot: string, toRoot: string) => Prisma.Sql;
+export declare const LATEST_CAMPAIGNS_REWARDS: (chainId: number, root: string, campaignIds: string[]) => Prisma.Sql;

package/dist/src/utils/queries/unclaimed.d.ts

@@ -0,0 +1,11 @@
+import { Prisma } from "../../../database/engine/.generated";
+export type TotalUnclaimedOutput = {
+    chainId: number;
+    rewardToken: string;
+    symbol: string;
+    unclaimed: number;
+};
+export declare const UNCLAIMED_BEFORE: (timestamp: number) => Prisma.Sql;
+export declare const UNCLAIMED_BY_CAMPAIGN: (currentRoot: string, chainId: number, campaignId: string) => Prisma.Sql;
+export declare const UNCLAIMED_FOR_CAMPAIGNS: (chainId: number, campaignIds: string[]) => Prisma.Sql;
+export declare const UNCLAIMED_BY_TOKEN: (currentRoot: string, chainId: number, rewardToken: string) => Prisma.Sql;