@merkl/api 0.10.199 → 0.10.200

package/dist/src/index.js

@@ -2,9 +2,11 @@ import { cors } from "@elysiajs/cors";
 import { swagger } from "@elysiajs/swagger";
 import axios from "axios";
 import { Elysia } from "elysia";
-import { autoroutes } from "elysia-autoroutes";
 import { redisClient } from "./cache/redis";
 import { v4 } from "./modules/v4/router";
+import { v1 } from "./routes/v1/router";
+import { v2 } from "./routes/v2/router";
+import { v3 } from "./routes/v3/router";
 import { errorHandler } from "./utils/error";
 import { log } from "./utils/logger";
 import { apiDbClient, engineDbClient } from "./utils/prisma";
@@ -18,13 +20,17 @@ const app = new Elysia({
     },
 })
     .use(swagger({
+    scalarConfig: {
+        theme: "kepler",
+        darkMode: true,
+    },
     documentation: {
         info: {
             contact: {
                 email: "contact@merkl.money",
                 name: "Angle Labs",
             },
-            description: "API to access data related to Merkl campaigns, built and maintained by Angle Labs. This API is provided as is, without any warranty of any kind.",
+            description: "The official API to access data related to Merkl campaigns, built and maintained by Angle Labs. This API is provided as is, without any warranty of any kind.",
             license: {
                 name: "UNLICENSED",
             },
@@ -32,15 +38,58 @@ const app = new Elysia({
             version: "1.0.1",
         },
     },
-    exclude: [/engine\/*/, /v1\/.*/, /v2\/.*/, /v3\/.*/, "/"],
+    exclude: [/v4\/.*/, "/"],
+}))
+    .use(swagger({
+    path: "/v4/docs",
+    scalarConfig: {
+        theme: "kepler",
+        darkMode: true,
+    },
+    documentation: {
+        tags: [
+            {
+                name: "Opportunities",
+                description: "An opportunity represents a collection of campaigns.",
+            },
+            {
+                name: "Campaigns",
+                description: "Campaigns are designed to incentivize participation in a protocol by offering rewards to users for specific behaviors or actions.",
+            },
+            {
+                name: "Protocols",
+                description: "Endpoints related to protocols integrated by Merkl.",
+            },
+            {
+                name: "Chains",
+                description: "Endpoints related to chains integrated by Merkl.",
+            },
+            {
+                name: "Users",
+                description: "Endpoints related to Merkl users.",
+            },
+        ],
+        info: {
+            contact: {
+                email: "contact@merkl.money",
+                name: "Angle Labs",
+            },
+            description: "The official API to access data related to Merkl campaigns, built and maintained by Angle Labs. This API is provided as is, without any warranty of any kind.",
+            license: {
+                name: "UNLICENSED",
+            },
+            title: "Merkl API",
+            version: "1.0.1",
+        },
+    },
+    exclude: [/engine\/*/, /v1\/.*/, /v2\/.*/, /v3\/.*/, "/", /swagger\/*/],
 }))
     .use(cors())
     .get("/", () => "Merkl API")
+    .use(v1)
+    .use(v2)
+    .use(v3)
     .use(v4)
-    .use(autoroutes({
-    routesDir: `${import.meta.dir}/routes`,
-    generateTags: false,
-}))
     .use(errorHandler())
     .listen(PORT, ({ hostname, port }) => {
     log.info(`🌐  Api started (${hostname}:${port})`);

package/dist/src/libs/campaigns/campaignTypes/ERC20DynamicData.js

@@ -1,12 +1,12 @@
 import { merklChainDataWithCache } from "../../merklChainData";
-import { BN2Number, ERC20Interface, YEAR, } from "@sdk";
+import { BN2Number, BalancerPoolInterface, ERC20Interface, EnzymeInterface, FactoryInterface, MetamorphoInterface, YEAR, } from "@sdk";
 import { batchMulticallCallWithRetry } from "../../../utils/generic";
 import { Pricer } from "../../../utils/pricer";
 import { getLastEligibilityRatio } from "../utils/getLastEligibilityRatio";
 import { tokenType } from "./ERC20SubTypes/helpers/tokenType";
 import { getTokenPricesInfo } from "./ERC20SubTypes/subtypesPrices";
-import { enzymeInterface, factoryInterface, getTokenTypeRound1, metamorphoInterface, } from "./ERC20SubTypes/subtypesRound1";
-import { balancerPoolInterface, getTokenTypeRound2 } from "./ERC20SubTypes/subtypesRound2";
+import { getTokenTypeRound1 } from "./ERC20SubTypes/subtypesRound1";
+import { getTokenTypeRound2 } from "./ERC20SubTypes/subtypesRound2";
 import { getTokenTypeRound3 } from "./ERC20SubTypes/subtypesRound3";
 import { getTokenTypeRound4 } from "./ERC20SubTypes/subtypesRound4";
 export async function ERC20DynamicData(chainId, campaigns) {
@@ -31,27 +31,23 @@ export async function ERC20DynamicData(chainId, campaigns) {
         }
         callsRounds1.push({
             allowFailure: true,
-            callData: factoryInterface.encodeFunctionData("factory"),
+            callData: FactoryInterface.encodeFunctionData("factory"),
             target: campaign.campaignParameters.targetToken,
-        });
-        callsRounds1.push({
+        }, {
             allowFailure: true,
-            callData: metamorphoInterface.encodeFunctionData("MORPHO"),
+            callData: MetamorphoInterface.encodeFunctionData("MORPHO"),
             target: campaign.campaignParameters.targetToken,
-        });
-        callsRounds1.push({
+        }, {
             allowFailure: true,
             callData: ERC20Interface.encodeFunctionData("name"),
             target: campaign.campaignParameters.targetToken,
-        });
-        callsRounds1.push({
+        }, {
             allowFailure: true,
-            callData: balancerPoolInterface.encodeFunctionData("getPoolId"),
+            callData: BalancerPoolInterface.encodeFunctionData("getPoolId"),
             target: campaign.campaignParameters.targetToken,
-        });
-        callsRounds1.push({
+        }, {
             allowFailure: true,
-            callData: enzymeInterface.encodeFunctionData("getCreator"),
+            callData: EnzymeInterface.encodeFunctionData("getCreator"),
             target: campaign.campaignParameters.targetToken,
         });
     }
@@ -68,7 +64,7 @@ export async function ERC20DynamicData(chainId, campaigns) {
             calls: [],
             typeInfo: {},
         };
-        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i);
+        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i, campaign);
         i += 5;
         tokenTypesByCampaign[campaign.campaignId] = typeStruct;
         callsRounds2.push(...typeStruct.calls);
@@ -128,12 +124,9 @@ export async function ERC20DynamicData(chainId, campaigns) {
                     const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
                     tokenTypesByCampaign[campaign.campaignId] = await getTokenPricesInfo(i, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, result, campaign, pricer);
                     i += callsForCampaign;
-                    const totalSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply;
-                    let whitelistedSupplyTargetToken = totalSupplyTargetToken - tokenTypesByCampaign[campaign.campaignId].typeInfo.blacklistedSupply;
+                    const whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
+                    const totalSupplyTargetToken = whitelistedSupplyTargetToken;
                     const priceTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
-                    if (whitelistedSupplyTargetToken === 0) {
-                        whitelistedSupplyTargetToken = 0.00001;
-                    }
                     let lastEligibilityRatio = 1;
                     if (!!campaign.campaignParameters.hooks?.length) {
                         lastEligibilityRatio = await getLastEligibilityRatio(campaign, chainId, currentRoot, []);
@@ -148,7 +141,7 @@ export async function ERC20DynamicData(chainId, campaigns) {
                             campaign.campaignParameters.duration /
                             (whitelistedSupplyTargetToken * priceTargetToken),
                         totalSupplyTargetToken,
-                        tvl: totalSupplyTargetToken * priceTargetToken,
+                        tvl: whitelistedSupplyTargetToken * priceTargetToken,
                         type: tokenTypesByCampaign[campaign.campaignId].type,
                         typeInfo: tokenTypesByCampaign[campaign.campaignId].typeInfo,
                         priceRewardToken: priceRewardToken,

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/factoryFinder.js

@@ -18,6 +18,7 @@ const factoryAddresses = {
     "0x35A338522a435D46f77Be32C70E215B813D0e3aC": tokenType.pendleYT, // Pendle YT Factory
     "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73": tokenType.pancakeswap, // PancakeSwap Factory BNB
     "0x70ee0A6DB4F5a2Dc4d9c0b57bE97B9987e75BAFD": tokenType.pendleYT, // Pendle YT Factory
+    "0xFD513630F697A9C1731F196185fb9ebA6eAAc20B": tokenType.cpmmGamma, // CPMMGAMMA Factory
 };
 export function getTypeFromFactoryAddress(address) {
     if (factoryAddresses[address]) {

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

@@ -58,7 +58,9 @@ export declare enum tokenType {
     pancakeswap = "pancakeswap",
     tempestStaking = "tempestStaking",
     holdstation = "holdstation",
-    staking = "staking"
+    staking = "staking",
+    noLinkVault = "noLinkVault",
+    cpmmGamma = "cpmmGamma"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.js

@@ -60,6 +60,8 @@ export var tokenType;
     tokenType["tempestStaking"] = "tempestStaking";
     tokenType["holdstation"] = "holdstation";
     tokenType["staking"] = "staking";
+    tokenType["noLinkVault"] = "noLinkVault";
+    tokenType["cpmmGamma"] = "cpmmGamma";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave" },
@@ -143,4 +145,10 @@ export const tokenTypeToProtocol = {
     [tokenType.staking]: {
         protocol: "Staking",
     },
+    [tokenType.noLinkVault]: {
+        protocol: "NoLinkVault",
+    },
+    [tokenType.cpmmGamma]: {
+        protocol: "GammaSwap",
+    },
 };

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

@@ -0,0 +1,43 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawGamma;
+    call: string;
+    target: keyof callKeysGamma;
+    metaData?: keyof callKeysGamma;
+};
+type callKeysGamma = mandatoryCallKeys & {
+    token0: string;
+    token1: string;
+    CFMMPrice: string;
+    cfmm: string;
+};
+type dataRawGamma = callKeysGamma & {
+    tokensRaw: string[];
+    tokenBalances: string[];
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+};
+type dataTypeGamma = dataType & {};
+export declare class GammaProcessor extends GenericProcessor<callKeysGamma, dataRawGamma, dataTypeGamma> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawGamma): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGamma>;
+    computeRound1(type: tokenType, typeInfo: dataRawGamma): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GammaProcessor.js

@@ -0,0 +1,63 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class GammaProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "tokensRaw", call: "tokensRaw", target: "tokenAddress" },
+            { key: "tokenBalances", call: "tokenBalances", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "symbolToken0", call: "symbol", target: "token0" },
+            { key: "symbolToken1", call: "symbol", target: "token1" },
+            { key: "decimalsToken0", call: "decimals", target: "token0" },
+            { key: "decimalsToken1", call: "decimals", target: "token1" },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    processingRound2(typeInfo) {
+        typeInfo.token0 = typeInfo.tokensRaw[0];
+        typeInfo.token1 = typeInfo.tokensRaw[1];
+        typeInfo.balanceToken0 = typeInfo.tokenBalances[0];
+        typeInfo.balanceToken1 = typeInfo.tokenBalances[1];
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const decimalsToken0 = Number(typeInfo.decimalsToken0);
+        const decimalsToken1 = Number(typeInfo.decimalsToken1);
+        const priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+        const priceToken1 = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        const balanceToken0 = BN2Number(typeInfo.balanceToken0, decimalsToken0);
+        const balanceToken1 = BN2Number(typeInfo.balanceToken1, decimalsToken1);
+        let tvl = 0;
+        if (priceToken0 !== 0 && priceToken1 !== 0) {
+            tvl = priceToken0 * balanceToken0 + priceToken1 * balanceToken1;
+        }
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            priceTargetToken,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            tvl,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+    computeRound1(type, typeInfo) {
+        return super.computeRound1(type, typeInfo);
+    }
+    computeRound2(index, type, typeInfo, calls) {
+        return super.computeRound2(index, type, typeInfo, calls);
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        return super.computeRound4(index, type, typeInfo, calls, campaign);
+    }
+    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
+        return super.computeRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+}

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

@@ -60,10 +60,10 @@ export declare class GenericProcessor<Input extends callKeys, DataRaw extends da
     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;
+    computeRound4(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;
     computeRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
-    generateWhitelistCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20>): Multicall3.Call3Struct[];
-    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20>): Multicall3.Call3Struct[];
+    generateWhitelistCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): Multicall3.Call3Struct[];
+    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): Multicall3.Call3Struct[];
     decodeListedSupply(index: number, decimals: number, list: 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;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GenericProcessor.js

@@ -177,7 +177,9 @@ export class GenericProcessor {
                     index++;
                     data[key] = value;
                 }
-                catch (error) { }
+                catch (error) {
+                    index++;
+                }
             }
             else {
                 const value = decodeCall(calls, index, call, type);

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

@@ -0,0 +1,36 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawNoLinkVault;
+    call: string;
+    target: keyof callKeysNoLinkVault;
+    metaData?: keyof callKeysNoLinkVault;
+};
+type callKeysNoLinkVault = mandatoryCallKeys & {
+    rateAccountant: string;
+    base: string;
+};
+type dataRawNoLinkVault = callKeysNoLinkVault & {
+    rate: string;
+};
+type dataTypeNoLinkVault = dataType & {
+    rate: number;
+};
+export declare class NoLinkVaultProcessor extends GenericProcessor<callKeysNoLinkVault, dataRawNoLinkVault, dataTypeNoLinkVault> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawNoLinkVault): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawNoLinkVault, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeNoLinkVault>;
+    computeRound1(type: tokenType, typeInfo: dataRawNoLinkVault): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: dataRawNoLinkVault, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawNoLinkVault, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawNoLinkVault, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: dataRawNoLinkVault, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/NoLinkVaultProcessor.js

@@ -0,0 +1,51 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class NoLinkVaultProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [
+            { key: "rate", call: "getRate", target: "rateAccountant" },
+            { key: "base", call: "base", target: "rateAccountant" },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    processingRound1(typeInfo) {
+        if (typeInfo.tokenAddress === "0x196ead472583Bc1e9aF7A05F860D9857e1Bd3dCc") {
+            typeInfo.rateAccountant = "0xA9fB7e2922216deBE3Fd5E1bBE7591eE446Dc21c";
+        }
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        const rate = BN2Number(typeInfo.rate, Number(campaign.campaignParameters.decimalsTargetToken));
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        console.log(typeInfo.base);
+        const priceTargetToken = rate * ((await pricer.get({ symbol: typeInfo.base })) ?? 0);
+        const tvl = whitelistedSupplyTargetToken * priceTargetToken;
+        return {
+            tokenAddress: typeInfo.tokenAddress,
+            whitelistedSupplyTargetToken,
+            rate,
+            totalSupply,
+            priceTargetToken,
+            tvl,
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+    computeRound1(type, typeInfo) {
+        return super.computeRound1(type, typeInfo);
+    }
+    computeRound2(index, type, typeInfo, calls) {
+        return super.computeRound2(index, type, typeInfo, calls);
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        return super.computeRound4(index, type, typeInfo, calls, campaign);
+    }
+    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
+        return super.computeRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+}

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

@@ -25,7 +25,6 @@ export declare class StakingProcessor extends GenericProcessor<callKeysStaking,
         round3: callType[];
         round4: callType[];
     };
-    processingRound1(typeInfo: dataRawStaking): void;
     processingRound2(typeInfo: dataRawStaking): void;
     processingRound3(typeInfo: dataRawStaking): void;
     processingRound4(typeInfo: dataRawStaking): void;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/StakingProcessor.js

@@ -10,16 +10,24 @@ export class StakingProcessor extends GenericProcessor {
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
     // override computeRound1(): void {}
-    processingRound1(typeInfo) {
-        if (typeInfo.stakingContract === "0x18eeD20f71BEf84B605253C89A7576E3634134C0") {
-            typeInfo.stakingSymbol = "CyberStaking";
-        }
-    }
     processingRound2(typeInfo) {
-        typeInfo.stakingSymbol = typeInfo.eip712DomainName;
+        if (typeInfo.stakingSymbol === undefined) {
+            typeInfo.stakingSymbol = typeInfo.eip712DomainName;
+        }
     }
     processingRound3(typeInfo) {
-        super.processingRound3(typeInfo);
+        if (typeInfo.stakingSymbol === undefined &&
+            typeInfo.stakingContract === "0x18eeD20f71BEf84B605253C89A7576E3634134C0") {
+            typeInfo.stakingSymbol = "CyberStaking";
+        }
+        if (typeInfo.stakingSymbol === undefined &&
+            typeInfo.stakingContract === "0x68754d29f2e97B837Cb622ccfF325adAC27E9977") {
+            typeInfo.stakingSymbol = "Karak";
+        }
+        if (typeInfo.stakingSymbol === undefined &&
+            typeInfo.stakingContract === "0xcd28cF8f7755f03967D27E128B38022B63919836") {
+            typeInfo.stakingSymbol = "Llamalend";
+        }
     }
     processingRound4(typeInfo) {
         super.processingRound4(typeInfo);

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/processorMapping.js

@@ -11,11 +11,13 @@ import { EulerBorrowProcessor } from "./EulerBorrowProcessor";
 import { EulerLendProcessor } from "./EulerLendProcessor";
 import { FluidProcessor } from "./FluidProcessor";
 import { FraxProcessor } from "./FraxProcessor";
+import { GammaProcessor } from "./GammaProcessor";
 import { GearboxProcessor } from "./GearboxProcessor";
 import { GenericProcessor } from "./GenericProcessor";
 import { HoldStationProcessor } from "./HoldStationProcessor";
 import { MaverickBPProcessor } from "./MaverickBPProcessor";
 import { MetamorphoProcessor } from "./MetamorphoProcessor";
+import { NoLinkVaultProcessor } from "./NoLinkVaultProcessor";
 import { PendleProcessor } from "./PendleProcessor";
 import { PendleYTProcessor } from "./PendleYTProcessor";
 import { RadiantProcessor } from "./RadiantProcessor";
@@ -90,4 +92,6 @@ export const processorMapping = {
     [tokenType.tempestStaking]: TempestVaultProcessor,
     [tokenType.holdstation]: HoldStationProcessor,
     [tokenType.staking]: StakingProcessor,
+    [tokenType.noLinkVault]: NoLinkVaultProcessor,
+    [tokenType.cpmmGamma]: GammaProcessor,
 };

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

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