@merkl/api 0.16.30 → 0.16.32

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

@@ -25,6 +25,17 @@ export class GenericProcessor {
         round3: [],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
+    stakingRounds = {
+        round1: [
+            { key: "lockNFT", call: "lockNFT", target: "stakingContract", optional: true },
+            { key: "eip712DomainName", call: "eip712DomainName", target: "stakingContract", optional: true },
+            { key: "stakingName", call: "name", target: "stakingContract", optional: true },
+            { key: "stakingSymbol", call: "symbol", target: "stakingContract", optional: true },
+        ],
+        round2: [{ key: "stakingSymbol", call: "symbol", target: "lockNFT", optional: true }],
+        round3: [],
+        round4: [],
+    };
     debug = false;
     processingRound1(_typeInfo) { }
     processingRound2(_typeInfo, _campaign) { }
@@ -60,48 +71,66 @@ export class GenericProcessor {
     computeRound1(type, typeInfo) {
         typeInfo = { type, ...tokenTypeToProtocol[type], ...typeInfo };
         this.processingRound1(typeInfo);
+        let calls = this.encodeNextRound(Round.one, type, typeInfo);
+        if (typeInfo.isStaking === "true") {
+            calls = calls.concat(this.encodeStakingNextRound(Round.one, type, typeInfo));
+        }
         if (this.debug) {
             console.log("Round 1", {
                 type: type,
-                calls: this.encodeNextRound(Round.one, type, typeInfo),
+                calls,
                 typeInfo,
             });
         }
         return {
             type: type,
-            calls: this.encodeNextRound(Round.one, type, typeInfo),
+            calls,
             typeInfo,
         };
     }
     computeRound2(index, type, typeInfo, calls, campaign) {
         this.decodePreviousRound(Round.one, calls, typeInfo, type, index);
+        if (typeInfo.isStaking === "true") {
+            this.decodePreviousStakingRound(Round.one, calls, typeInfo, type, index + this.rounds.round1.length);
+        }
         this.processingRound2(typeInfo, campaign);
+        let nextCalls = this.encodeNextRound(Round.two, type, typeInfo);
+        if (typeInfo.isStaking === "true") {
+            nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.two, type, typeInfo));
+        }
         if (this.debug) {
             console.log("Round 2", {
                 type: type,
-                calls: this.encodeNextRound(Round.two, type, typeInfo),
+                calls: nextCalls,
                 typeInfo,
             });
         }
         return {
             type: type,
-            calls: this.encodeNextRound(Round.two, type, typeInfo),
+            calls: nextCalls,
             typeInfo,
         };
     }
     computeRound3(index, type, typeInfo, calls) {
         this.decodePreviousRound(Round.two, calls, typeInfo, type, index);
+        if (typeInfo.isStaking === "true") {
+            this.decodePreviousStakingRound(Round.two, calls, typeInfo, type, index + this.rounds.round2.length);
+        }
         this.processingRound3(typeInfo);
+        let nextCalls = this.encodeNextRound(Round.three, type, typeInfo);
+        if (typeInfo.isStaking === "true") {
+            nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.three, type, typeInfo));
+        }
         if (this.debug) {
             console.log("Round 3", {
                 type: type,
-                calls: this.encodeNextRound(Round.three, type, typeInfo),
+                calls: nextCalls,
                 typeInfo,
             });
         }
         return {
             type: type,
-            calls: this.encodeNextRound(Round.three, type, typeInfo),
+            calls: nextCalls,
             typeInfo,
         };
     }
@@ -109,19 +138,24 @@ export class GenericProcessor {
         const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
         const whitelistedLiquidityCalls = this.generateWhitelistCall(type, typeInfo, campaign);
         this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
+        if (typeInfo.isStaking === "true") {
+            this.decodePreviousStakingRound(Round.three, calls, typeInfo, type, index + this.rounds.round3.length);
+        }
         this.processingRound4(typeInfo);
+        let nextCalls = this.encodeNextRound(Round.four, type, typeInfo);
+        if (typeInfo.isStaking === "true") {
+            nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.four, type, typeInfo));
+        }
         if (this.debug) {
             console.log("Round 4", {
                 type: type,
-                calls: this.encodeNextRound(Round.four, type, typeInfo),
+                calls: nextCalls,
                 typeInfo,
             });
         }
         return {
             type: type,
-            calls: whitelistedLiquidityCalls
-                .concat(blacklistedLiquidityCalls)
-                .concat(this.encodeNextRound(Round.four, type, typeInfo)),
+            calls: whitelistedLiquidityCalls.concat(blacklistedLiquidityCalls).concat(nextCalls),
             typeInfo: {
                 ...typeInfo,
             },
@@ -133,6 +167,9 @@ export class GenericProcessor {
         typeInfo.blacklistedSupply = this.decodeListedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
         index = index + campaign.campaignParameters.blacklist.length;
         this.decodePreviousRound(Round.four, calls, typeInfo, type, index);
+        if (typeInfo.isStaking === "true") {
+            this.decodePreviousStakingRound(Round.four, calls, typeInfo, type, index + this.rounds.round4.length);
+        }
         const outputInfo = (await this.processingRound5(index, type, typeInfo, calls, campaign, pricer));
         if (this.debug) {
             console.log("Round 5", {
@@ -216,6 +253,20 @@ export class GenericProcessor {
             this.decodeRound(this.rounds.round4, index, calls, type, data);
         }
     }
+    decodePreviousStakingRound(round, calls, data, type, index) {
+        if (round === Round.one) {
+            this.decodeRound(this.stakingRounds.round1, index, calls, type, data);
+        }
+        if (round === Round.two) {
+            this.decodeRound(this.stakingRounds.round2, index, calls, type, data);
+        }
+        if (round === Round.three) {
+            this.decodeRound(this.stakingRounds.round3, index, calls, type, data);
+        }
+        if (round === Round.four) {
+            this.decodeRound(this.stakingRounds.round4, index, calls, type, data);
+        }
+    }
     encodeRound(round, callInfo, type) {
         return round
             .map(({ call, target, metaData, optional }) => {
@@ -252,4 +303,27 @@ export class GenericProcessor {
         }
         return calls;
     }
+    encodeStakingNextRound(round, type, data) {
+        const keys = Object.keys(data);
+        const callInfo = keys.reduce((acc, key) => {
+            if (data[key]) {
+                acc[key] = data[key];
+            }
+            return acc;
+        }, {});
+        let calls = [];
+        if (round === Round.one) {
+            calls = this.encodeRound(this.stakingRounds.round1, callInfo, type);
+        }
+        if (round === Round.two) {
+            calls = this.encodeRound(this.stakingRounds.round2, callInfo, type);
+        }
+        if (round === Round.three) {
+            calls = this.encodeRound(this.stakingRounds.round3, callInfo, type);
+        }
+        if (round === Round.four) {
+            calls = this.encodeRound(this.stakingRounds.round4, callInfo, type);
+        }
+        return calls;
+    }
 }

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

@@ -2,6 +2,7 @@ import { tokenType } from "./tokenType";
 const ownerAddresses = {
     "0xbF7E49483881C76487b0989CD7d9A8239B20CA41": tokenType.curve_2,
     "0x42a856dbEBB97AbC1269EAB32f3bb40C15102819": tokenType.satlayer,
+    "0x4C911bf7A008C497719CBEb1a376f1cEc9e2c1d6": tokenType.hanji_liquidity_vault_token,
 };
 export function getTypeFromOwnerAddress(address) {
     if (ownerAddresses[address]) {

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

@@ -61,7 +61,6 @@ export declare enum tokenType {
     pancakeswap = "pancakeswap",
     tempestStaking = "tempestStaking",
     holdstation = "holdstation",
-    staking = "staking",
     noLinkVault = "noLinkVault",
     cpmmGamma = "cpmmGamma",
     crosscurve = "crosscurve",
@@ -89,7 +88,8 @@ export declare enum tokenType {
     spectra_yt = "spectra_yt",
     hourglass = "hourglass",
     katana = "katana",
-    balancerV3 = "balancerV3"
+    balancerV3 = "balancerV3",
+    hanji_liquidity_vault_token = "hanji_liquidity_vault_token"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

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

@@ -62,7 +62,6 @@ export var tokenType;
     tokenType["pancakeswap"] = "pancakeswap";
     tokenType["tempestStaking"] = "tempestStaking";
     tokenType["holdstation"] = "holdstation";
-    tokenType["staking"] = "staking";
     tokenType["noLinkVault"] = "noLinkVault";
     tokenType["cpmmGamma"] = "cpmmGamma";
     tokenType["crosscurve"] = "crosscurve";
@@ -91,6 +90,7 @@ export var tokenType;
     tokenType["hourglass"] = "hourglass";
     tokenType["katana"] = "katana";
     tokenType["balancerV3"] = "balancerV3";
+    tokenType["hanji_liquidity_vault_token"] = "hanji_liquidity_vault_token";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave", action: OpportunityAction.BORROW },
@@ -154,12 +154,11 @@ export const tokenTypeToProtocol = {
     [tokenType.pancakeswap]: { protocol: "PancakeSwap V2", action: OpportunityAction.POOL },
     [tokenType.tempestStaking]: { protocol: "Tempest", action: OpportunityAction.HOLD },
     [tokenType.holdstation]: { protocol: "HoldStation", action: OpportunityAction.HOLD },
-    [tokenType.staking]: { protocol: "Staking", action: OpportunityAction.HOLD },
     [tokenType.noLinkVault]: { protocol: "NoLinkVault", action: OpportunityAction.HOLD },
     [tokenType.cpmmGamma]: { protocol: "GammaSwap", action: OpportunityAction.POOL },
     [tokenType.crosscurve]: { protocol: "CrossCurve", action: OpportunityAction.POOL },
     [tokenType.curveNPool]: { protocol: "Curve", action: OpportunityAction.POOL },
-    [tokenType.vicuna]: { protocol: "Vicuna", action: OpportunityAction.HOLD },
+    [tokenType.vicuna]: { protocol: "Vicuna", action: OpportunityAction.POOL },
     [tokenType.traderJoe]: { protocol: "Trader Joe", action: OpportunityAction.HOLD },
     [tokenType.avalon_lending]: { protocol: "Avalon", action: OpportunityAction.HOLD },
     [tokenType.avalon_borrowing]: { protocol: "Avalon", action: OpportunityAction.HOLD },
@@ -182,4 +181,5 @@ export const tokenTypeToProtocol = {
     [tokenType.hourglass]: { protocol: "Hourglass", action: OpportunityAction.HOLD },
     [tokenType.katana]: { protocol: "Katana", action: OpportunityAction.POOL },
     [tokenType.balancerV3]: { protocol: "Balancer", action: OpportunityAction.POOL },
+    [tokenType.hanji_liquidity_vault_token]: { protocol: "Hanji", action: OpportunityAction.POOL },
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/implementations/HanjiVaultProcessor.d.ts

@@ -0,0 +1,43 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawHanjiN;
+    call: string;
+    target: keyof callKeysHanjiN;
+    metaData?: keyof callKeysHanjiN | string;
+    optional?: boolean;
+};
+type callKeysHanjiN = mandatoryCallKeys & {
+    owner: string;
+    [key: `token${number}`]: string;
+    [key: `symbolToken${number}`]: string;
+    [key: `decimalsToken${number}`]: string;
+    [key: `balanceToken${number}`]: string;
+    [key: `${number}`]: string;
+    name: string;
+    helper: string;
+    tvl: string;
+};
+type dataRawHanjiN = callKeysHanjiN & {
+    numberTokens: number;
+};
+type dataTypeHanjiN = dataType & {
+    numberTokens: number;
+    tvl: number;
+};
+export declare class HanjiVaultProcessor extends GenericProcessor<callKeysHanjiN, dataRawHanjiN, dataTypeHanjiN> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawHanjiN): void;
+    processingRound3(typeInfo: dataRawHanjiN): void;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawHanjiN, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawHanjiN, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawHanjiN, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeHanjiN>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/implementations/HanjiVaultProcessor.js

@@ -0,0 +1,58 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class HanjiVaultProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "numberTokens", call: "getTokensCount", target: "owner" }],
+        round2: [],
+        round3: [],
+        round4: [
+            { key: "tvl", call: "getTotalValue", target: "helper", metaData: "owner" },
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+        ],
+    };
+    // override computeRound1(): void {}
+    processingRound2(typeInfo) {
+        typeInfo.helper = "0x6b285F02DE1a48B3D58Ab65759494f8ab83cF64d";
+        typeInfo.numberTokens = Number(typeInfo.numberTokens);
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            typeInfo[`${i}`] = i.toString();
+            this.rounds.round2 = this.rounds.round2.concat([
+                { key: `token${i}`, call: "tokens", target: "owner", metaData: i.toString() },
+            ]);
+        }
+    }
+    processingRound3(typeInfo) {
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            this.rounds.round3 = this.rounds.round3.concat([{ key: `symbolToken${i}`, call: "symbol", target: `token${i}` }]);
+        }
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            this.rounds.round2 = this.rounds.round2.concat([
+                { key: `token${i}`, call: "tokens", target: "tokenAddress", metaData: i.toString() },
+            ]);
+        }
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            this.rounds.round3 = this.rounds.round3.concat([{ key: `symbolToken${i}`, call: "symbol", target: `token${i}` }]);
+        }
+        return super.computeRound4(index, type, typeInfo, calls, campaign);
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const tvl = BN2Number(typeInfo.tvl, 18);
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/implementations/curveNPoolProcessor.js

@@ -62,7 +62,6 @@ export class CurveNPoolProcessor extends GenericProcessor {
             hardcodedSymbol = "USDC";
         for (let i = 0; i < typeInfo.numberTokens; i++) {
             const symbol = typeInfo[`symbolToken${i}`];
-            const parsedSymbol = symbol.split("_")[0].slice(1);
             let price = (await pricer.get({ symbol: symbol })) ?? 0;
             if (price === 0) {
                 // For cross curve

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

@@ -18,6 +18,7 @@ import { FluidProcessor } from "./FluidProcessor";
 import { FraxProcessor } from "./FraxProcessor";
 import { GammaProcessor } from "./GammaProcessor";
 import { GearboxProcessor } from "./GearboxProcessor";
+import { HanjiVaultProcessor } from "./HanjiVaultProcessor";
 import { HoldStationProcessor } from "./HoldStationProcessor";
 import { HourglassProcessor } from "./HourglassProcessor";
 import { MaverickBPProcessor } from "./MaverickBPProcessor";
@@ -31,7 +32,6 @@ import { SatlayerProcessor } from "./Satlayer";
 import { SpectraProcessor } from "./SpectraProcessor";
 import { SpectraYTProcessor } from "./SpectraYTProcessor";
 import { SpliceProcessor } from "./SpliceProcessor";
-import { StakingProcessor } from "./StakingProcessor";
 import { SturdySiloProcessor } from "./SturdySiloProcessor";
 import { TempestVaultProcessor } from "./TempestVaultProcessor";
 import { TorosProcessor } from "./TorosProcessor";
@@ -102,7 +102,6 @@ export const processorMapping = {
     [tokenType.pancakeswap]: UniswapProcessor,
     [tokenType.tempestStaking]: TempestVaultProcessor,
     [tokenType.holdstation]: HoldStationProcessor,
-    [tokenType.staking]: StakingProcessor,
     [tokenType.noLinkVault]: NoLinkVaultProcessor,
     [tokenType.cpmmGamma]: GammaProcessor,
     [tokenType.venus]: AssetProcessor,
@@ -132,4 +131,5 @@ export const processorMapping = {
     [tokenType.hourglass]: HourglassProcessor,
     [tokenType.katana]: UniswapProcessor,
     [tokenType.balancerV3]: BalancerV3PoolProcessor,
+    [tokenType.hanji_liquidity_vault_token]: HanjiVaultProcessor,
 };

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

@@ -1,3 +1,3 @@
-import { type Campaign, type CampaignParameters, type ResultDto } from "@sdk";
+import type { Campaign, CampaignParameters, ResultDto } from "@sdk";
 import { type tokenTypeStruct } from "./helpers/tokenType";
 export declare function getTokenTypeRound1(calls: ResultDto[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1.js

@@ -1,5 +1,4 @@
 import { decodeCall, decodeReturnValue } from "../../../../utils/decodeCalls";
-import { ChainId } from "@sdk";
 import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
 import { getTypeFromAddressChain } from "./helpers/hardcoded";
 import { getTypeFromOwnerAddress } from "./helpers/ownerFinder";
@@ -154,12 +153,14 @@ function satisfiesNameConditions(name, type) {
             return false;
     }
 }
-function generateResult(type, name, targetToken, typeInfo) {
+function generateResult(type, name, targetToken, typeInfo, campaign) {
     const ProcessorClass = processorMapping[type];
     if (!ProcessorClass) {
         throw new Error(`Processor not found for key: ${type}`);
     }
     const processorObject = new ProcessorClass();
+    if (campaign)
+        typeInfo = { ...typeInfo, ...parseForStaking(campaign) };
     typeInfo = {
         ...typeInfo,
         name: name,
@@ -169,25 +170,25 @@ function generateResult(type, name, targetToken, typeInfo) {
     };
     return processorObject.computeRound1(type, typeInfo);
 }
-function processNamingConditions(type, name, targetToken) {
+function processNamingConditions(type, name, targetToken, campaign) {
     if (satisfiesNameConditions(name, type)) {
-        return generateResult(type, name, targetToken, {});
+        return generateResult(type, name, targetToken, {}, campaign);
     }
 }
-function processNamingConditionsInOrder(types, name, targetToken) {
+function processNamingConditionsInOrder(types, name, targetToken, campaign) {
     for (const type of types) {
-        const result = processNamingConditions(type, name, targetToken);
+        const result = processNamingConditions(type, name, targetToken, campaign);
         if (result)
             return result;
     }
 }
-function parseForFactory(calls, targetToken) {
+function parseForFactory(calls, targetToken, campaign) {
     try {
         const factory = decodeReturnValue(calls.factory, "factory");
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromFactoryAddress(factory);
         if (type !== tokenType.unknown)
-            return generateResult(type, name, targetToken, { factory });
+            return generateResult(type, name, targetToken, { factory }, campaign);
     }
     catch (e) {
         // No factory on this token
@@ -266,15 +267,14 @@ function checkAgainstHardcoded(calls, chainId, targetToken) {
         // Not a hardcoded address
     }
 }
-function parseForStaking(campaign, calls, targetToken) {
+function parseForStaking(campaign) {
     try {
         const whitelist = campaign.campaignParameters.whitelist;
-        if (whitelist.length === 1 && campaign.chainId !== ChainId.ARBITRUM) {
+        if (whitelist.length === 1) {
             const forwarders = campaign.campaignParameters.forwarders;
             if (forwarders.length === 1) {
                 if (forwarders[0].sender === whitelist[0]) {
-                    const name = decodeReturnValue(calls.name, "name");
-                    return generateResult(tokenType.staking, name, targetToken, { stakingContract: whitelist[0] });
+                    return { isStaking: "true", stakingContract: whitelist[0] };
                 }
             }
         }
@@ -283,6 +283,7 @@ function parseForStaking(campaign, calls, targetToken) {
         // No factory on this token
         // console.log(e);
     }
+    return { isStaking: "false" };
 }
 export function getTokenTypeRound1(calls, targetToken, index, campaign) {
     const returnValueOfCalls = calls.map(call => call.returnData);
@@ -295,7 +296,7 @@ export function getTokenTypeRound1(calls, targetToken, index, campaign) {
         owner: returnValueOfCalls[index + 5],
         vault: returnValueOfCalls[index + 6],
     };
-    let result = parseForFactory(returnValue, targetToken);
+    let result = parseForFactory(returnValue, targetToken, campaign);
     if (result)
         return result;
     result = parseForOwner(returnValue, targetToken);
@@ -308,9 +309,6 @@ export function getTokenTypeRound1(calls, targetToken, index, campaign) {
     if (result)
         return result;
     result = parseForMetamorpho(returnValue, targetToken);
-    if (result)
-        return result;
-    result = parseForStaking(campaign, returnValue, targetToken);
     if (result)
         return result;
     let name;
@@ -318,15 +316,15 @@ export function getTokenTypeRound1(calls, targetToken, index, campaign) {
         name = decodeCall(returnValueOfCalls, index + 2, "name");
     }
     catch {
-        return generateResult(tokenType.unknown, "Unknown", targetToken, {});
+        return generateResult(tokenType.unknown, "Unknown", targetToken, {}, campaign);
     }
     result = parseForBalancer(returnValue, targetToken, name);
     if (result)
         return result;
     // Order matters
     const ordered_token_Type = Object.values(tokenType).filter(value => typeof value === "string");
-    result = processNamingConditionsInOrder(ordered_token_Type, name, targetToken);
+    result = processNamingConditionsInOrder(ordered_token_Type, name, targetToken, campaign);
     if (result)
         return result;
-    return generateResult(tokenType.unknown, name, targetToken, {});
+    return generateResult(tokenType.unknown, name, targetToken, {}, campaign);
 }

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

@@ -77,25 +77,6 @@ export declare const BoostController: Elysia<"/boosts", false, {
             };
         };
     };
-} & {
-    boosts: {
-        openblock: {
-            zksync: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: {
-                            address: string;
-                            boost: string;
-                        }[];
-                    };
-                };
-            };
-        };
-    };
 }, {
     derive: {};
     resolve: {};

package/dist/src/modules/v4/boost/boost.controller.js

@@ -12,5 +12,4 @@ export const BoostController = new Elysia({ prefix: "/boosts", detail: { tags: [
     query: getZksyncBoost,
     body: getEulerBoostBody,
     detail: { hide: true },
-})
-    .get("/openblock/zksync", async () => BoostService.getOpenBlockBoostDefault());
+});

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

@@ -8,8 +8,4 @@ export declare class BoostService {
         address: string;
         boost: string;
     }[]>;
-    static getOpenBlockBoostDefault(): Promise<{
-        address: string;
-        boost: string;
-    }[]>;
 }

package/dist/src/modules/v4/boost/boost.service.js

@@ -17,27 +17,4 @@ export class BoostService {
         }
         return response.data.map(({ address, boost }) => ({ address, boost: boost.toString() }));
     }
-    static async getOpenBlockBoostDefault() {
-        return [
-            { address: "0x684566c9ffcac7f6a04c3a9997000d2d58c00824", boost: "0" },
-            { address: "0x29dfdd80d6acc0f9028d8a6fa7d7d448342e25c1", boost: "0" },
-            { address: "0x5b9effdcbd65946f2b143725dc244563248aa4ee", boost: "0" },
-            { address: "0xd2262a05e225ce0c61fb699fdcf14068132dd362", boost: "0" },
-            { address: "0x7da8481e24303d55f29f0c06174f18b30b81c9ac", boost: "0" },
-            { address: "0x1d098a8d7fa63a39e0884b720f86f9ba8cbbeef1", boost: "0" },
-            { address: "0x7f3e3d663a5f29274d0809020c675f5cc3d1429a", boost: "0" },
-            { address: "0x7f04f7fdad3272b806e3d57bec445e0ece82f2ad", boost: "0" },
-            { address: "0xfe769b6f39a000ff508b5baf8fbe3a1f516f258c", boost: "0" },
-            { address: "0xd635736f8ac2241cdfcc3ee02d3f3bac1f78431f", boost: "0" },
-            { address: "0xb38c7e2b4ba3cdc4eaea863cbb01470353c5ea16", boost: "0" },
-            { address: "0xe37885b5e1187f7f618407fb0c14a3383998348e", boost: "0" },
-            { address: "0xe01f660b304be815627628c38c2dcdf37f68245e", boost: "0" },
-            { address: "0xe746db07d2b4babf5f2051d40987b7278414192f", boost: "0" },
-            { address: "0xa0265ed27561b25c0e7ad3ed1fed74c2ee5f8cdf", boost: "0" },
-            { address: "0xdf5ad5a87fceaacb1ecef40e8e61c42c92339a10", boost: "0" },
-            { address: "0xc91fc9dd7f1bb6ec429eddb577b9ace6236b2147", boost: "0" },
-            { address: "0x8b81420441ac3933c58d1190c8499c2f89eb1263", boost: "0" },
-            { address: "0x0000000000000000000000000000000000000000", boost: "1" },
-        ];
-    }
 }

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

@@ -185,6 +185,70 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 };
             };
         };
+    } & {
+        ":id": {
+            get: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        params: any;
+                        chain: {
+                            name: string;
+                            id: number;
+                            icon: string;
+                        };
+                        rewardToken: {
+                            symbol: string;
+                            name: string | null;
+                            id: string;
+                            icon: string;
+                            chainId: number;
+                            address: string;
+                            decimals: number;
+                            verified: boolean;
+                            isTest: boolean;
+                        } & {
+                            price?: number | null | undefined;
+                        };
+                        distributionChain: {
+                            name: string;
+                            id: number;
+                            icon: string;
+                        } | undefined;
+                        campaignStatus: {
+                            error: string;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                        };
+                        creatorAddress: string;
+                        Creator: {
+                            tags: string[];
+                            address: string;
+                            creatorId: string | null;
+                        };
+                        type: string;
+                        id: string;
+                        subType: number | null;
+                        startTimestamp: bigint;
+                        endTimestamp: bigint;
+                        computeChainId: number;
+                        distributionChainId: number;
+                        campaignId: string;
+                        rewardTokenId: string;
+                        amount: string;
+                        opportunityId: string;
+                    };
+                };
+            };
+        };
     } & {
         count: {
             get: {