@merkl/api 0.20.101 → 0.20.103

package/dist/src/modules/v4/token/token.repository.js

@@ -4,33 +4,55 @@ import axios from "axios";
 export class TokenRepository {
     static #transformQueryToPrismaFilters(query) {
         const ids = query.id ? query.id.map(id => ({ id })) : [];
+        const { page: _page, items: _items } = query;
+        const page = _page ? _page : 0;
+        const items = _items !== undefined ? _items : 100;
         return {
+            take: items === 0 ? undefined : items,
+            skip: page * items,
             where: {
-                OR: query.symbol
-                    ? [
-                        { symbol: { equals: query.symbol, mode: "insensitive" } },
-                        { displaySymbol: { equals: query.symbol, mode: "insensitive" } },
-                        ...ids,
-                    ]
-                    : query.displaySymbol
-                        ? [
-                            {
-                                displaySymbol: "",
-                                symbol: { equals: query.displaySymbol, mode: "insensitive" },
-                            },
-                            { displaySymbol: { equals: query.displaySymbol, mode: "insensitive" } },
-                            ...ids,
-                        ]
-                        : ids.length
-                            ? [...ids]
-                            : undefined,
-                address: query.address ? { equals: query.address, mode: "insensitive" } : undefined,
-                chainId: query.chainId ? { equals: query.chainId } : undefined,
-                name: query.name ? { contains: query.name, mode: "insensitive" } : undefined,
-                verified: query.verified ? { equals: query.verified } : undefined,
-                isTest: query.test ? { equals: query.test } : undefined,
-                icon: query.missingIcons ? { equals: "" } : undefined,
-                price: query.missingPrice ? { equals: null } : undefined,
+                AND: [
+                    {
+                        OR: query.symbol
+                            ? [
+                                { symbol: { equals: query.symbol, mode: "insensitive" } },
+                                { displaySymbol: { equals: query.symbol, mode: "insensitive" } },
+                                ...ids,
+                            ]
+                            : query.displaySymbol
+                                ? [
+                                    {
+                                        displaySymbol: "",
+                                        symbol: { equals: query.displaySymbol, mode: "insensitive" },
+                                    },
+                                    { displaySymbol: { equals: query.displaySymbol, mode: "insensitive" } },
+                                    ...ids,
+                                ]
+                                : ids.length
+                                    ? [...ids]
+                                    : undefined,
+                        address: query.address ? { equals: query.address, mode: "insensitive" } : undefined,
+                        chainId: query.chainId ? { equals: query.chainId } : undefined,
+                        name: query.name ? { contains: query.name, mode: "insensitive" } : undefined,
+                        verified: query.verified ? { equals: query.verified } : undefined,
+                        isTest: query.test ? { equals: query.test } : undefined,
+                        icon: query.missingIcons ? { equals: "" } : undefined,
+                        price: query.missingPrice ? { equals: null } : undefined,
+                    },
+                    !query.search
+                        ? {}
+                        : {
+                            AND: query.search?.split(" ")?.map((keyword) => ({
+                                OR: [
+                                    { id: { contains: keyword, mode: "insensitive" } },
+                                    { name: { contains: keyword, mode: "insensitive" } },
+                                    { symbol: { contains: keyword, mode: "insensitive" } },
+                                    { address: { contains: keyword, mode: "insensitive" } },
+                                    { Chain: { name: { contains: keyword, mode: "insensitive" } } },
+                                ],
+                            })),
+                        },
+                ],
             },
         };
     }

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

@@ -114,6 +114,13 @@ export declare abstract class TokenService {
     } & {
         price?: number | null | undefined;
     }>;
+    /**
+     * Checks if two tokens are the same based on chainId/address combo
+     * @param a token
+     * @param b token
+     * @returns true if both tokens are the same
+     */
+    static isSame(a: Pick<Token["model"], "chainId" | "address">, b: Pick<Token["model"], "chainId" | "address">): Promise<boolean>;
     /**
      * Get the list of tokens satisfying the query
      * @param query
@@ -134,6 +141,26 @@ export declare abstract class TokenService {
     } & {
         price?: number | null | undefined;
     })[]>;
+    /**
+     * Get the list of tokens satisfying the query or fetch if chainId and address are provided
+     * @param query
+     * @returns A list of tokens
+     */
+    static findManyOrFetch(query: GetTokenQueryModel): Promise<({
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+    } & {
+        price?: number | null | undefined;
+    })[]>;
     static getPrice(query: GetTokenQueryModel): Promise<number>;
     static findManyObjectPerAddress(query: GetTokenQueryModel): Promise<Record<string, {
         symbol: string;
@@ -256,10 +283,4 @@ export declare abstract class TokenService {
         isNative: boolean;
         price: number | null;
     }>;
-    /**
-     * @deprecated Should be useless now that the token list is not used anymore
-     * Get all tokens from https://github.com/AngleProtocol/angle-token-list and override icons from it
-     * TODO: use the bucket
-     */
-    static fillTokenAndIconsFromTokenList(): Promise<void>;
 }

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

@@ -1,18 +1,16 @@
 import { HttpError } from "@/errors";
-import { getTokensListWithCache } from "@/libs/getTokensList";
 import { getOnlyUserBalance } from "@/libs/tokens/balances";
 import { BucketService } from "@/modules/v4/bucket/bucket.service";
+import { CacheService } from "@/modules/v4/cache";
+import { TTLPresets } from "@/modules/v4/cache/cache.model";
+import { CoingeckoService } from "@/modules/v4/coingecko/coingecko.service";
 import { IconService } from "@/modules/v4/icon/icon.service";
 import { PriceService } from "@/modules/v4/price/price.service";
 import { log } from "@/utils/logger";
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
-import { apiDbClient } from "@db";
 import { Prisma } from "@db/api";
 import { ChainInteractionService, DistributionCreatorService, NETWORK_LABELS, NULL_ADDRESS, bigIntToNumber, } from "@sdk";
-import { getAddress, parseUnits } from "viem";
-import { CacheService } from "../cache";
-import { TTLPresets } from "../cache/cache.model";
-import { CoingeckoService } from "../coingecko/coingecko.service";
+import { getAddress, isAddress, parseUnits } from "viem";
 import { TokenRepository } from "./token.repository";
 export class TokenService {
     static hashId(token) {
@@ -165,6 +163,15 @@ export class TokenService {
         const id = typeof token === "string" ? token : TokenService.hashId(token);
         return await TokenRepository.findUniqueOrThrow(id);
     }
+    /**
+     * Checks if two tokens are the same based on chainId/address combo
+     * @param a token
+     * @param b token
+     * @returns true if both tokens are the same
+     */
+    static async isSame(a, b) {
+        return a.chainId === b.chainId && a.address?.toLowerCase() === b.address?.toLowerCase();
+    }
     /**
      * Get the list of tokens satisfying the query
      * @param query
@@ -173,6 +180,22 @@ export class TokenService {
     static async findMany(query) {
         return (await TokenRepository.findMany(query)).map(TokenService.format);
     }
+    /**
+     * Get the list of tokens satisfying the query or fetch if chainId and address are provided
+     * @param query
+     * @returns A list of tokens
+     */
+    static async findManyOrFetch(query) {
+        const foundTokens = (await TokenRepository.findMany(query)).map(TokenService.format);
+        const isTokenAddress = query.chainId && query.search && isAddress(query.search);
+        if (isTokenAddress &&
+            !foundTokens.some(t => TokenService.isSame(t, { chainId: query.chainId, address: query.search }))) {
+            const token = await TokenService.fetchOnChain({ chainId: query.chainId, address: query.search });
+            //Assigning a temporary id since token is not in the database
+            token && foundTokens.push({ ...token, id: `tmp-${token.chainId}-${token.address}` });
+        }
+        return foundTokens;
+    }
     static async getPrice(query) {
         const tokensFound = (await TokenRepository.findMany(query)).map(TokenService.format);
         if (tokensFound.length === 0) {
@@ -343,77 +366,4 @@ export class TokenService {
         }
         return await TokenRepository.upsert({ ...filledData, ...token, id });
     }
-    /**
-     * @deprecated Should be useless now that the token list is not used anymore
-     * Get all tokens from https://github.com/AngleProtocol/angle-token-list and override icons from it
-     * TODO: use the bucket
-     */
-    static async fillTokenAndIconsFromTokenList() {
-        const tokenList = await getTokensListWithCache();
-        for (const chain of Object.keys(tokenList)) {
-            for (const [symbol, token] of Object.entries(tokenList[chain])) {
-                if (!(await TokenRepository.findUnique(TokenService.hashId({ chainId: Number.parseInt(chain), address: token.address })))) {
-                    try {
-                        const res = await TokenRepository.create({
-                            id: TokenService.hashId({ chainId: Number.parseInt(chain), address: token.address }),
-                            chainId: Number.parseInt(chain),
-                            address: token.address,
-                            name: token.name,
-                            symbol: token.symbol,
-                            verified: true,
-                            decimals: token.decimals,
-                            icon: token.logoURI,
-                            isTest: false,
-                            isPoint: false,
-                            isNative: false,
-                        });
-                        log.local(`Token created: ${res?.symbol} on ${NETWORK_LABELS[Number.parseInt(chain)]}`);
-                    }
-                    catch (e) {
-                        console.error(e);
-                    }
-                }
-                try {
-                    await apiDbClient.token.update({
-                        data: {
-                            chainId: Number.parseInt(chain),
-                            address: token.address,
-                            name: token.name,
-                            symbol: token.symbol,
-                            verified: true,
-                            decimals: token.decimals,
-                            icon: token.logoURI,
-                        },
-                        where: {
-                            chainId_address: {
-                                chainId: Number.parseInt(chain),
-                                address: token.address,
-                            },
-                        },
-                    });
-                }
-                catch (e) {
-                    console.error(e);
-                }
-                try {
-                    const tokensWithSameSymbol = await apiDbClient.token.findMany({
-                        select: { chainId: true, address: true },
-                        where: { symbol: { equals: symbol, mode: "insensitive" } },
-                    });
-                    for (const dbToken of tokensWithSameSymbol) {
-                        await apiDbClient.token.update({
-                            data: { icon: token.logoURI },
-                            where: {
-                                chainId_address: {
-                                    chainId: dbToken.chainId,
-                                    address: dbToken.address,
-                                },
-                            },
-                        });
-                    }
-                }
-                catch (_err) { }
-            }
-        }
-    }
 }

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

@@ -1,3 +1,3 @@
-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;
+import { Erc20SubType } from "@/engine/campaignTVL/implementations/Erc20/Erc20SubType";
+export declare function decodeCall(calls: string[], index: number, key: string, type?: Erc20SubType): any;
+export declare function decodeReturnValue(returnData: string, key: string, type?: Erc20SubType): any;

package/dist/src/utils/decodeCalls.js

@@ -1,4 +1,4 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { Erc20SubType } from "@/engine/campaignTVL/implementations/Erc20/Erc20SubType";
 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) {
@@ -25,8 +25,8 @@ export function decodeReturnValue(returnData, key, type) {
             return ERC20Interface.decodeFunctionResult("decimals", returnData)[0];
         case "totalSupply":
             switch (type) {
-                case tokenType.lendle_lending:
-                case tokenType.lendle_borrowing:
+                case Erc20SubType.lendle_lending:
+                case Erc20SubType.lendle_borrowing:
                     return LendleInterface.decodeFunctionResult("scaledTotalSupply", returnData)[0];
                 default:
                     return ERC20Interface.decodeFunctionResult("totalSupply", returnData)[0];
@@ -51,8 +51,8 @@ export function decodeReturnValue(returnData, key, type) {
             return UniswapV2PoolInterface.decodeFunctionResult("token1", returnData)[0];
         case "lp_token":
             switch (type) {
-                case tokenType.beraborrow_gauge:
-                case tokenType.beratrax_vault:
+                case Erc20SubType.beraborrow_gauge:
+                case Erc20SubType.beratrax_vault:
                     return ERC4626Interface.decodeFunctionResult("asset", returnData)[0];
                 default:
                     return BalancerGaugeInterface.decodeFunctionResult("lp_token", returnData)[0];
@@ -73,94 +73,94 @@ export function decodeReturnValue(returnData, key, type) {
             return RfxInterface.decodeFunctionResult("longToken", returnData)[0];
         case "underlying":
             switch (type) {
-                case tokenType.pendle:
-                case tokenType.pendleYT:
+                case Erc20SubType.pendle:
+                case Erc20SubType.pendleYT:
                     return PendleInterface.decodeFunctionResult("yieldToken", returnData)[0];
-                case tokenType.gearbox:
+                case Erc20SubType.gearbox:
                     return GearboxVaultInterface.decodeFunctionResult("underlyingToken", returnData)[0];
-                case tokenType.enzyme:
+                case Erc20SubType.enzyme:
                     return EnzymeInterface.decodeFunctionResult("calcNetShareValue", returnData)[0];
-                case tokenType.aura:
+                case Erc20SubType.aura:
                     return AuraInterface.decodeFunctionResult("asset", returnData)[0];
-                case tokenType.fluid:
+                case Erc20SubType.fluid:
                     return FluidInterface.decodeFunctionResult("asset", returnData)[0];
-                case tokenType.metamorpho:
+                case Erc20SubType.metamorpho:
                     return MetamorphoInterface.decodeFunctionResult("asset", returnData)[0];
-                case tokenType.fraxlend:
-                case tokenType.sturdy_aggregator:
-                case tokenType.sturdy_silo:
+                case Erc20SubType.fraxlend:
+                case Erc20SubType.sturdy_aggregator:
+                case Erc20SubType.sturdy_silo:
                     return FraxlendInterface.decodeFunctionResult("asset", returnData)[0];
-                case tokenType.aave_lending:
-                case tokenType.aave_borrowing:
-                case tokenType.sake_lending:
-                case tokenType.sake_borrowing:
-                case tokenType.ironclad_lending:
-                case tokenType.ironclad_borrowing:
-                case tokenType.zerolend_lending:
-                case tokenType.zerolend_borrowing:
-                case tokenType.avalon_lending:
-                case tokenType.avalon_borrowing:
-                case tokenType.superlend_lending:
-                case tokenType.superlend_borrowing:
-                case tokenType.takotako_lending:
-                case tokenType.takotako_borrowing:
-                case tokenType.vicuna_borrowing:
-                case tokenType.vicuna_lending:
-                case tokenType.lendle_lending:
-                case tokenType.lendle_borrowing:
-                case tokenType.yei_borrowing:
-                case tokenType.yei_lending:
-                case tokenType.xlend_lending:
-                case tokenType.xlend_borrowing:
+                case Erc20SubType.aave_lending:
+                case Erc20SubType.aave_borrowing:
+                case Erc20SubType.sake_lending:
+                case Erc20SubType.sake_borrowing:
+                case Erc20SubType.ironclad_lending:
+                case Erc20SubType.ironclad_borrowing:
+                case Erc20SubType.zerolend_lending:
+                case Erc20SubType.zerolend_borrowing:
+                case Erc20SubType.avalon_lending:
+                case Erc20SubType.avalon_borrowing:
+                case Erc20SubType.superlend_lending:
+                case Erc20SubType.superlend_borrowing:
+                case Erc20SubType.takotako_lending:
+                case Erc20SubType.takotako_borrowing:
+                case Erc20SubType.vicuna_borrowing:
+                case Erc20SubType.vicuna_lending:
+                case Erc20SubType.lendle_lending:
+                case Erc20SubType.lendle_borrowing:
+                case Erc20SubType.yei_borrowing:
+                case Erc20SubType.yei_lending:
+                case Erc20SubType.xlend_lending:
+                case Erc20SubType.xlend_borrowing:
                     return AaveInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", returnData)[0];
-                case tokenType.radiant_borrow:
-                case tokenType.radiant_lend:
+                case Erc20SubType.radiant_borrow:
+                case Erc20SubType.radiant_lend:
                     return RadiantInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", returnData)[0];
-                case tokenType.moonwell:
+                case Erc20SubType.moonwell:
                     return MoonwellInterface.decodeFunctionResult("underlying", returnData)[0];
-                case tokenType.ionic:
-                case tokenType.venus:
+                case Erc20SubType.ionic:
+                case Erc20SubType.venus:
                     return IonicInterface.decodeFunctionResult("underlying", returnData)[0];
-                case tokenType.reactor_fusion:
+                case Erc20SubType.reactor_fusion:
                     try {
                         return IonicInterface.decodeFunctionResult("underlying", returnData)[0];
                     }
                     catch (e) {
                         return "0x000000000000000000000000000000000000800A";
                     }
-                case tokenType.layerbank:
+                case Erc20SubType.layerbank:
                     return LayerBankInterface.decodeFunctionResult("underlying", returnData)[0];
-                case tokenType.holdstation:
+                case Erc20SubType.holdstation:
                     return DefutureVaultInterface.decodeFunctionResult("asset", returnData)[0];
-                case tokenType.euler_borrow:
-                case tokenType.euler_lend:
-                case tokenType.maha:
+                case Erc20SubType.euler_borrow:
+                case Erc20SubType.euler_lend:
+                case Erc20SubType.maha:
                     return EulerInterface.decodeFunctionResult("asset", returnData)[0];
-                case tokenType.hourglass:
+                case Erc20SubType.hourglass:
                     return HourglassVedaLockDepositorV2Interface.decodeFunctionResult("getUnderlying", returnData)[0];
-                case tokenType.curve_gauge:
+                case Erc20SubType.curve_gauge:
                     return BalancerGaugeInterface.decodeFunctionResult("lp_token", returnData)[0];
                 default:
-                    throw new Error(`Need tokenType for this key ${key}, or type ${type} not matched`);
+                    throw new Error(`Need Erc20SubType for this key ${key}, or type ${type} not matched`);
             }
         // case "exchangeRateCurrent":
         //   return IonicInterface.decodeFunctionResult("exchangeRateCurrent", returnData)[0];
         case "exchangeRate":
             switch (type) {
-                case tokenType.pendle:
+                case Erc20SubType.pendle:
                     return PendleInterface.decodeFunctionResult("exchangeRate", returnData)[0];
-                case tokenType.layerbank:
+                case Erc20SubType.layerbank:
                     return LayerBankInterface.decodeFunctionResult("exchangeRate", returnData)[0];
-                case tokenType.enzyme:
+                case Erc20SubType.enzyme:
                     return EnzymeInterface.decodeFunctionResult("calcNetShareValue", returnData)[1];
-                case tokenType.ionic:
+                case Erc20SubType.ionic:
                     return IonicInterface.decodeFunctionResult("exchangeRateCurrent", returnData)[0];
-                case tokenType.moonwell:
-                case tokenType.venus:
-                case tokenType.reactor_fusion:
+                case Erc20SubType.moonwell:
+                case Erc20SubType.venus:
+                case Erc20SubType.reactor_fusion:
                     return MoonwellInterface.decodeFunctionResult("exchangeRateStored", returnData)[0];
                 default:
-                    throw new Error(`Need tokenType for this key ${key}`);
+                    throw new Error(`Need Erc20SubType for this key ${key}`);
             }
         // case "exchangeRateStored":
         //   return MoonwellInterface.decodeFunctionResult("exchangeRateStored", returnData)[0];
@@ -170,14 +170,14 @@ export function decodeReturnValue(returnData, key, type) {
             return SturdyInterface.decodeFunctionResult("collateralContract", returnData)[0];
         case "lp_price":
             switch (type) {
-                case tokenType.curve:
-                case tokenType.curve_gauge:
+                case Erc20SubType.curve:
+                case Erc20SubType.curve_gauge:
                     return CurveInterface.decodeFunctionResult("lp_price", returnData)[0];
-                case tokenType.curve_2:
-                case tokenType.maha:
+                case Erc20SubType.curve_2:
+                case Erc20SubType.maha:
                     return CurveInterface.decodeFunctionResult("get_virtual_price", returnData)[0];
                 default:
-                    throw new Error(`Need tokenType for this key ${key}`);
+                    throw new Error(`Need Erc20SubType for this key ${key}`);
             }
         case "coin0":
             return CurveInterface.decodeFunctionResult("coins", returnData)[0];
@@ -213,25 +213,25 @@ export function decodeReturnValue(returnData, key, type) {
             return AuraOperatorInterface.decodeFunctionResult("staker", returnData)[0];
         case "totalAssets":
             switch (type) {
-                case tokenType.anglesLiquid:
-                case tokenType.cian:
-                case tokenType.rfx_slv:
-                case tokenType.beratrax_vault:
-                case tokenType.beraborrow_gauge:
-                case tokenType.metamorpho:
+                case Erc20SubType.anglesLiquid:
+                case Erc20SubType.cian:
+                case Erc20SubType.rfx_slv:
+                case Erc20SubType.beratrax_vault:
+                case Erc20SubType.beraborrow_gauge:
+                case Erc20SubType.metamorpho:
                     return ERC4626Interface.decodeFunctionResult("totalAssets", returnData)[0];
-                case tokenType.concrete:
+                case Erc20SubType.concrete:
                     return ERC4626Interface.decodeFunctionResult("totalAssets", returnData)[0];
-                case tokenType.gearbox:
+                case Erc20SubType.gearbox:
                     return GearboxVaultInterface.decodeFunctionResult("totalAssets", returnData)[0];
-                case tokenType.euler_lend:
+                case Erc20SubType.euler_lend:
                     return EulerInterface.decodeFunctionResult("totalAssets", returnData)[0];
-                case tokenType.euler_borrow:
+                case Erc20SubType.euler_borrow:
                     return EulerInterface.decodeFunctionResult("totalBorrows", returnData)[0];
-                case tokenType.compound:
+                case Erc20SubType.compound:
                     return CompoundInterface.decodeFunctionResult("totalBorrow", returnData)[0];
                 default:
-                    throw new Error(`Need tokenType for this key ${key}, or type ${type} not matched`);
+                    throw new Error(`Need Erc20SubType for this key ${key}, or type ${type} not matched`);
             }
         case "getPoolTokens":
             return [
@@ -240,7 +240,7 @@ export function decodeReturnValue(returnData, key, type) {
             ];
         case "convertToAssets":
             switch (type) {
-                case tokenType.curve_gauge:
+                case Erc20SubType.curve_gauge:
                     return BigNumber.from("1000000000000000000");
                 default:
                     return FluidInterface.decodeFunctionResult("convertToAssets", returnData)[0];
@@ -257,7 +257,7 @@ export function decodeReturnValue(returnData, key, type) {
             return ZFStableSwapThreePoolInterface.decodeFunctionResult("coins", returnData)[0];
         case "minter":
             switch (type) {
-                case tokenType.spectra_lpt:
+                case Erc20SubType.spectra_lpt:
                     return CurveLPTokenInterface.decodeFunctionResult("minter", returnData)[0];
                 default:
                     return ZFStableLPINterface.decodeFunctionResult("minter", returnData)[0];
@@ -266,7 +266,7 @@ export function decodeReturnValue(returnData, key, type) {
             return SpectraYTInterface.decodeFunctionResult("getPT", returnData)[0];
         case "getTokenAddresses":
             switch (type) {
-                case tokenType.tempestStaking: {
+                case Erc20SubType.tempestStaking: {
                     return RswEthStrategyInterface.decodeFunctionResult("getTokenAddresses", returnData)[0];
                 }
                 default:
@@ -274,7 +274,7 @@ export function decodeReturnValue(returnData, key, type) {
             }
         case "getPositions":
             switch (type) {
-                case tokenType.tempestStaking: {
+                case Erc20SubType.tempestStaking: {
                     return RswEthStrategyInterface.decodeFunctionResult("getPositions", returnData);
                 }
                 default:

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

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