@merkl/api 0.10.128 → 0.10.130

package/dist/src/types/parameters/Action.js

@@ -0,0 +1,11 @@
+import { ANGLE_NETWORKS, opportunityActions } from "@sdk";
+import { t } from "elysia";
+export const Action = {
+    isValid: chain => ANGLE_NETWORKS.merkl.concat().includes(chain),
+    type: t.Union(opportunityActions.map(type => t.Literal(`${type}`)), {
+        examples: {
+            Any: { value: undefined },
+            ...opportunityActions.reduce((all, type) => Object.assign(all, { [`${type}`]: { value: `${type}` } }), {}),
+        },
+    }),
+};

package/dist/src/types/parameters/Chain.js

@@ -0,0 +1,13 @@
+import { ANGLE_NETWORKS, NETWORK_LABELS } from "@sdk";
+import { t } from "elysia";
+export const Chain = {
+    isValid: chain => ANGLE_NETWORKS.merkl.concat().includes(chain),
+    type: t.Union(ANGLE_NETWORKS.merkl.map(chain => t.Literal(chain)), {
+        examples: {
+            Any: { value: undefined },
+            ...ANGLE_NETWORKS.merkl.reduce((all, chain) => Object.assign(all, {
+                [`${NETWORK_LABELS[chain]} (${chain})`]: { value: chain },
+            }), {}),
+        },
+    }),
+};

package/dist/src/types/parameters/ChainCampaignId.js

@@ -0,0 +1,13 @@
+import { ANGLE_NETWORKS } from "@sdk";
+import { t } from "elysia";
+import { Chain } from "./Chain";
+export const ChainCampaignId = {
+    isValid: chain => ANGLE_NETWORKS.merkl.concat().includes(chain),
+    type: t.TemplateLiteral([Chain.type, t.Literal("_"), t.String()], {
+        examples: {
+            "Shuffle on Ethereum": {
+                value: "1_0xf69d17aa75d36c4a9c6402fd9abc012b66a7947acaa2b20b267fe3ef10733421",
+            },
+        },
+    }),
+};

package/dist/src/types/parameters/MainParameter.js

@@ -0,0 +1,19 @@
+import { ANGLE_NETWORKS } from "@sdk";
+import { t } from "elysia";
+export const MainParameter = {
+    isValid: chain => ANGLE_NETWORKS.merkl.concat().includes(chain),
+    type: t.String({
+        examples: {
+            Any: { value: undefined },
+            "UniswapV3 USDC.e-WETH 0.05 % on ZKSync": {
+                value: "0x3e3dD517fEC2E70EDdba2a626422a4BA286e8c38",
+            },
+            "StrykePCS ARB-USDC 0.05 % on Arbitrum": {
+                value: "0x9ffca51d23ac7f7df82da414865ef1055e5afcd7",
+            },
+            "UniswapV3 USDC-WETH 0.05 % on Taiko": {
+                value: "0xE47a76e15a6F3976c8Dc070B3a54C7F7083D668B",
+            },
+        },
+    }),
+};

package/dist/src/types/parameters/OpportunityId.js

@@ -0,0 +1,14 @@
+import { ANGLE_NETWORKS } from "@sdk";
+import { t } from "elysia";
+import { Chain } from "./Chain";
+export const OpportunityId = {
+    isValid: chain => ANGLE_NETWORKS.merkl.concat().includes(chain),
+    type: t.TemplateLiteral([Chain.type, t.Literal("_"), t.String(), t.Literal("_"), t.String()], {
+        examples: {
+            All: { value: undefined },
+            "PancakeSwapV3 rETH-WETH 0.05 %": {
+                value: "1_2_0x2201d2400d30BFD8172104B4ad046d019CA4E7bd",
+            },
+        },
+    }),
+};

package/dist/src/types/parameters/Timestamp.js

@@ -0,0 +1,16 @@
+import { t } from "elysia";
+import moment from "moment";
+export const Timestamp = {
+    isValid: timestamp => true,
+    type: t.Numeric({
+        examples: [
+            moment(),
+            moment().subtract(1, "hour"),
+            moment().subtract(1, "day"),
+            moment().subtract(7, "day"),
+            moment().subtract(30, "day"),
+        ].reduce((all, now) => Object.assign(all, {
+            [now.format("DD/MM ha")]: { value: `${now.unix()}` },
+        }), {}),
+    }),
+};

package/dist/src/types/parameters/Type.js

@@ -0,0 +1,15 @@
+import { ANGLE_NETWORKS, Campaign } from "@sdk";
+import { t } from "elysia";
+const campaigns = Object.keys(Campaign).filter(a => /[a-zA-Z]+/.test(a));
+// .map(n => Number.parseInt(n));
+export const Type = {
+    isValid: chain => ANGLE_NETWORKS.merkl.concat().includes(chain),
+    type: t.Union(campaigns.map(type => t.Literal(Campaign[type])), {
+        examples: {
+            Any: { value: undefined },
+            ...campaigns.reduce((all, type) => Object.assign(all, {
+                [`${Campaign[type]} (${type})`]: { value: Campaign[type] },
+            }), {}),
+        },
+    }),
+};

package/dist/src/types/parameters/index.js

@@ -0,0 +1,17 @@
+import { Action } from "./Action";
+import { Chain } from "./Chain";
+import { ChainCampaignId } from "./ChainCampaignId";
+import { MainParameter } from "./MainParameter";
+import { OpportunityId } from "./OpportunityId";
+import { Timestamp } from "./Timestamp";
+import { Type } from "./Type";
+const param = {
+    Chain,
+    Type,
+    Action,
+    ChainCampaignId,
+    OpportunityId,
+    MainParameter,
+    Timestamp,
+};
+export default param;

package/dist/src/types/returnTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/utils.js

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/addString.js

@@ -0,0 +1,6 @@
+export const addStrings = (a, b) => {
+    return (BigInt(a) + BigInt(b)).toString();
+};
+export const subStrings = (a, b) => {
+    return (BigInt(a) - BigInt(b)).toString();
+};

package/dist/src/utils/bigintToString.js

@@ -0,0 +1,20 @@
+// opportunities[0].campaigns[0]
+// opportunities: map bigintToString
+// campaign: map bigintToString
+export default function bigintToString(obj) {
+    if (Array.isArray(obj))
+        return obj.map(bigintToString);
+    if (typeof obj === "object" && obj !== null) {
+        return Object.keys(obj).reduce((acc, key) => {
+            const value = obj[key];
+            if (typeof value === "bigint")
+                acc[key] = value.toString();
+            else if (typeof value === "object" || Array.isArray(value))
+                acc[key] = bigintToString(value);
+            else
+                acc[key] = value;
+            return acc;
+        }, {});
+    }
+    return obj;
+}

package/dist/src/utils/crypto.js

@@ -0,0 +1,4 @@
+import crypto from "node:crypto";
+export function sha256(x) {
+    return crypto.createHash("sha256").update(x).digest("hex");
+}

package/dist/src/utils/decodeCalls.js

@@ -0,0 +1,170 @@
+import { AaveInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerVaultInterface, BeefyInterface, CompoundInterface, CurveInterface, ERC20Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, IonicInterface, LayerBankInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, RadiantInterface, RfxInterface, SturdyInterface, TorosInterface, UniswapV2PoolInterface, } from "@sdk";
+import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
+export function decodeCall(calls, index, key, type) {
+    const returnData = calls[index];
+    switch (key) {
+        case "symbol":
+            return ERC20Interface.decodeFunctionResult("symbol", returnData)[0];
+        case "decimals":
+            return ERC20Interface.decodeFunctionResult("decimals", returnData)[0];
+        case "totalSupply":
+            return ERC20Interface.decodeFunctionResult("totalSupply", returnData)[0];
+        case "balanceOf":
+            return ERC20Interface.decodeFunctionResult("balanceOf", returnData)[0];
+        case "name":
+            return ERC20Interface.decodeFunctionResult("name", returnData)[0];
+        case "getPoolId":
+            return BalancerPoolInterface.decodeFunctionResult("getPoolId", returnData)[0];
+        case "MORPHO":
+            return MetamorphoInterface.decodeFunctionResult("MORPHO", returnData)[0];
+        case "getCreator":
+            return EnzymeInterface.decodeFunctionResult("getCreator", returnData)[0];
+        case "factory":
+            return FactoryInterface.decodeFunctionResult("factory", returnData)[0];
+        case "token0":
+            return UniswapV2PoolInterface.decodeFunctionResult("token0", returnData)[0];
+        case "token1":
+            return UniswapV2PoolInterface.decodeFunctionResult("token1", returnData)[0];
+        case "lp_token":
+            return BalancerGaugeInterface.decodeFunctionResult("lp_token", returnData)[0];
+        case "operator":
+            return AuraInterface.decodeFunctionResult("operator", returnData)[0];
+        case "pid":
+            return AuraInterface.decodeFunctionResult("pid", returnData)[0];
+        case "stakingToken":
+            return OneInchStakingInterface.decodeFunctionResult("stakingToken", returnData)[0];
+        case "baseToken":
+            return CompoundInterface.decodeFunctionResult("baseToken", returnData)[0];
+        case "getAssetPrice":
+            return RadiantInterface.decodeFunctionResult("getAssetPrice", returnData)[0];
+        case "shortToken":
+            return RfxInterface.decodeFunctionResult("shortToken", returnData)[0];
+        case "longToken":
+            return RfxInterface.decodeFunctionResult("longToken", returnData)[0];
+        case "underlying":
+            switch (type) {
+                case tokenType.pendle:
+                    return PendleInterface.decodeFunctionResult("yieldToken", returnData)[0];
+                case tokenType.gearbox:
+                    return GearboxVaultInterface.decodeFunctionResult("underlyingToken", returnData)[0];
+                case tokenType.enzyme:
+                    return EnzymeInterface.decodeFunctionResult("calcNetShareValue", returnData)[0];
+                case tokenType.aura:
+                    return AuraInterface.decodeFunctionResult("asset", returnData)[0];
+                case tokenType.fluid:
+                    return FluidInterface.decodeFunctionResult("asset", returnData)[0];
+                case tokenType.metamorpho:
+                    return MetamorphoInterface.decodeFunctionResult("asset", returnData)[0];
+                case tokenType.fraxlend:
+                case tokenType.sturdy_aggregator:
+                case tokenType.sturdy_silo:
+                    return FraxlendInterface.decodeFunctionResult("asset", returnData)[0];
+                case tokenType.aave_lending:
+                case tokenType.aave_borrowing:
+                case tokenType.ironclad_lending:
+                case tokenType.ironclad_borrowing:
+                case tokenType.zerolend_lending:
+                case tokenType.zerolend_borrowing:
+                case tokenType.yei_borrowing:
+                case tokenType.yei_lending:
+                    return AaveInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", returnData)[0];
+                case tokenType.radiant_borrow:
+                case tokenType.radiant_lend:
+                    return RadiantInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", returnData)[0];
+                case tokenType.moonwell:
+                    return MoonwellInterface.decodeFunctionResult("underlying", returnData)[0];
+                case tokenType.ionic:
+                    return IonicInterface.decodeFunctionResult("underlying", returnData)[0];
+                case tokenType.layerbank:
+                    return LayerBankInterface.decodeFunctionResult("underlying", returnData)[0];
+                case tokenType.euler_borrow:
+                case tokenType.euler_lend:
+                    return EulerInterface.decodeFunctionResult("asset", returnData)[0];
+                default:
+                    throw new Error(`Need tokenType for this key ${key}, or type ${type} not matched`);
+            }
+        // case "exchangeRateCurrent":
+        //   return IonicInterface.decodeFunctionResult("exchangeRateCurrent", returnData)[0];
+        case "exchangeRate":
+            switch (type) {
+                case tokenType.pendle:
+                    return PendleInterface.decodeFunctionResult("exchangeRate", returnData)[0];
+                case tokenType.layerbank:
+                    return LayerBankInterface.decodeFunctionResult("exchangeRate", returnData)[0];
+                case tokenType.enzyme:
+                    return EnzymeInterface.decodeFunctionResult("calcNetShareValue", returnData)[1];
+                case tokenType.ionic:
+                    return IonicInterface.decodeFunctionResult("exchangeRateCurrent", returnData)[0];
+                case tokenType.moonwell:
+                    return MoonwellInterface.decodeFunctionResult("exchangeRateStored", returnData)[0];
+                default:
+                    throw new Error(`Need tokenType for this key ${key}`);
+            }
+        // case "exchangeRateStored":
+        //   return MoonwellInterface.decodeFunctionResult("exchangeRateStored", returnData)[0];
+        case "pricePerShare":
+            return FraxlendInterface.decodeFunctionResult("pricePerShare", returnData)[0];
+        case "collateralContract":
+            return SturdyInterface.decodeFunctionResult("collateralContract", returnData)[0];
+        case "lp_price":
+            switch (type) {
+                case tokenType.curve:
+                    return CurveInterface.decodeFunctionResult("lp_price", returnData)[0];
+                case tokenType.curve_2:
+                    return CurveInterface.decodeFunctionResult("get_virtual_price", returnData)[0];
+                default:
+                    throw new Error(`Need tokenType for this key ${key}`);
+            }
+        case "coin0":
+            return CurveInterface.decodeFunctionResult("coins", returnData)[0];
+        case "coin1":
+            return CurveInterface.decodeFunctionResult("coins", returnData)[0];
+        case "coin2":
+            return CurveInterface.decodeFunctionResult("coins", returnData)[0];
+        case "calcNetShareValue":
+            return [
+                EnzymeInterface.decodeFunctionResult("calcNetShareValue", returnData)[0],
+                EnzymeInterface.decodeFunctionResult("calcNetShareValue", returnData)[1],
+            ];
+        case "eVault":
+            return EulerInterface.decodeFunctionResult("eVault", returnData)[0];
+        case "getPricePerFullShare":
+            return BeefyInterface.decodeFunctionResult("getPricePerFullShare", returnData)[0];
+        case "want":
+            return BeefyInterface.decodeFunctionResult("want", returnData)[0];
+        case "getVault":
+            return BalancerPoolInterface.decodeFunctionResult("getVault", returnData)[0];
+        case "poolInfo":
+            return AuraOperatorInterface.decodeFunctionResult("poolInfo", returnData)[2];
+        case "staker":
+            return AuraOperatorInterface.decodeFunctionResult("staker", returnData)[0];
+        case "totalAssets":
+            switch (type) {
+                case tokenType.gearbox:
+                    return GearboxVaultInterface.decodeFunctionResult("totalAssets", returnData)[0];
+                case tokenType.euler_lend:
+                    return EulerInterface.decodeFunctionResult("totalAssets", returnData)[0];
+                case tokenType.euler_borrow:
+                    return EulerInterface.decodeFunctionResult("totalBorrows", returnData)[0];
+                case tokenType.compound:
+                    return CompoundInterface.decodeFunctionResult("totalBorrow", returnData)[0];
+                default:
+                    throw new Error(`Need tokenType for this key ${key}, or type ${type} not matched`);
+            }
+        case "getPoolTokens":
+            return [
+                BalancerVaultInterface.decodeFunctionResult("getPoolTokens", returnData)[0],
+                BalancerVaultInterface.decodeFunctionResult("getPoolTokens", returnData)[1],
+            ];
+        case "convertToAssets":
+            return FluidInterface.decodeFunctionResult("convertToAssets", returnData)[0];
+        case "tokenPrice":
+            return TorosInterface.decodeFunctionResult("tokenPrice", returnData)[0];
+        case "readTokens0":
+            return PendleInterface.decodeFunctionResult("readTokens", returnData)[0];
+        case "readTokens2":
+            return PendleInterface.decodeFunctionResult("readTokens", returnData)[2];
+        default:
+            throw new Error(`Key not recognized for ${key}`);
+    }
+}

package/dist/src/utils/encodeCalls.js

@@ -0,0 +1,240 @@
+import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
+import { AaveInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerVaultInterface, BeefyInterface, CompoundInterface, CurveInterface, ERC20Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, IonicInterface, LayerBankInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, RadiantInterface, RfxDatastoreInterface, SturdyInterface, TorosInterface, UniswapV2PoolInterface, } from "@sdk";
+import { fluidInterface } from "src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1";
+export function createCall(target, key, type, metaData) {
+    switch (key) {
+        case "collateralContract":
+            return { allowFailure: true, callData: SturdyInterface.encodeFunctionData("collateralContract"), target };
+        case "pricePerShare":
+            return { allowFailure: true, callData: FraxlendInterface.encodeFunctionData("pricePerShare"), target };
+        case "lp_price":
+            switch (type) {
+                case tokenType.curve:
+                    return { allowFailure: true, callData: CurveInterface.encodeFunctionData("lp_price"), target };
+                case tokenType.curve_2:
+                    return { allowFailure: true, callData: CurveInterface.encodeFunctionData("get_virtual_price"), target };
+                default:
+                    throw new Error(`Need tokenType for this key ${key}`);
+            }
+        case "coin0":
+            return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [0]), target };
+        case "coin1":
+            return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [1]), target };
+        case "coin2":
+            return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [2]), target };
+        case "operator":
+            return { allowFailure: true, callData: AuraInterface.encodeFunctionData("operator"), target };
+        case "pid":
+            return { allowFailure: true, callData: AuraInterface.encodeFunctionData("pid"), target };
+        case "lp_token":
+            return { allowFailure: true, callData: BalancerGaugeInterface.encodeFunctionData("lp_token"), target };
+        case "stakingToken":
+            return { allowFailure: true, callData: OneInchStakingInterface.encodeFunctionData("stakingToken"), target };
+        case "eVault":
+            return { allowFailure: true, callData: EulerInterface.encodeFunctionData("eVault"), target };
+        case "exchangeRate":
+            switch (type) {
+                case tokenType.pendle:
+                    return { allowFailure: true, callData: PendleInterface.encodeFunctionData("exchangeRate"), target };
+                case tokenType.ionic:
+                    return { allowFailure: true, callData: IonicInterface.encodeFunctionData("exchangeRateCurrent"), target };
+                case tokenType.moonwell:
+                    return { allowFailure: true, callData: MoonwellInterface.encodeFunctionData("exchangeRateStored"), target };
+                case tokenType.layerbank:
+                    return { allowFailure: true, callData: LayerBankInterface.encodeFunctionData("exchangeRate"), target };
+                default:
+                    throw new Error(`Need tokenType for this key ${key}`);
+            }
+        case "shortToken": {
+            return {
+                allowFailure: true,
+                callData: RfxDatastoreInterface.encodeFunctionData("getAddress", [metaData]),
+                target,
+            };
+        }
+        case "longToken": {
+            return {
+                allowFailure: true,
+                callData: RfxDatastoreInterface.encodeFunctionData("getAddress", [metaData]),
+                target,
+            };
+        }
+        case "underlying":
+            switch (type) {
+                case tokenType.pendle:
+                    return { allowFailure: true, callData: PendleInterface.encodeFunctionData("yieldToken"), target };
+                case tokenType.metamorpho:
+                    return { allowFailure: true, callData: MetamorphoInterface.encodeFunctionData("asset"), target };
+                case tokenType.fluid:
+                    return { allowFailure: true, callData: FluidInterface.encodeFunctionData("asset"), target };
+                case tokenType.euler_borrow:
+                case tokenType.euler_lend:
+                    return {
+                        allowFailure: true,
+                        callData: EulerInterface.encodeFunctionData("asset"),
+                        target,
+                    };
+                case tokenType.fraxlend:
+                case tokenType.sturdy_aggregator:
+                case tokenType.sturdy_silo:
+                    return { allowFailure: true, callData: FraxlendInterface.encodeFunctionData("asset"), target };
+                case tokenType.gearbox:
+                    return {
+                        allowFailure: true,
+                        callData: GearboxVaultInterface.encodeFunctionData("underlyingToken"),
+                        target,
+                    };
+                case tokenType.aura:
+                    return { allowFailure: true, callData: AuraInterface.encodeFunctionData("asset"), target };
+                case tokenType.ionic:
+                    return { allowFailure: true, callData: IonicInterface.encodeFunctionData("underlying"), target };
+                case tokenType.layerbank:
+                    return { allowFailure: true, callData: LayerBankInterface.encodeFunctionData("underlying"), target };
+                case tokenType.moonwell:
+                    return { allowFailure: true, callData: MoonwellInterface.encodeFunctionData("underlying"), target };
+                case tokenType.radiant_lend:
+                case tokenType.radiant_borrow:
+                    return {
+                        allowFailure: true,
+                        callData: RadiantInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
+                        target,
+                    };
+                case tokenType.aave_lending:
+                case tokenType.aave_borrowing:
+                case tokenType.ironclad_lending:
+                case tokenType.ironclad_borrowing:
+                case tokenType.zerolend_lending:
+                case tokenType.zerolend_borrowing:
+                case tokenType.yei_borrowing:
+                case tokenType.yei_lending:
+                    return { allowFailure: true, callData: AaveInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"), target };
+                default:
+                    throw new Error(`Need tokenType for this key ${key}, or unknown type ${type}`);
+            }
+        case "calcNetShareValue":
+            return {
+                allowFailure: true,
+                callData: EnzymeInterface.encodeFunctionData("calcNetShareValue", [metaData]),
+                target,
+            };
+        case "getPricePerFullShare":
+            return { allowFailure: true, callData: BeefyInterface.encodeFunctionData("getPricePerFullShare"), target };
+        case "token0":
+            return { allowFailure: true, callData: UniswapV2PoolInterface.encodeFunctionData("token0"), target };
+        case "token1":
+            return { allowFailure: true, callData: UniswapV2PoolInterface.encodeFunctionData("token1"), target };
+        case "baseToken":
+            return { allowFailure: true, callData: CompoundInterface.encodeFunctionData("baseToken"), target };
+        case "factory":
+            return { allowFailure: true, callData: FactoryInterface.encodeFunctionData("factory"), target };
+        case "getAssetPrice":
+            return { allowFailure: true, callData: RadiantInterface.encodeFunctionData("getAssetPrice"), target };
+        case "want":
+            return { allowFailure: true, callData: BeefyInterface.encodeFunctionData("want"), target };
+        case "symbol":
+            return {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("symbol"),
+                target,
+            };
+        case "decimals":
+            return {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("decimals"),
+                target,
+            };
+        case "totalSupply":
+            return {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                target,
+            };
+        case "balanceOf":
+            return {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("balanceOf", [metaData]),
+                target,
+            };
+        case "getPoolId":
+            return {
+                allowFailure: true,
+                callData: BalancerPoolInterface.encodeFunctionData("getPoolId"),
+                target,
+            };
+        case "getVault":
+            return {
+                allowFailure: true,
+                callData: BalancerPoolInterface.encodeFunctionData("getVault"),
+                target,
+            };
+        case "poolInfo":
+            return {
+                allowFailure: true,
+                callData: AuraOperatorInterface.encodeFunctionData("poolInfo", [metaData]),
+                target,
+            };
+        case "staker":
+            return { allowFailure: true, callData: AuraOperatorInterface.encodeFunctionData("staker"), target };
+        case "getPoolTokens":
+            return {
+                allowFailure: true,
+                callData: BalancerVaultInterface.encodeFunctionData("getPoolTokens", [metaData]),
+                target,
+            };
+        case "convertToAssets":
+            return {
+                allowFailure: true,
+                callData: fluidInterface.encodeFunctionData("convertToAssets", [metaData]),
+                target,
+            };
+        case "tokenPrice":
+            return {
+                allowFailure: true,
+                callData: TorosInterface.encodeFunctionData("tokenPrice"),
+                target,
+            };
+        case "totalAssets":
+            switch (type) {
+                case tokenType.euler_borrow:
+                    return {
+                        allowFailure: true,
+                        callData: EulerInterface.encodeFunctionData("totalBorrows"),
+                        target,
+                    };
+                case tokenType.euler_lend:
+                    return {
+                        allowFailure: true,
+                        callData: EulerInterface.encodeFunctionData("totalAssets"),
+                        target,
+                    };
+                case tokenType.gearbox:
+                    return {
+                        allowFailure: true,
+                        callData: GearboxVaultInterface.encodeFunctionData("totalAssets"),
+                        target,
+                    };
+                case tokenType.compound:
+                    return {
+                        allowFailure: true,
+                        callData: CompoundInterface.encodeFunctionData("totalBorrow"),
+                        target: target,
+                    };
+                default:
+                    throw new Error(`Need tokenType for this key ${key}, or unknown type ${type}`);
+            }
+        case "readTokens0":
+            return {
+                allowFailure: true,
+                callData: PendleInterface.encodeFunctionData("readTokens"),
+                target: target,
+            };
+        case "readTokens2":
+            return {
+                allowFailure: true,
+                callData: PendleInterface.encodeFunctionData("readTokens"),
+                target: target,
+            };
+        default:
+            throw new Error(`Unknown key ${key}`);
+    }
+}