@merkl/api 0.10.80 → 0.10.82

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/FluidProcessor.d.ts

@@ -0,0 +1,39 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawFluid;
+    call: string;
+    target: keyof callKeysFluid;
+    metaData?: any;
+};
+type callKeysFluid = callKeys & {
+    underlying: string;
+    exchangeRate: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    amount: string;
+    toAssets: string;
+};
+type dataRawFluid = callKeysFluid & {};
+type dataTypeFluid = dataType & {
+    underlying: string;
+    exchangeRate: number;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    totalSupply: number;
+    amount: string;
+    toAssets: string;
+};
+export declare class FluidProcessor extends GenericProcessor<callKeysFluid, dataRawFluid, dataTypeFluid> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawFluid, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFluid>;
+    processingRound3(typeInfo: dataRawFluid): void;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/FraxProcessor.d.ts

@@ -0,0 +1,33 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawFrax;
+    call: string;
+    target: keyof callKeysFrax;
+    metaData?: any;
+};
+type callKeysFrax = callKeys & {
+    underlying: string;
+    sharePrice: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+type dataRawFrax = callKeysFrax & {};
+type dataTypeFrax = dataType & {
+    underlying: string;
+    sharePrice: number;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+export declare class FraxProcessor extends GenericProcessor<callKeysFrax, dataRawFrax, dataTypeFrax> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawFrax, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFrax>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GearboxProcessor.d.ts

@@ -0,0 +1,40 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawGearbox;
+    call: string;
+    target: keyof callKeysGearbox;
+    metaData?: any;
+};
+type callKeysGearbox = callKeys & {
+    stakingToken: string;
+    balanceStakingToken: string;
+    underlyingToken: string;
+    totalSupplyStakingToken: string;
+    decimalsStakingToken: string;
+    totalAssets: string;
+    decimalsUnderlyingToken: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawGearbox = callKeysGearbox & {};
+type dataTypeGearbox = dataType & {
+    stakingToken: string;
+    balanceStakingToken: number;
+    underlyingToken: string;
+    totalSupplyStakingToken: number;
+    decimalsStakingToken: string;
+    totalAssets: number;
+    percentageOfSupplyUnderlyingPoolTokens: number;
+};
+export declare class GearboxProcessor extends GenericProcessor<callKeysGearbox, dataRawGearbox, dataTypeGearbox> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawGearbox, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGearbox>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/MetamorphoProcessor.d.ts

@@ -0,0 +1,31 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawMetamorpho;
+    call: string;
+    target: keyof callKeysMetamorpho;
+    metaData?: any;
+};
+type callKeysMetamorpho = callKeys & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawMetamorpho = callKeysMetamorpho & {};
+type dataTypeMetamorpho = dataType & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+    priceTargetToken: number;
+};
+export declare class MetamorphoProcessor extends GenericProcessor<callKeysMetamorpho, dataRawMetamorpho, dataTypeMetamorpho> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawMetamorpho, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeMetamorpho>;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawMetamorpho, calls: string[]): tokenTypeStruct;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/PendleProcessor.d.ts

@@ -0,0 +1,27 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawTemplate;
+    call: string;
+    target: keyof callKeysTemplate;
+    metaData?: any;
+};
+type callKeysTemplate = callKeys & {
+    readTokensRaw: string[];
+    SYToken: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawTemplate = callKeysTemplate & {};
+type dataTypeTemplate = dataType & {};
+export declare class PendleProcessor extends GenericProcessor<callKeysTemplate, dataRawTemplate, dataTypeTemplate> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeTemplate>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/RadiantProcessor.d.ts

@@ -0,0 +1,32 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawRadiant;
+    call: string;
+    target: keyof callKeysRadiant;
+    metaData?: any;
+};
+type callKeysRadiant = callKeys & {
+    underlyingToken: string;
+    priceBN: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawRadiant = callKeysRadiant & {};
+type dataTypeRadiant = dataType & {
+    priceTargetToken: number;
+    underlyingToken: string;
+    symbolUnderlyingToken: string;
+};
+export declare class RadiantProcessor extends GenericProcessor<callKeysRadiant, dataRawRadiant, dataTypeRadiant> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawRadiant, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeRadiant>;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawRadiant, calls: string[]): tokenTypeStruct;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SpliceProcessor.d.ts

@@ -0,0 +1,16 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callKeysSplice = callKeys & {
+    priceTargetToken: string;
+};
+type dataRawSplice = callKeysSplice & {};
+type dataTypeSplice = dataType & {
+    priceTargetToken: number;
+};
+export declare class SpliceProcessor extends GenericProcessor<callKeysSplice, dataRawSplice, dataTypeSplice> {
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawSplice, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeSplice>;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawSplice, calls: string[]): tokenTypeStruct;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SturdySiloProcessor.d.ts

@@ -0,0 +1,39 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawSturdySilo;
+    call: string;
+    target: keyof callKeysSturdySilo;
+    metaData?: any;
+};
+type callKeysSturdySilo = callKeys & {
+    underlying: string;
+    sharePrice: string;
+    collateralContract: string;
+    collateral: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    symbolCollateral: string;
+};
+type dataRawSturdySilo = callKeysSturdySilo & {};
+type dataTypeSturdySilo = dataType & {
+    underlying: string;
+    sharePrice: number;
+    collateral: string;
+    collateralContract: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    symbolCollateral: string;
+};
+export declare class SturdySiloProcessor extends GenericProcessor<callKeysSturdySilo, dataRawSturdySilo, dataTypeSturdySilo> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawSturdySilo, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeSturdySilo>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/TorosProcessor.d.ts

@@ -0,0 +1,29 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawToros;
+    call: string;
+    target: keyof callKeysToros;
+    metaData?: any;
+};
+type callKeysToros = callKeys & {
+    tokenPrice: string;
+};
+type dataRawToros = callKeysToros & {};
+type dataTypeToros = dataType & {
+    tokenPrice: string;
+    priceTargetToken: number;
+    symbolUnderlyingToken: string;
+};
+export declare class TorosProcessor extends GenericProcessor<callKeysToros, dataRawToros, dataTypeToros> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawToros, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeToros>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/curveProcessor.d.ts

@@ -0,0 +1,47 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawCurve;
+    call: string;
+    target: keyof callKeysCurve;
+    metaData?: any;
+    optional?: boolean;
+};
+type callKeysCurve = callKeys & {
+    lp_price: string;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+};
+type dataRawCurve = callKeysCurve & {
+    poolTokens: {
+        [key: string]: string;
+    };
+};
+type dataTypeCurve = dataType & {
+    lp_price: number;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+    poolTokens: {
+        [key: string]: string;
+    };
+};
+export declare class CurveProcessor extends GenericProcessor<callKeysCurve, dataRawCurve, dataTypeCurve> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawCurve, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCurve>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/genericProcessor.d.ts

@@ -0,0 +1,61 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { type tokenType, type tokenTypeStruct } from "../helpers/tokenType";
+export declare enum roundType {
+    one = "round1",
+    two = "round2",
+    three = "round3",
+    four = "round4"
+}
+export type callType = {
+    key: any;
+    call: any;
+    target: any;
+    metaData?: any;
+    optional?: boolean;
+};
+export type callKeys = {
+    [key: string]: string;
+    tokenAddress: string;
+    blacklistedSupply: string;
+    totalSupply: string;
+};
+export type dataRaw = {
+    tokenAddress: string;
+    blacklistedSupply: string;
+    totalSupply: string;
+};
+export type dataType = {
+    tokenAddress: string;
+    totalSupply: number;
+    blacklistedSupply: number;
+    tvl: number;
+    cardName: string;
+    priceTargetToken: number;
+};
+export declare class GenericProcessor<Input extends callKeys, DataRaw extends dataRaw, Output extends dataType> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    debug: boolean;
+    processingRound1(typeInfo: DataRaw): void;
+    processingRound2(typeInfo: DataRaw): void;
+    processingRound3(typeInfo: DataRaw): void;
+    processingRound4(typeInfo: DataRaw): void;
+    processingRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<Output>;
+    computeRound1(type: tokenType, typeInfo: DataRaw): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20>): Multicall3.Call3Struct[];
+    decodeBlackListedSupply(index: number, decimals: number, blacklist: string[], calls: string[]): string;
+    decodeRound(round: callType[], index: number, calls: string[], type: tokenType, data: DataRaw): void;
+    decodePreviousRound(round: roundType, calls: string[], data: DataRaw, type: tokenType, index: number): void;
+    encodeRound(round: callType[], callInfo: Input, type: tokenType): Multicall3.Call3Struct[];
+    encodeNextRound(round: roundType, type: tokenType, data: DataRaw): Multicall3.Call3Struct[];
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/processorMapping.d.ts

@@ -0,0 +1,6 @@
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor } from "./GenericProcessor";
+import type { callKeys, dataRaw, dataType } from "./GenericProcessor";
+export declare const processorMapping: {
+    [key in tokenType]: typeof GenericProcessor<callKeys, dataRaw, dataType>;
+};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/templateProcessor.d.ts

@@ -0,0 +1,32 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawTemplate;
+    call: string;
+    target: keyof callKeysTemplate;
+    metaData?: any;
+};
+type callKeysTemplate = callKeys & {};
+type dataRawTemplate = callKeysTemplate & {};
+type dataTypeTemplate = dataType & {};
+export declare class TemplateProcessor extends GenericProcessor<callKeysTemplate, dataRawTemplate, dataTypeTemplate> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawTemplate): void;
+    processingRound2(typeInfo: dataRawTemplate): void;
+    processingRound3(typeInfo: dataRawTemplate): void;
+    processingRound4(typeInfo: dataRawTemplate): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeTemplate>;
+    computeRound1(type: tokenType, typeInfo: dataRawTemplate): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/uniswapProcessor.d.ts

@@ -0,0 +1,42 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawUni;
+    call: string;
+    target: keyof callKeysUni;
+    metaData?: any;
+};
+type callKeysUni = callKeys & {
+    token0: string;
+    token1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+};
+type dataRawUni = callKeysUni & {};
+type dataTypeUni = dataType & {
+    token0: string;
+    token1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: number;
+    decimalsToken1: number;
+    balanceToken0: number;
+    balanceToken1: number;
+    priceTargetToken: number;
+};
+export declare class UniswapProcessor extends GenericProcessor<callKeysUni, dataRawUni, dataTypeUni> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawUni, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeUni>;
+}
+export {};

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

@@ -0,0 +1,4 @@
+import type { Pricer } from "../../../../utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { tokenType, 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/subtypesRound1RefactoFinal.d.ts

@@ -0,0 +1,3 @@
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { type tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number): tokenTypeStruct;

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

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

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

@@ -0,0 +1,3 @@
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound3(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;

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

@@ -0,0 +1,4 @@
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import type { tokenType, 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/campaignsDynamicDataRefacto.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 campaignsDynamicDataRefacto<T extends Campaign>(chainId: MerklChainId, campaigns: CampaignParameters<T>[], type: T, nextVersion?: boolean): Promise<UncachedResult<Partial<CampaignDynamicData<T>[]>>>;

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

@@ -53,7 +53,6 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                     200: {
                         aprRecord: {
                             cumulated: number;
-                            cummulated: number;
                             timestamp: bigint;
                             breakdowns: {
                                 id: number;
@@ -141,7 +140,6 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                         200: {
                             aprRecord: {
                                 cumulated: number;
-                                cummulated: number;
                                 timestamp: bigint;
                                 breakdowns: {
                                     id: number;
@@ -239,7 +237,6 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                     200: ({
                         aprRecord: {
                             cumulated: number;
-                            cummulated: number;
                             timestamp: bigint;
                             breakdowns: {
                                 id: number;

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

@@ -64,7 +64,6 @@ export declare abstract class OpportunityRepository {
         } & {
             id: string;
             timestamp: bigint;
-            cummulated: number;
             cumulated: number;
             opportunityId: string;
         })[];
@@ -123,18 +122,6 @@ export declare abstract class OpportunityRepository {
                 verified: boolean;
                 price: number | null;
             };
-            RewardBreakdown: {
-                id: number;
-                protocolId: string | null;
-                reason: string;
-                amount: string;
-                claimed: string;
-                pending: string;
-                auxiliaryData1: string | null;
-                auxiliaryData2: string | null;
-                rewardId: string;
-                campaignId: string;
-            }[];
         } & {
             id: string;
             computeChainId: number;
@@ -203,7 +190,6 @@ export declare abstract class OpportunityRepository {
         } & {
             id: string;
             timestamp: bigint;
-            cummulated: number;
             cumulated: number;
             opportunityId: string;
         })[];
@@ -323,7 +309,6 @@ export declare abstract class OpportunityRepository {
         } & {
             id: string;
             timestamp: bigint;
-            cummulated: number;
             cumulated: number;
             opportunityId: string;
         })[];
@@ -369,7 +354,6 @@ export declare abstract class OpportunityRepository {
         aprRecord: {
             id: string;
             timestamp: bigint;
-            cummulated: number;
             cumulated: number;
             opportunityId: string;
         };

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

@@ -35,7 +35,6 @@ export declare abstract class OpportunityService {
     static getUniqueWithCampaignsOrThrow(opportunityId: string | OpportunityUnique): Promise<({
         aprRecord: {
             cumulated: number;
-            cummulated: number;
             timestamp: bigint;
             breakdowns: {
                 id: number;
@@ -145,7 +144,6 @@ export declare abstract class OpportunityService {
     static getUniqueOrThrow(opportunityId: string | OpportunityUnique): Promise<{
         aprRecord: {
             cumulated: number;
-            cummulated: number;
             timestamp: bigint;
             breakdowns: {
                 id: number;
@@ -222,7 +220,6 @@ export declare abstract class OpportunityService {
     static getMany(query: GetOpportunitiesQueryEntity): Promise<({
         aprRecord: {
             cumulated: number;
-            cummulated: number;
             timestamp: bigint;
             breakdowns: {
                 id: number;
@@ -304,7 +301,6 @@ export declare abstract class OpportunityService {
     static formatResponse(opportunity: Awaited<ReturnType<typeof OpportunityRepository.findUniqueOrThrow>>): {
         aprRecord: {
             cumulated: number;
-            cummulated: number;
             timestamp: bigint;
             breakdowns: {
                 id: number;

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

@@ -145,6 +145,7 @@ export declare abstract class RewardRepository {
         rewardId: string;
         campaignId: string;
     }[]>;
+    static findManyRootsWithRewardOnChain(chainId: number): Promise<string[]>;
     static breakdownForCampaigns(root: string, campaignIds: string[], query: CampaignIdListModel): Promise<{
         Campaign: {
             identifier: string;