@merkl/api 0.16.2 → 0.16.4

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

@@ -1,7 +1,7 @@
 import { merklChainDataWithCache } from "../../merklChainData";
 import { TokenRepository } from "../../../modules/v4/token/token.repository";
 import { log } from "../../../utils/logger";
-import { BN2Number, BalancerPoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
+import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
 import { Pricer } from "../../../utils/pricer";
 import { getLastEligibilityRatio } from "../utils/getLastEligibilityRatio";
 import { getTVL } from "./ERC20SubTypes/helpers/getTVL";
@@ -55,6 +55,11 @@ export async function ERC20DynamicData(chainId, campaigns) {
                 callData: LayerBankERC20Interface.encodeFunctionData("owner"),
                 target: targetToken,
             },
+            {
+                allowFailure: true,
+                callData: BalancerV3StablePoolInterface.encodeFunctionData("getVault"),
+                target: targetToken,
+            },
         ];
         callsRounds1.push(...typeStruct.calls);
         tokenTypesByCampaign[campaign.campaignId] = typeStruct;

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

@@ -26,6 +26,7 @@ const factoryAddresses = {
     "0x7Ca46A636b02D4aBC66883D7FF164bDE506DC66a": tokenType.curveNPool, // Curve Corn 3crypto Factory
     "0xbC0797015fcFc47d9C1856639CaE50D0e69FbEE8": tokenType.curveNPool, // Curve Arbitrum 3crypto Factory
     "0xA5961898870943c68037F6848d2D866Ed2016bcB": tokenType.curveNPool, // Curve Base
+    "0xB255D6A720BB7c39fee173cE22113397119cB930": tokenType.katana, // Katana Ronin
 };
 export function getTypeFromFactoryAddress(address) {
     if (factoryAddresses[address]) {

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

@@ -86,7 +86,10 @@ export declare enum tokenType {
     vicuna_lending = "vicuna_lending",
     vicuna_borrowing = "vicuna_borrowing",
     spectra_lpt = "spectra_lpt",
-    spectra_yt = "spectra_yt"
+    spectra_yt = "spectra_yt",
+    hourglass = "hourglass",
+    katana = "katana",
+    balancerV3 = "balancerV3"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

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

@@ -88,6 +88,9 @@ export var tokenType;
     tokenType["vicuna_borrowing"] = "vicuna_borrowing";
     tokenType["spectra_lpt"] = "spectra_lpt";
     tokenType["spectra_yt"] = "spectra_yt";
+    tokenType["hourglass"] = "hourglass";
+    tokenType["katana"] = "katana";
+    tokenType["balancerV3"] = "balancerV3";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave", action: OpportunityAction.BORROW },
@@ -176,4 +179,7 @@ export const tokenTypeToProtocol = {
     [tokenType.spectra_lpt]: { protocol: "Spectra", action: OpportunityAction.POOL },
     [tokenType.spectra_yt]: { protocol: "Spectra", action: OpportunityAction.POOL },
     [tokenType.rfx_slv]: { protocol: "RFX", action: OpportunityAction.POOL },
+    [tokenType.hourglass]: { protocol: "Hourglass", action: OpportunityAction.HOLD },
+    [tokenType.katana]: { protocol: "Katana", action: OpportunityAction.POOL },
+    [tokenType.balancerV3]: { protocol: "Balancer", action: OpportunityAction.POOL },
 };

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

@@ -0,0 +1,44 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { BigNumber } from "ethers";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawBalancerV3;
+    call: string;
+    target: keyof callKeysBalancerV3;
+    metaData?: keyof callKeysBalancerV3 | string;
+    optional?: boolean;
+};
+type callKeysBalancerV3 = mandatoryCallKeys & {
+    [key: `token${number}`]: string;
+    [key: `symbolToken${number}`]: string;
+    [key: `decimalsToken${number}`]: string;
+    [key: `${number}`]: string;
+    name: string;
+};
+type dataRawBalancerV3 = callKeysBalancerV3 & {
+    numberTokens: number;
+    [key: `balanceToken${number}`]: BigNumber;
+    tokenInfo: {
+        tokens: string[];
+        tokenInfo: string[][];
+        balancesRaw: BigNumber[];
+        lastBalancesLiveScaled18: BigNumber[];
+    };
+};
+type dataTypeBalancerV3 = dataType & {
+    numberTokens: number;
+};
+export declare class BalancerV3PoolProcessor extends GenericProcessor<callKeysBalancerV3, dataRawBalancerV3, dataTypeBalancerV3> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawBalancerV3): void;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawBalancerV3, calls: string[]): tokenTypeStruct;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawBalancerV3, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBalancerV3>;
+}
+export {};

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

@@ -0,0 +1,69 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+const matchSingleNumber = (input) => {
+    const regex = /^\d+$/;
+    return regex.test(input);
+};
+export class BalancerV3PoolProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "numberTokens", call: "getTokens", target: "tokenAddress" },
+            { key: "tokenInfo", call: "getTokenInfo", target: "tokenAddress" },
+        ],
+        round2: [],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    processingRound2(typeInfo) {
+        typeInfo.numberTokens = Number(typeInfo.numberTokens);
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            typeInfo[`token${i}`] = typeInfo.tokenInfo.tokens[i];
+            this.rounds.round2 = this.rounds.round2.concat([
+                { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
+                { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
+            ]);
+            typeInfo[`balanceToken${i}`] = typeInfo.tokenInfo.balancesRaw[i];
+        }
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            this.rounds.round2 = this.rounds.round2.concat([
+                { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
+                { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
+            ]);
+        }
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        let tvl = 0;
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            const symbol = typeInfo[`symbolToken${i}`];
+            const price = (await pricer.get({ symbol: symbol })) ?? 0;
+            const decimals = Number(typeInfo[`decimalsToken${i}`]);
+            const amount = BN2Number(typeInfo[`balanceToken${i}`], decimals);
+            tvl += amount * price;
+        }
+        const priceTargetToken = tvl / totalSupply;
+        // Remove all keys that start with a number or balanceToken
+        for (const key in typeInfo) {
+            if (key.startsWith("balanceToken") ||
+                key.startsWith("decimalsToken") ||
+                matchSingleNumber(key) ||
+                key.startsWith("tokenInfo")) {
+                delete typeInfo[key];
+            }
+        }
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { BigNumber } from "ethers";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawHourglass;
+    call: string;
+    target: keyof callKeysHourglass;
+    metaData?: keyof callKeysHourglass;
+};
+export type callKeysHourglass = mandatoryCallKeys & {
+    depositor: string;
+    underlying: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlying: string;
+    balanceOfUnderlying: string;
+};
+type dataRawHourglass = callKeysHourglass & {};
+type dataTypeHourglass = dataType & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlying: number;
+    priceTargetToken: number;
+    balanceOfUnderlying: BigNumber;
+};
+export declare class HourglassProcessor extends GenericProcessor<callKeysHourglass, dataRawHourglass, dataTypeHourglass> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawHourglass, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeHourglass>;
+}
+export {};

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

@@ -0,0 +1,31 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class HourglassProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "depositor", call: "depositor", target: "tokenAddress" }],
+        round2: [{ key: "underlying", call: "underlying", target: "depositor" }],
+        round3: [
+            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
+            { key: "decimalsUnderlying", call: "decimals", target: "underlying" },
+            { key: "balanceOfUnderlying", call: "balanceOf", target: "underlying", metaData: "depositor" },
+        ],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // // override computeRound1(): void {}
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        const tvl = BN2Number(typeInfo.balanceOfUnderlying, Number(typeInfo.decimalsUnderlying)) * priceUnderlying;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            whitelistedSupplyTargetToken,
+            tvl: tvl,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+            blacklistedSupply,
+            totalSupply,
+        };
+    }
+}

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

@@ -5,6 +5,7 @@ import { AssetProcessor } from "./AssetProcessor";
 import { AuraProcessor } from "./AuraProcessor";
 import { BalancerGaugeProcessor } from "./BalancerGaugeProcessor";
 import { BalancerPoolProcessor } from "./BalancerPoolProcessor";
+import { BalancerV3PoolProcessor } from "./BalancerV3PoolProcessor";
 import { BeefyProcessor } from "./BeefyProcessor";
 import { CompoundProcessor } from "./CompoundProcessor";
 import { ERC4626Processor } from "./ERC4626Processor";
@@ -18,6 +19,7 @@ import { GammaProcessor } from "./GammaProcessor";
 import { GearboxProcessor } from "./GearboxProcessor";
 import { GenericProcessor } from "./GenericProcessor";
 import { HoldStationProcessor } from "./HoldStationProcessor";
+import { HourglassProcessor } from "./HourglassProcessor";
 import { MaverickBPProcessor } from "./MaverickBPProcessor";
 import { MetamorphoProcessor } from "./MetamorphoProcessor";
 import { NoLinkVaultProcessor } from "./NoLinkVaultProcessor";
@@ -127,4 +129,7 @@ export const processorMapping = {
     [tokenType.spectra_lpt]: SpectraProcessor,
     [tokenType.spectra_yt]: SpectraYTProcessor,
     [tokenType.rfx_slv]: ERC4626Processor,
+    [tokenType.hourglass]: HourglassProcessor,
+    [tokenType.katana]: UniswapProcessor,
+    [tokenType.balancerV3]: BalancerV3PoolProcessor,
 };

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

@@ -8,6 +8,8 @@ import { processorMapping } from "./processor/processorMapping";
 function satisfiesNameConditions(name, type) {
     const lowerCaseName = name.toLowerCase();
     switch (type) {
+        case tokenType.hourglass:
+            return lowerCaseName.startsWith("ct-hourglass");
         case tokenType.fraxlend:
             return lowerCaseName.includes("fraxlend interest bearing");
         case tokenType.sturdy_aggregator:
@@ -244,6 +246,13 @@ function parseForBalancer(calls, targetToken, name) {
     catch (e) {
         // Not a balancer pool
     }
+    try {
+        decodeReturnValue(calls.vault, "getVault");
+        return generateResult(tokenType.balancerV3, name, targetToken, {});
+    }
+    catch (e) {
+        // Not a balancer v3 pool
+    }
 }
 function checkAgainstHardcoded(calls, chainId, targetToken) {
     // Check for balancer pools
@@ -284,6 +293,7 @@ export function getTokenTypeRound1(calls, targetToken, index, campaign) {
         poolId: returnValueOfCalls[index + 3],
         creator: returnValueOfCalls[index + 4],
         owner: returnValueOfCalls[index + 5],
+        vault: returnValueOfCalls[index + 6],
     };
     let result = parseForFactory(returnValue, targetToken);
     if (result)

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

@@ -7,33 +7,11 @@ export class BoostService {
         const protocol = query.protocol;
         const target = query.target;
         const url = `https://www.data-openblocklabs.com/zksync/boosts/${protocol}/${target}`;
-        // console.log(url);
-        // return (
-        //   await axios.post(url, body, {
-        //     headers: {
-        //       "Content-Type": "application/json",
-        //     }}));
-        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" },
-        ];
+        return (await axios.post(url, body, {
+            headers: {
+                "Content-Type": "application/json",
+            },
+        })).data.map(({ address, boost }) => ({ address, boost: boost.toString() }));
     }
     static async getOpenBlockBoostDefault() {
         return [

package/dist/src/utils/decodeCalls.js

@@ -1,4 +1,4 @@
-import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerVaultInterface, BeefyInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveLPTokenInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, ERC4626Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, IonicInterface, LayerBankERC20Interface, LayerBankInterface, LendleInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxInterface, RswEthStrategyInterface, SpectraYTInterface, SturdyInterface, SymetricAmbientStrategyInterface, SyncSwapClassicPoolInterface, TorosInterface, UniswapV2PoolInterface, VePufferInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
+import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerV3StablePoolInterface, BalancerVaultInterface, BeefyInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveLPTokenInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, ERC4626Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, HourglassERC20TBTInterface, HourglassVedaLockDepositorV2Interface, IonicInterface, LayerBankERC20Interface, LayerBankInterface, LendleInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxInterface, RswEthStrategyInterface, SpectraYTInterface, SturdyInterface, SymetricAmbientStrategyInterface, SyncSwapClassicPoolInterface, TorosInterface, UniswapV2PoolInterface, VePufferInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
 import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
 export function decodeCall(calls, index, key, type) {
     const returnData = calls[index];
@@ -117,6 +117,8 @@ export function decodeReturnValue(returnData, key, type) {
                 case tokenType.euler_lend:
                 case tokenType.maha:
                     return EulerInterface.decodeFunctionResult("asset", returnData)[0];
+                case tokenType.hourglass:
+                    return HourglassVedaLockDepositorV2Interface.decodeFunctionResult("getUnderlying", returnData)[0];
                 default:
                     throw new Error(`Need tokenType for this key ${key}, or type ${type} not matched`);
             }
@@ -271,6 +273,12 @@ export function decodeReturnValue(returnData, key, type) {
             return SyncSwapClassicPoolInterface.decodeFunctionResult("reserve1", returnData)[0];
         case "asset":
             return ERC4626Interface.decodeFunctionResult("asset", returnData)[0];
+        case "depositor":
+            return HourglassERC20TBTInterface.decodeFunctionResult("depositor", returnData)[0];
+        case "getTokens":
+            return BalancerV3StablePoolInterface.decodeFunctionResult("getTokens", returnData)[0].length;
+        case "getTokenInfo":
+            return BalancerV3StablePoolInterface.decodeFunctionResult("getTokenInfo", returnData);
         default:
             throw new Error(`Key not recognized for ${key}`);
     }

package/dist/src/utils/encodeCalls.js

@@ -1,5 +1,5 @@
 import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
-import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerVaultInterface, BeefyInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveLPTokenInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, ERC4626Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, IonicInterface, LayerBankInterface, LendleInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxDatastoreInterface, RswEthStrategyInterface, SpectraYTInterface, SturdyInterface, SymetricAmbientStrategyInterface, SyncSwapClassicPoolInterface, TorosInterface, UniswapV2PoolInterface, VePufferInterface, ZFStableLPINterface, } from "@sdk";
+import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerV3StablePoolInterface, BalancerVaultInterface, BeefyInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveLPTokenInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, ERC4626Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, HourglassERC20TBTInterface, HourglassVedaLockDepositorV2Interface, IonicInterface, LayerBankInterface, LendleInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxDatastoreInterface, RswEthStrategyInterface, SpectraYTInterface, SturdyInterface, SymetricAmbientStrategyInterface, SyncSwapClassicPoolInterface, TorosInterface, UniswapV2PoolInterface, VePufferInterface, ZFStableLPINterface, } from "@sdk";
 export function createCall(target, key, type, metaData) {
     switch (key) {
         case "SY":
@@ -148,6 +148,12 @@ export function createCall(target, key, type, metaData) {
                 case tokenType.vicuna_borrowing:
                 case tokenType.vicuna_lending:
                     return { allowFailure: true, callData: AaveInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"), target };
+                case tokenType.hourglass:
+                    return {
+                        allowFailure: true,
+                        callData: HourglassVedaLockDepositorV2Interface.encodeFunctionData("getUnderlying"),
+                        target,
+                    };
                 default:
                     throw new Error(`Need tokenType for this key ${key}, or unknown type ${type}`);
             }
@@ -417,6 +423,24 @@ export function createCall(target, key, type, metaData) {
                 callData: SyncSwapClassicPoolInterface.encodeFunctionData("reserve1"),
                 target: target,
             };
+        case "depositor":
+            return {
+                allowFailure: true,
+                callData: HourglassERC20TBTInterface.encodeFunctionData("depositor"),
+                target: target,
+            };
+        case "getTokens":
+            return {
+                allowFailure: true,
+                callData: BalancerV3StablePoolInterface.encodeFunctionData("getTokens"),
+                target: target,
+            };
+        case "getTokenInfo":
+            return {
+                allowFailure: true,
+                callData: BalancerV3StablePoolInterface.encodeFunctionData("getTokenInfo"),
+                target: target,
+            };
         default:
             throw new Error(`Unknown key ${key}`);
     }

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

@@ -1,3 +1,3 @@
 import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
-import type { Campaign, CampaignParameters } from "@sdk";
+import { type Campaign, type CampaignParameters } from "@sdk";
 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,4 +1,5 @@
 import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
+import { ChainId } from "@sdk";
 export function generateCardName(type, typeInfo, campaign, symbols = [""], displayName) {
     switch (type) {
         case tokenType.uniswapv2:
@@ -15,6 +16,7 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""], displ
         case tokenType.syncswap:
         case tokenType.pancakeswap:
         case tokenType.traderJoe:
+        case tokenType.katana:
             return `Provide liquidity to ${typeInfo.protocol} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
         case tokenType.pendleYT:
             return `Hold ${typeInfo.protocol} ${typeInfo.name}`;
@@ -23,12 +25,25 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""], displ
         case tokenType.balancerGauge:
             return `${typeInfo.protocol} ${symbols.join("-")}`;
         case tokenType.balancerPool: {
+            if (campaign.computeChainId === ChainId.SONIC) {
+                typeInfo.protocol = "Beets";
+            }
             let cardName = `Provide liquidity to ${typeInfo.protocol} ${symbols.join("-")}`;
             if (typeInfo.vault === "0xFB43069f6d0473B85686a85F4Ce4Fc1FD8F00875") {
                 cardName = `Provide liquidity to Jellyverse Pool ${symbols.join("-")}`;
             }
             return cardName;
         }
+        case tokenType.balancerV3: {
+            const symbols = [];
+            for (let i = 0; i < typeInfo.numberTokens; i++) {
+                symbols.push(typeInfo[`symbolToken${i}`]);
+            }
+            if (campaign.computeChainId === ChainId.SONIC) {
+                typeInfo.protocol = "Beets";
+            }
+            return `Provide liquidity to ${typeInfo.protocol} ${symbols.join("-")}`;
+        }
         case tokenType.aura:
             return `Provide liquidity to ${typeInfo.protocol} ${symbols.join("-")}`;
         case tokenType.gearbox:
@@ -144,6 +159,8 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""], displ
             return `Provide liquidity on Spectra to ${typeInfo.name}`;
         case tokenType.spectra_yt:
             return `Hold Spectra ${typeInfo.name}`;
+        case tokenType.hourglass:
+            return `Deposit ${typeInfo.symbolUnderlyingToken} into Hourglass`;
         default:
             // OVERRIDE
             switch (typeInfo.tokenAddress) {