@merkl/api 0.10.78

package/dist/src/internal/controllers/endingCampaigns.d.ts

@@ -0,0 +1,42 @@
+import { type Elysia } from "elysia";
+export declare const endingCampaignsController: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    v3: {
+        internal: {
+            endingCampaigns: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        maxEndDate?: number | undefined;
+                        minEndDate?: number | undefined;
+                        minStartDate?: number | undefined;
+                        nonRenewedOnly?: string | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: any[];
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/internal/controllers/unclaimed.d.ts

@@ -0,0 +1,43 @@
+import { type Elysia } from "elysia";
+import { type TotalUnclaimedOutput } from "../../utils/queries/unclaimed";
+export declare const unclaimedController: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    v3: {
+        internal: {
+            unclaimed: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        timestamp?: number | undefined;
+                        months?: number | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: (TotalUnclaimedOutput & {
+                            usdValue?: number;
+                        })[];
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1 @@
+export {};

package/dist/src/libs/campaigns/campaignTypes/AjnaDynamicData.d.ts

@@ -0,0 +1,5 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+type campaignType = Campaign.AJNA;
+export declare function AjnaDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<UncachedResult<Partial<CampaignDynamicData<campaignType>[]>>>;
+export {};

package/dist/src/libs/campaigns/campaignTypes/BadgerDynamicData.d.ts

@@ -0,0 +1,5 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+type campaignType = Campaign.BADGER;
+export declare function BadgerDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<UncachedResult<Partial<CampaignDynamicData<campaignType>[]>>>;
+export {};

package/dist/src/libs/campaigns/campaignTypes/CLAMMDynamicData.d.ts

@@ -0,0 +1,3 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export declare function CLAMMDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.CLAMM>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.CLAMM>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/CompoundDynamicData.d.ts

@@ -0,0 +1,3 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export declare function CompoundDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.COMPOUND>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.COMPOUND>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/DolomiteDynamicData.d.ts

@@ -0,0 +1,5 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+type campaignType = Campaign.DOLOMITE;
+export declare function DolomiteDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<UncachedResult<Partial<CampaignDynamicData<campaignType>[]>>>;
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20DynamicData.d.ts

@@ -0,0 +1,3 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export declare function ERC20DynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.ERC20>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.ERC20>[]>>>;

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

@@ -0,0 +1 @@
+export declare function fetchEulerVaultName(vaultAddress: string, chainId: number): Promise<string | null>;

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

@@ -0,0 +1,5 @@
+import { tokenType } from "./tokenType";
+export declare function getTypeFromFactoryAddress(address: string): tokenType;
+export declare const enzymeFundValueCalculatorRouterMapping: {
+    [address: string]: string;
+};

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

@@ -0,0 +1 @@
+export declare function getBlacklistedSupply(index: number, decimals: number, blacklist: string[], calls: string[]): number;

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

@@ -0,0 +1 @@
+export declare function fetchMetamorphoTvl(chainId: number, vaultAddress: string): Promise<number>;

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

@@ -0,0 +1,7 @@
+type SpliceInformation = {
+    symbolUnderlyingToken: string;
+    priceTargetToken: number;
+    tvl: number;
+};
+export declare function fetchSpliceInformation(marketAddress: string): Promise<SpliceInformation>;
+export {};

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

@@ -0,0 +1,45 @@
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+export declare enum tokenType {
+    uniswapv2 = "uniswapv2",
+    poolside = "poolside",
+    balancerGauge = "balancerGauge",
+    balancerPool = "balancerPool",
+    unknown = "unknown",
+    gearbox = "gearbox",
+    compound = "compound",
+    radiant_borrow = "radiant_borrow",
+    radiant_lend = "radiant_lend",
+    fluid = "fluid",
+    ionic = "ionic",
+    metamorpho = "metamorpho",
+    aerodrome = "aerodrome",
+    velodrome = "velodrome",
+    moonwell = "moonwell",
+    aave_lending = "aave_lending",
+    aave_borrowing = "aave_borrowing",
+    fraxlend = "fraxlend",
+    curve = "curve",
+    sturdy_aggregator = "sturdy_aggregator",
+    sturdy_silo = "sturdy_silo",
+    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"
+}
+export type tokenTypeStruct = {
+    type: tokenType;
+    calls: Multicall3.Call3Struct[];
+    typeInfo: any;
+};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesPrices.d.ts

@@ -0,0 +1,4 @@
+import type { Pricer } from "../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenPricesInfo(index: number, type: tokenType, typeInfo: any, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1.d.ts

@@ -0,0 +1,23 @@
+import { Interface } from "@ethersproject/abi";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { type tokenTypeStruct } from "./helpers/tokenType";
+export declare const factoryInterface: Interface;
+export declare const balancerGaugeInterface: Interface;
+export declare const OneInchStakingInterface: Interface;
+export declare const compoundInterface: Interface;
+export declare const radiantInterface: Interface;
+export declare const ionicInterface: Interface;
+export declare const layerBankInterface: Interface;
+export declare const metamorphoInterface: Interface;
+export declare const moonwellInterface: Interface;
+export declare const aaveInterface: Interface;
+export declare const fraxlendInterface: Interface;
+export declare const curveInterface: Interface;
+export declare const sturdyInterface: Interface;
+export declare const torosInterface: Interface;
+export declare const auraInterface: Interface;
+export declare const fluidInterface: Interface;
+export declare const enzymeInterface: Interface;
+export declare const eulerInterface: Interface;
+export declare const beefyInterface: Interface;
+export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound2.d.ts

@@ -0,0 +1,7 @@
+import { Interface } from "@ethersproject/abi";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
+export declare const balancerPoolInterface: Interface;
+export declare const gearboxVaultInterface: Interface;
+export declare const auraOperatorInterface: Interface;
+export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound3.d.ts

@@ -0,0 +1,6 @@
+import { Interface } from "@ethersproject/abi";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
+export declare const BALANCER_VAULT_ADDRESS = "0xBA12222222228d8Ba445958a75a0704d566BF2C8";
+export declare const balancerVaultInterface: Interface;
+export declare function getTokenTypeRound3(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound4.d.ts

@@ -0,0 +1,4 @@
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound4(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20_SNAPSHOTDynamicData.d.ts

@@ -0,0 +1,5 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+type ReturnType = CampaignDynamicData<Campaign.ERC20_SNAPSHOT>[];
+export declare function ERC20_SNAPSHOTDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.ERC20_SNAPSHOT>[]): Promise<UncachedResult<Partial<ReturnType>>>;
+export {};

package/dist/src/libs/campaigns/campaignTypes/EulerDynamicData.d.ts

@@ -0,0 +1,3 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export declare function EulerDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.EULER>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.EULER>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/JSON_AIRDROPDynamicData.d.ts

@@ -0,0 +1,5 @@
+import type { Campaign, CampaignDynamicData, CampaignParameters, MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+type ReturnType = CampaignDynamicData<Campaign.JSON_AIRDROP>[];
+export declare function JSON_AIRDROPDynamicData(_chainId: MerklChainId, campaigns: CampaignParameters<Campaign.JSON_AIRDROP>[]): Promise<UncachedResult<Partial<ReturnType>>>;
+export {};

package/dist/src/libs/campaigns/campaignTypes/MORPHODynamicData.d.ts

@@ -0,0 +1,5 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+type ReturnType = Partial<CampaignDynamicData<Campaign.MORPHO>[]>;
+export declare function MORPHODynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.MORPHO>[]): Promise<UncachedResult<ReturnType>>;
+export {};

package/dist/src/libs/campaigns/campaignTypes/RadiantDynamicData.d.ts

@@ -0,0 +1,3 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export declare function RadiantDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.RADIANT>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.RADIANT>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/SILODynamicData.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import { utils } from "ethers";
+import type { UncachedResult } from "../../../utils/execute";
+export declare const SILO_INTERFACE: utils.Interface;
+type ReturnType = Partial<CampaignDynamicData<Campaign.SILO>[]>;
+export declare function SILODynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.SILO>[]): Promise<UncachedResult<ReturnType>>;
+export {};

package/dist/src/libs/campaigns/campaignsDynamicData.d.ts

@@ -0,0 +1,3 @@
+import { Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../utils/execute";
+export declare function campaignsDynamicData<T extends Campaign>(chainId: MerklChainId, campaigns: CampaignParameters<T>[], type: T): Promise<UncachedResult<Partial<CampaignDynamicData<T>[]>>>;

package/dist/src/libs/campaigns/getCampaigns.d.ts

@@ -0,0 +1 @@
+export declare function getCampaigns(chainId: number): Promise<any>;

package/dist/src/libs/campaigns/getRewards.d.ts

@@ -0,0 +1,29 @@
+import { type MerklChainId } from "@sdk";
+export type RewardsT = {
+    [chainId: number]: {
+        tokenData: {
+            [token: string]: {
+                accumulated: string;
+                unclaimed: string;
+                decimals: number;
+                symbol: string;
+                proof: string[];
+            };
+        };
+        campaignData: {
+            [campaignId: string]: {
+                [reason: string]: {
+                    accumulated: string;
+                    unclaimed: string;
+                    token: string;
+                    decimals: number;
+                    symbol: string;
+                    mainParameter: string;
+                    auxiliaryData1: string;
+                    auxiliaryData2: string;
+                };
+            };
+        };
+    };
+};
+export declare const getRewards: (chainIds: MerklChainId[], user: string, merklRoots: string[], creatorTag?: string) => Promise<RewardsT>;

package/dist/src/libs/campaigns/utils/fetchA51Strategies.d.ts

@@ -0,0 +1,18 @@
+import { type MerklChainId } from "@sdk";
+export declare type A51StrategiesType = {
+    pool: string;
+    vault: string;
+    id: string;
+    tickLower: number;
+    tickUpper: number;
+};
+export type A51StrategiesReturnType = {
+    [pool: string]: {
+        [vault: string]: {
+            id: string;
+            tickLower: number;
+            tickUpper: number;
+        }[];
+    };
+};
+export declare function fetchA51Strategies(chainId: MerklChainId, pools: string[]): Promise<A51StrategiesReturnType>;

package/dist/src/libs/campaigns/utils/fetchClamInfo.d.ts

@@ -0,0 +1,2 @@
+import type { Campaigns } from "../../../../database/engine/.generated";
+export declare function fetchClamInfo(campaigns: Campaigns[]): Promise<void>;

package/dist/src/libs/campaigns/utils/fetchLogs.d.ts

@@ -0,0 +1,10 @@
+import type { MerklChainId } from "@sdk";
+export type LogType = {
+    data: string;
+    topics: ReadonlyArray<string>;
+    blockNumber: string;
+    address: string;
+    blockHash: string;
+    logIndex: string;
+};
+export declare function safeFetchLogs(chainId: MerklChainId, topics: string[], addresses: string[], fromBlock: number, toBlock: number): Promise<LogType[]>;

package/dist/src/libs/campaigns/utils/getCompV2ForksVaults.d.ts

@@ -0,0 +1,19 @@
+import { type MerklChainId } from "@sdk";
+export type CompoundVaultType = {
+    address: string;
+    asset: string;
+    chainId: MerklChainId;
+    debtTokenAddress: string;
+    name: string;
+};
+export type CompoundVaultsType = {
+    [chainId_compFork: string]: {
+        address: string;
+        symbolCToken: string;
+        decimalsCToken: number;
+        underlying: string;
+        symbolUnderlying: string;
+        decimalsUnderlying: number;
+    }[];
+};
+export declare const getCompoundV2ForksVaultsWithCache: () => Promise<CompoundVaultsType>;

package/dist/src/libs/campaigns/utils/getContractCreationBlock.d.ts

@@ -0,0 +1,2 @@
+import type { JsonRpcProvider } from "@ethersproject/providers";
+export declare function getContractCreationBlock(contractAddress: string, provider: JsonRpcProvider): Promise<number | undefined>;

package/dist/src/libs/campaigns/utils/getDolomiteMarkets.d.ts

@@ -0,0 +1,7 @@
+export type DolomiteMarketT = {
+    index: number;
+    token: string;
+    symbol: string;
+}[];
+export declare const getDomiteMarkets: () => Promise<DolomiteMarketT>;
+export declare const getDolomiteMarketWithCache: () => Promise<DolomiteMarketT>;

package/dist/src/libs/campaigns/utils/getEulerV2Vaults.d.ts

@@ -0,0 +1,16 @@
+import { type MerklChainId } from "@sdk";
+export type EulerVaultType = {
+    address: string;
+    asset: string;
+    chainId: MerklChainId;
+    debtTokenAddress: string;
+    name: string;
+    collaterals: {
+        address: string;
+        borrowLTV: string;
+        nameCollateral: string;
+        symbolCollateral: string;
+        symbolUnderlying: string;
+    }[];
+};
+export declare const getEulerV2VaultsWithCache: () => Promise<EulerVaultType[]>;

package/dist/src/libs/campaigns/utils/getLastEligibilityRatio.d.ts

@@ -0,0 +1,2 @@
+import type { Campaign, CampaignParameters, MerklChainId } from "@sdk";
+export declare const getLastEligibilityRatio: (campaign: CampaignParameters<Campaign>, chainId: MerklChainId, currentRoot: string, backupCampaignIds: string[]) => Promise<number>;

package/dist/src/libs/computeFee.d.ts

@@ -0,0 +1,4 @@
+import { type Campaign, type MerklChainId, type campaignConfig } from "@sdk";
+export declare const computeFee: (chainId: MerklChainId, config: campaignConfig<Campaign>) => Promise<{
+    fee: string;
+}>;

package/dist/src/libs/custom/twtParticipants.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+export declare function getTwtParticipants(chainId: MerklChainId): Promise<{
+    participants: number;
+    totalSupply: number;
+}>;
+export declare const getTwtParticipantsWithCache: (chainId: MerklChainId) => Promise<any>;

package/dist/src/libs/deprecated-merklv3/index.d.ts

@@ -0,0 +1,5 @@
+import type { CampaignsCacheUpdaterReturnType } from "../../backgroundJobs/jobs/campaignsCacheUpdater";
+import { AMM, type ChainId, type MerklAPIType } from "@sdk";
+import type { MerklChainData } from "../../types";
+export declare function getClamsInfo(chainIds?: number[] | readonly ChainId[], AMMs?: Lowercase<keyof typeof AMM>[], user?: string, onlyLive?: boolean): Promise<MerklAPIType>;
+export declare function campaignsToOldFormat(campaignData: CampaignsCacheUpdaterReturnType, merklChainData: MerklChainData): MerklAPIType[number];

package/dist/src/libs/getTokensList.d.ts

@@ -0,0 +1,27 @@
+export interface Token {
+    readonly name: string;
+    readonly address: string;
+    readonly decimals: number;
+    readonly symbol: string;
+    readonly useInSwap?: boolean;
+    readonly hasPermit?: boolean;
+    readonly permitVersion?: string;
+    readonly logoURI?: string;
+    readonly tags?: string[];
+    readonly wrappingMethod?: "Curve" | "BorrowStaker" | "Aave Matic Market" | "Wrap Native" | "Convex";
+    readonly underlyingTokens?: string[];
+}
+export interface TokenInfoListType {
+    [symbol: string]: Token;
+}
+export interface TokenList {
+    [chainId: number]: TokenInfoListType;
+}
+export declare const getTokensListWithCache: () => Promise<TokenList>;
+export type MerklTokens = {
+    [address: string]: {
+        symbol: string;
+        decimals: number;
+    };
+};
+export declare function getMerklTokenList(chainId: number): Promise<MerklTokens>;

package/dist/src/libs/merklChainData.d.ts

@@ -0,0 +1,4 @@
+import { type MerklChainId } from "@sdk";
+import type { MerklChainData } from "../types";
+export declare function merklChainData(chainId: MerklChainId): Promise<MerklChainData>;
+export declare const merklChainDataWithCache: (chainId: MerklChainId) => Promise<any>;

package/dist/src/libs/parse/marketsWithCache.d.ts

@@ -0,0 +1,4 @@
+import { type MerklChainId } from "@sdk";
+export declare const getMorphoMarketsWithCache: (chainId: MerklChainId, subtype: string) => Promise<any>;
+export declare const getRadiantMarketsWithCache: (chainId: MerklChainId, poolAddressProvider: string) => Promise<any>;
+export declare const getSiloMarketsWithCache: (chainId: MerklChainId, repository: string) => Promise<any>;

package/dist/src/libs/positions/ajna/index.d.ts

@@ -0,0 +1,41 @@
+import { type Forwarder, type ForwarderParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export type UserPosition = {
+    balance: number;
+    token: string;
+    origin: string;
+    totalSupply: number;
+    tvl: number;
+};
+export type FetchedCampaign = {
+    rewardToken: string;
+    targetToken: string;
+    symbolRewardToken: string;
+    subtype: number;
+    tvl: number;
+    poolId: string;
+    decimals: number;
+    totalSupplyTargetToken: number;
+    computedtotalSupply: number;
+    amount: number;
+    forwarders?: {
+        [address: string]: ForwarderParameters<Forwarder>;
+    };
+};
+export type MorphoPositionType = {
+    [mainParameter: string]: {
+        userPositions: UserPosition[];
+        decimals: number;
+        totalSupply: number;
+        userTVL: number;
+    };
+};
+export type Res = {
+    userPositions: UserPosition[];
+    decimals: number;
+    totalSupply: number;
+    userTVL: number;
+};
+export declare function getAjnaUserPositions(user: string, _chainId: MerklChainId, campaigns: {
+    [mainparameter: string]: FetchedCampaign;
+}): Promise<UncachedResult<MorphoPositionType>>;

package/dist/src/libs/positions/badger/index.d.ts

@@ -0,0 +1,27 @@
+import { type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+import type { FetchedCampaign } from "../morpho";
+export type UserPosition = {
+    balance: number;
+    token: string;
+    origin: string;
+    totalSupply: number;
+    tvl: number;
+};
+export type MorphoPositionType = {
+    [mainParameter: string]: {
+        userPositions: UserPosition[];
+        decimals: number;
+        totalSupply: number;
+        userTVL: number;
+    };
+};
+export type Res = {
+    userPositions: UserPosition[];
+    decimals: number;
+    totalSupply: number;
+    userTVL: number;
+};
+export declare function getBadgerUserPositions(user: string, _chainId: MerklChainId, campaigns: {
+    [mainparameter: string]: FetchedCampaign;
+}): Promise<UncachedResult<MorphoPositionType>>;

package/dist/src/libs/positions/clamm/index.d.ts

@@ -0,0 +1,8 @@
+import { type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+import type { CLAMMPosition } from "../types";
+export declare function getClammUserPositions(user: string, chainId: MerklChainId, poolsByAmm: {
+    [amm: string]: {
+        [pool: string]: any;
+    };
+}): Promise<UncachedResult<CLAMMPosition>>;

package/dist/src/libs/positions/clamm/thegraph/fetchAlmPositions.d.ts

@@ -0,0 +1,5 @@
+import { type MerklChainId } from "@sdk";
+import { BigNumber } from "ethers";
+export declare function fetchAlmPositionsV2(chainId: MerklChainId, user: string): Promise<{
+    [token: string]: BigNumber;
+}>;

package/dist/src/libs/positions/clamm/thegraph/fetchAmmPositions.d.ts

@@ -0,0 +1,8 @@
+import { AMM, type ANGLE_NETWORKS } from "@sdk";
+import { type PositionType } from ".";
+export declare function fetchAmmPositionsV2(chainId: (typeof ANGLE_NETWORKS.merkl)[number], user: string, amms: AMM[]): Promise<{
+    [amm in AMM]?: {
+        nft: PositionType[];
+        direct: PositionType[];
+    };
+}>;

package/dist/src/libs/positions/clamm/thegraph/fetchFarmedPositions.d.ts

@@ -0,0 +1,11 @@
+import { AMM, type MerklChainId } from "@sdk";
+export type FarmPositionsType = {
+    [nftWrapper: string]: {
+        farmAddress: string;
+        id: string;
+        pool: string;
+        holder: string;
+    }[];
+};
+export declare function fetchFarmedPositionsV2(chainId: MerklChainId, owners: string[], amm: AMM): Promise<FarmPositionsType>;
+export declare const fetchFarmedPositionsV2WithCache: (chainId: MerklChainId, user: string[], amm: AMM) => Promise<any>;

package/dist/src/libs/positions/clamm/thegraph/index.d.ts

@@ -0,0 +1,37 @@
+export type TGUniswapV3Positions = {
+    id: string;
+    liquidity: string;
+    tickLower: {
+        id: string;
+    };
+    tickUpper: {
+        id: string;
+    };
+    token0?: {
+        symbol: string;
+    };
+    token1?: {
+        symbol: string;
+    };
+};
+export declare type PositionType = {
+    id: string;
+    startTimestamp: number;
+    endTimestamp: number;
+    pool: {
+        id: string;
+    };
+    tickLower: string;
+    tickUpper: string;
+    liquidity: string;
+    owner: string;
+    handler?: string;
+};
+export declare const positionsQuery: string;
+export declare const nftWrapperPositionsQuery: string;
+export declare const nftPositionByIdsQuery: string;
+/** Queries */
+export declare const positionMultipleOwnersQuery: string;
+export declare const positionsWithPastQuery: string;
+export declare const almBalancesQuery: string;
+export declare const almNFTBalancesQuery: string;