@merkl/api 0.20.65 → 0.20.67

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound1.js

@@ -1,9 +1,9 @@
 import { decodeCall, decodeReturnValue } from "@/utils/decodeCalls";
-import { tokenType } from "./constants";
-import { erc20ProcessorFactory } from "./factory";
 import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
 import { getTypeFromAddressChain } from "./helpers/hardcoded";
 import { getTypeFromOwnerAddress } from "./helpers/ownerFinder";
+import { tokenType } from "./helpers/tokenType";
+import { processorMapping } from "./implementations/processorMapping";
 function satisfiesNameConditions(name, type) {
     const lowerCaseName = name.toLowerCase();
     switch (type) {
@@ -165,168 +165,178 @@ function satisfiesNameConditions(name, type) {
             return false;
     }
 }
-function generateResult(type, name, campaign, data) {
-    const 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,
-        tokenAddress: campaign.campaignParameters.targetToken,
+        tokenAddress: targetToken,
         totalSupply: 0,
         blacklistedSupply: 0,
-        whitelistedSupply: 0,
-        ...parseForStaking(campaign),
-        ...(data ?? {}),
     };
-    return erc20ProcessorFactory(type, campaign).computeRound1(typeInfo); // TODO Fix
+    return processorObject.computeRound1(type, typeInfo);
 }
-function processNamingConditions(type, name, campaign) {
+function processNamingConditions(type, name, targetToken, campaign) {
     if (satisfiesNameConditions(name, type)) {
-        return generateResult(type, name, campaign);
+        return generateResult(type, name, targetToken, {}, campaign);
     }
 }
-function processNamingConditionsInOrder(types, name, campaign) {
+function processNamingConditionsInOrder(types, name, targetToken, campaign) {
     for (const type of types) {
-        const result = processNamingConditions(type, name, campaign);
+        const result = processNamingConditions(type, name, targetToken, campaign);
         if (result)
             return result;
     }
 }
-function parseForFactory(calls, campaign) {
+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, campaign, { factory });
+            return generateResult(type, name, targetToken, { factory }, campaign);
     }
     catch (e) {
         // No factory on this token
         // console.log(e);
     }
 }
-function parseForOwner(calls, campaign) {
+function parseForOwner(calls, targetToken) {
     try {
         const owner = decodeReturnValue(calls.owner, "owner");
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromOwnerAddress(owner);
         if (type !== tokenType.unknown)
-            return generateResult(type, name, campaign, { owner });
+            return generateResult(type, name, targetToken, { owner: owner });
     }
     catch (e) {
         // No factory on this token
         // console.log(e);
     }
 }
-function parseForEnzyme(calls, campaign) {
+function parseForEnzyme(calls, targetToken) {
     // Enzyme check
     try {
         const dispatcher = decodeReturnValue(calls.creator, "getCreator");
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromFactoryAddress(dispatcher);
         const fundValueCalculator = enzymeFundValueCalculatorRouterMapping[dispatcher];
+        const typeInfo = {
+            fundValueCalculator,
+            dispatcher,
+        };
         if (type === tokenType.enzyme) {
-            return generateResult(type, name, campaign, {
-                fundValueCalculator,
-                dispatcher,
-            });
+            return generateResult(type, name, targetToken, typeInfo);
         }
     }
     catch (e) {
         // No factory on this token
     }
 }
-function parseForMetamorpho(calls, campaign) {
+function parseForMetamorpho(calls, targetToken) {
     // MetaMorpho check
     try {
         decodeReturnValue(calls.metamorpho, "MORPHO");
         const name = decodeReturnValue(calls.name, "name");
-        return generateResult(tokenType.metamorpho, name, campaign);
+        return generateResult(tokenType.metamorpho, name, targetToken, {});
     }
     catch (e) {
         // Not a metamorpho token
     }
 }
-function parseForBalancer(calls, name, campaign) {
+function parseForBalancer(calls, targetToken, name) {
     // Check for balancer pools
     try {
         decodeReturnValue(calls.poolId, "getPoolId");
-        return generateResult(tokenType.balancerPool, name, campaign);
+        return generateResult(tokenType.balancerPool, name, targetToken, {});
     }
     catch (e) {
         // Not a balancer pool
     }
     try {
         decodeReturnValue(calls.vault, "getVault");
-        return generateResult(tokenType.balancerV3, name, campaign);
+        return generateResult(tokenType.balancerV3, name, targetToken, {});
     }
     catch (e) {
         // Not a balancer v3 pool
     }
 }
-function checkAgainstHardcoded(calls, campaign) {
+function checkAgainstHardcoded(calls, chainId, targetToken) {
     // Check for balancer pools
     try {
         const name = decodeReturnValue(calls.name, "name");
-        const type = getTypeFromAddressChain(campaign.computeChainId, campaign.campaignParameters.targetToken);
+        const type = getTypeFromAddressChain(chainId, targetToken);
         if (type !== tokenType.unknown)
-            return generateResult(type, name, campaign);
+            return generateResult(type, name, targetToken, {});
     }
     catch (e) {
         // Not a hardcoded address
     }
 }
-export function parseForStaking(campaign) {
+function parseForStaking(campaign) {
     try {
         const whitelist = campaign.campaignParameters.whitelist;
         if (whitelist.length === 1) {
             const forwarders = campaign.campaignParameters.forwarders;
             if (forwarders.length === 1) {
                 if (forwarders[0].sender === whitelist[0]) {
-                    return { isStaking: true, stakingContract: whitelist[0] };
+                    return { isStaking: "true", stakingContract: whitelist[0] };
                 }
             }
         }
     }
-    catch { }
-    return { isStaking: false };
+    catch (e) {
+        // No factory on this token
+        // console.log(e);
+    }
+    return { isStaking: "false" };
 }
-export function getTokenTypeRound1(callResults, index, campaign) {
+export function getTokenTypeRound1(calls, targetToken, index, campaign) {
+    const returnValueOfCalls = calls.map(call => call.returnData);
     const returnValue = {
-        factory: callResults[index],
-        metamorpho: callResults[index + 1],
-        name: callResults[index + 2],
-        poolId: callResults[index + 3],
-        creator: callResults[index + 4],
-        owner: callResults[index + 5],
-        vault: callResults[index + 6],
+        factory: returnValueOfCalls[index],
+        metamorpho: returnValueOfCalls[index + 1],
+        name: returnValueOfCalls[index + 2],
+        poolId: returnValueOfCalls[index + 3],
+        creator: returnValueOfCalls[index + 4],
+        owner: returnValueOfCalls[index + 5],
+        vault: returnValueOfCalls[index + 6],
     };
-    let result = parseForFactory(returnValue, campaign);
+    let result = parseForFactory(returnValue, targetToken, campaign);
     if (result)
         return result;
-    result = parseForOwner(returnValue, campaign);
+    result = parseForOwner(returnValue, targetToken);
     if (result)
         return result;
-    result = checkAgainstHardcoded(returnValue, campaign);
+    result = checkAgainstHardcoded(returnValue, campaign.computeChainId, targetToken);
     if (result)
         return result;
-    result = parseForEnzyme(returnValue, campaign);
+    result = parseForEnzyme(returnValue, targetToken);
     if (result)
         return result;
-    result = parseForMetamorpho(returnValue, campaign);
+    result = parseForMetamorpho(returnValue, targetToken);
     if (result)
         return result;
     let name;
     try {
-        name = decodeCall(callResults, index + 2, "name");
+        name = decodeCall(returnValueOfCalls, index + 2, "name");
     }
     catch {
-        return generateResult(tokenType.unknown, "Unknown", campaign);
+        return generateResult(tokenType.unknown, "Unknown", targetToken, {}, campaign);
     }
-    result = parseForBalancer(returnValue, name, 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, campaign);
+    result = processNamingConditionsInOrder(ordered_token_Type, name, targetToken, campaign);
     if (result)
         return result;
-    return generateResult(tokenType.unknown, name, campaign);
+    return generateResult(tokenType.unknown, name, targetToken, {}, campaign);
 }

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound2.d.ts

@@ -0,0 +1,4 @@
+import type { CampaignParameters, ResultDto } from "@sdk";
+import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: ResultDto[], campaign?: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound2.js

@@ -0,0 +1,22 @@
+import { processorMapping } from "./implementations/processorMapping";
+export function getTokenTypeRound2(index, type, typeInfo, calls, campaign) {
+    try {
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        const ProcessorClass = processorMapping[type];
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound2(index, type, typeInfo, returnValueOfCalls, campaign);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound3.d.ts

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

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound3.js

@@ -0,0 +1,22 @@
+import { processorMapping } from "./implementations/processorMapping";
+export function getTokenTypeRound3(index, type, typeInfo, calls) {
+    try {
+        const ProcessorClass = processorMapping[type];
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound3(index, type, typeInfo, returnValueOfCalls);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound4.d.ts

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

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound4.js

@@ -0,0 +1,22 @@
+import { processorMapping } from "./implementations/processorMapping";
+export function getTokenTypeRound4(index, type, typeInfo, calls, campaign) {
+    try {
+        const ProcessorClass = processorMapping[type];
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound4(index, type, typeInfo, returnValueOfCalls, campaign);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/factory.js

@@ -61,5 +61,7 @@ const map = {
     [Campaign.ERC6909FIXAPR]: new DefaultMetadata(), // TODO
     [Campaign.ERC1155]: new DefaultMetadata(), // TODO
     [Campaign.ERC1155FIXAPR]: new DefaultMetadata(), // TODO
+    [Campaign.ERC721]: new DefaultMetadata(), // TODO
+    [Campaign.ERC721FIXAPR]: new DefaultMetadata(), // TODO
 };
 export const metadataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/opportunityMetadata/implementations/CompoundV3.js

@@ -11,7 +11,10 @@ export class CompoundV3Metadata {
                     : `Borrow ${symbolUnderlyingToken} on`,
                 "Compound V3",
             ].join(" "),
-            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            tokens: [
+                { chainId: computeChainId, address: params.underlyingToken },
+                { chainId: computeChainId, address: params.targetToken },
+            ],
             mainProtocol: "compound",
             depositUrl: undefined, // TODO, shall depend on compFork
         };

package/dist/src/engine/opportunityMetadata/implementations/JsonAirdrop.js

@@ -19,7 +19,7 @@ export class JsonAirdropMetadata {
                 tokens: [
                     {
                         chainId: computeChainId,
-                        address: tokenAddress,
+                        address: tokenAddress, // TODO: Make sure targetToken is set
                     },
                 ],
                 mainProtocol: aavePrefix || aciPrefix ? "aave" : undefined,

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

@@ -1,3 +1,3 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/constants";
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
 export declare function decodeCall(calls: string[], index: number, key: string, type?: tokenType): any;
 export declare function decodeReturnValue(returnData: string, key: string, type?: tokenType): any;

package/dist/src/utils/decodeCalls.js

@@ -1,4 +1,4 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/constants";
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
 import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerV3StablePoolInterface, BalancerVaultInterface, BeefyInterface, BunniV2HubInterface, BunniV2TokenInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveLPTokenInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, ERC4626Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, HourglassERC20TBTInterface, HourglassVedaLockDepositorV2Interface, IonicInterface, LPManagerHelperInterface, LPManagerInterface, LayerBankERC20Interface, LayerBankInterface, LendleInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxInterface, RswEthStrategyInterface, SpectraYTInterface, SturdyInterface, SymetricAmbientStrategyInterface, SyncSwapClassicPoolInterface, TorosInterface, UniswapV2PoolInterface, UniswapV3PoolInterface, VePufferInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
 import { BigNumber } from "ethers";
 export function decodeCall(calls, index, key, type) {

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

@@ -1,3 +1,3 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/constants";
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
 import { type CallDto } from "@sdk";
-export declare function createCall(target: string, key: string, type?: tokenType, callArgs?: any): CallDto;
+export declare function createCall(target: string, key: string, type?: tokenType, metaData?: any): CallDto;

package/dist/src/utils/encodeCalls.js

@@ -1,17 +1,17 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/constants";
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
 import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerV3StablePoolInterface, BalancerVaultInterface, BeefyInterface, BunniV2HubInterface, BunniV2TokenInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveLPTokenInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, ERC4626Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, HourglassERC20TBTInterface, HourglassVedaLockDepositorV2Interface, IonicInterface, LPManagerHelperInterface, LPManagerInterface, LayerBankInterface, LendleInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxDatastoreInterface, RswEthStrategyInterface, SpectraYTInterface, SturdyInterface, SymetricAmbientStrategyInterface, SyncSwapClassicPoolInterface, TorosInterface, UniswapV2PoolInterface, UniswapV3PoolInterface, VePufferInterface, ZFStableLPINterface, } from "@sdk";
-export function createCall(target, key, type, callArgs) {
+export function createCall(target, key, type, metaData) {
     switch (key) {
         case "sqrtPriceX96":
             return { allowFailure: true, callData: UniswapV3PoolInterface.encodeFunctionData("slot0"), target };
         case "tokens":
-            return { allowFailure: true, callData: LPManagerInterface.encodeFunctionData("tokens", [callArgs]), target };
+            return { allowFailure: true, callData: LPManagerInterface.encodeFunctionData("tokens", [metaData]), target };
         case "getTokensCount":
             return { allowFailure: true, callData: LPManagerInterface.encodeFunctionData("getTokensCount"), target };
         case "getTotalValue":
             return {
                 allowFailure: true,
-                callData: LPManagerHelperInterface.encodeFunctionData("getTotalValue", [callArgs]),
+                callData: LPManagerHelperInterface.encodeFunctionData("getTotalValue", [metaData]),
                 target,
             };
         case "SY":
@@ -38,13 +38,13 @@ export function createCall(target, key, type, callArgs) {
         case "coin2":
             return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [2]), target };
         case "coins":
-            return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [callArgs]), target };
+            return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [metaData]), target };
         case "N_COINS":
             return { allowFailure: true, callData: CurveStableSwapNGInterface.encodeFunctionData("N_COINS"), target };
         case "balances":
             return {
                 allowFailure: true,
-                callData: CurveStableSwapNGInterface.encodeFunctionData("balances", [callArgs]),
+                callData: CurveStableSwapNGInterface.encodeFunctionData("balances", [metaData]),
                 target,
             };
         case "operator":
@@ -81,14 +81,14 @@ export function createCall(target, key, type, callArgs) {
         case "shortToken": {
             return {
                 allowFailure: true,
-                callData: RfxDatastoreInterface.encodeFunctionData("getAddress", [callArgs]),
+                callData: RfxDatastoreInterface.encodeFunctionData("getAddress", [metaData]),
                 target,
             };
         }
         case "longToken": {
             return {
                 allowFailure: true,
-                callData: RfxDatastoreInterface.encodeFunctionData("getAddress", [callArgs]),
+                callData: RfxDatastoreInterface.encodeFunctionData("getAddress", [metaData]),
                 target,
             };
         }
@@ -183,7 +183,7 @@ export function createCall(target, key, type, callArgs) {
         case "calcNetShareValue":
             return {
                 allowFailure: true,
-                callData: EnzymeInterface.encodeFunctionData("calcNetShareValue", [callArgs]),
+                callData: EnzymeInterface.encodeFunctionData("calcNetShareValue", [metaData]),
                 target,
             };
         case "getPricePerFullShare":
@@ -237,7 +237,7 @@ export function createCall(target, key, type, callArgs) {
         case "balanceOf":
             return {
                 allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("balanceOf", [callArgs]),
+                callData: ERC20Interface.encodeFunctionData("balanceOf", [metaData]),
                 target,
             };
         case "getPoolId":
@@ -255,7 +255,7 @@ export function createCall(target, key, type, callArgs) {
         case "poolInfo":
             return {
                 allowFailure: true,
-                callData: AuraOperatorInterface.encodeFunctionData("poolInfo", [callArgs]),
+                callData: AuraOperatorInterface.encodeFunctionData("poolInfo", [metaData]),
                 target,
             };
         case "staker":
@@ -263,13 +263,13 @@ export function createCall(target, key, type, callArgs) {
         case "getPoolTokens":
             return {
                 allowFailure: true,
-                callData: BalancerVaultInterface.encodeFunctionData("getPoolTokens", [callArgs]),
+                callData: BalancerVaultInterface.encodeFunctionData("getPoolTokens", [metaData]),
                 target,
             };
         case "convertToAssets":
             return {
                 allowFailure: true,
-                callData: FluidInterface.encodeFunctionData("convertToAssets", [callArgs]),
+                callData: FluidInterface.encodeFunctionData("convertToAssets", [metaData]),
                 target,
             };
         case "tokenPrice":
@@ -339,7 +339,7 @@ export function createCall(target, key, type, callArgs) {
         case "boostedPositionInformation":
             return {
                 allowFailure: true,
-                callData: MaverickBPLensInterface.encodeFunctionData("boostedPositionInformation", [callArgs]),
+                callData: MaverickBPLensInterface.encodeFunctionData("boostedPositionInformation", [metaData]),
                 target: target,
             };
         case "minter":
@@ -488,7 +488,7 @@ export function createCall(target, key, type, callArgs) {
         case "poolState":
             return {
                 allowFailure: true,
-                callData: BunniV2HubInterface.encodeFunctionData("poolState", [callArgs]),
+                callData: BunniV2HubInterface.encodeFunctionData("poolState", [metaData]),
                 target: target,
             };
         default:

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

@@ -1,7 +1,6 @@
-import type { ERC20SupportedCampaignType } from "@/engine/dynamicData/implementations/Erc20";
-import { tokenType } from "@/engine/erc20SubTypeProcessors/constants";
-import type { CampaignParameters } from "@sdk";
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import type { Campaign, CampaignParameters } from "@sdk";
 export declare const stakingContractToStakingSymbol: {
     [key: string]: string;
 };
-export declare function generateCardName(type: tokenType, isStaking: boolean, typeInfo: any, campaign: CampaignParameters<ERC20SupportedCampaignType>, symbols?: string[], displayName?: string): string;
+export declare function generateCardName(type: tokenType, typeInfo: any, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, symbols?: string[], displayName?: string): string;

package/dist/src/utils/generateCardName.js

@@ -1,12 +1,12 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/constants";
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
 import { capitalize } from "lodash";
 export const stakingContractToStakingSymbol = {
     "0x18eeD20f71BEf84B605253C89A7576E3634134C0": "CyberStaking",
     "0x68754d29f2e97B837Cb622ccfF325adAC27E9977": "Karak",
     "0xcd28cF8f7755f03967D27E128B38022B63919836": "Llamalend",
 };
-export function generateCardName(type, isStaking, typeInfo, campaign, symbols = [""], displayName) {
-    if (isStaking) {
+export function generateCardName(type, typeInfo, campaign, symbols = [""], displayName) {
+    if (typeInfo.isStaking === "true") {
         if (typeInfo.stakingName !== undefined) {
             typeInfo.stakingSymbol = typeInfo.stakingName.includes("Deposit")
                 ? typeInfo.stakingName.replace("Deposit", "").trim()

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

@@ -0,0 +1,3 @@
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import type { Campaign, CampaignParameters } from "@sdk";
+export declare function generateIcons(type: tokenType, typeInfo: any, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, symbols?: string[]): string[];

package/dist/src/utils/generateIcons.js

@@ -0,0 +1,65 @@
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { OpportunityAction } from "@db/api";
+export function generateIcons(type, typeInfo, campaign, symbols = [""]) {
+    const action = typeInfo.action ? typeInfo.action : "HOLD";
+    switch (action) {
+        case OpportunityAction.POOL:
+            switch (type) {
+                case tokenType.vicuna: {
+                    const parsedName = typeInfo.name.split(" ").pop();
+                    return parsedName.split("-");
+                }
+                case tokenType.balancerGauge:
+                case tokenType.balancerPool:
+                case tokenType.aura:
+                    return Object.values(typeInfo.poolTokens ?? {})
+                        .map(tkn => tkn?.symbol)
+                        .filter(tkn => tkn && !tkn.includes("/"));
+                case tokenType.curve:
+                case tokenType.curve_2:
+                case tokenType.hanji_liquidity_vault_token:
+                case tokenType.crosscurve: {
+                    const icons = [];
+                    for (let i = 0; i < typeInfo.numberTokens; i++) {
+                        if (typeInfo[`symbolToken${i}`])
+                            icons.push(typeInfo[`symbolToken${i}`]);
+                    }
+                    return icons;
+                }
+                case tokenType.rfx_slv:
+                    return [typeInfo.symbolAsset];
+                case tokenType.rfx:
+                    return [typeInfo.symbolShortToken, typeInfo.symbolLongToken];
+                case tokenType.maverickBoostedPosition:
+                    return [typeInfo.symbolTokenA, typeInfo.symbolTokenB];
+                default:
+                    return [typeInfo.symbolToken0, typeInfo.symbolToken1];
+            }
+        case OpportunityAction.LEND:
+            switch (type) {
+                case tokenType.compound:
+                    return [typeInfo.symbolBaseToken];
+                default:
+                    return [typeInfo.symbolUnderlyingToken];
+            }
+        case OpportunityAction.BORROW:
+            return [typeInfo.symbolUnderlyingToken];
+        case OpportunityAction.HOLD:
+            switch (type) {
+                case tokenType.toros:
+                case tokenType.enzyme:
+                    return [typeInfo.symbolUnderlyingToken];
+                case tokenType.pendleYT: {
+                    let symbol = campaign.campaignParameters.symbolTargetToken;
+                    symbol = symbol.split("-").slice(0, 2).join("-");
+                    return [symbol];
+                }
+                case tokenType.pendle:
+                    return [typeInfo.symbolUnderlyingToken];
+                default:
+                    return [campaign.campaignParameters.symbolTargetToken];
+            }
+        default:
+            return [];
+    }
+}