@merkl/api 0.9.15

package/dist/src/types/external/spectraAPI.d.ts

@@ -0,0 +1,88 @@
+export interface SpectraPoolData {
+    address: string;
+    chainId: number;
+    lpt: {
+        address: string;
+        decimals: number;
+        chainId: number;
+        supply: string;
+    };
+    liquidity: {
+        underlying: number;
+        usd: number;
+    };
+    impliedApy: number;
+    lpApy: {
+        total: number;
+        details: {
+            fees: number;
+            pt: number;
+            ibt: number;
+        };
+    };
+    ibtToPt: string;
+    ptToIbt: string;
+    ptPrice: {
+        underlying: number;
+        usd: number;
+    };
+    ytPrice: {
+        underlying: number;
+        usd: number;
+    };
+    ibtAmount: string;
+    ptAmount: string;
+    feeRate: string;
+    outFee: string;
+    midFee: string;
+    lastPrices: string;
+}
+export interface SpectraObject {
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    chainId: number;
+    rate: string;
+    yt: {
+        address: string;
+        decimals: number;
+        chainId: number;
+    };
+    ibt: {
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        chainId: number;
+        rate: string;
+        apr: {
+            total: number;
+            details: {
+                base: number;
+            };
+        };
+        price: {
+            underlying: number;
+            usd: number;
+        };
+        protocol: string;
+    };
+    underlying: {
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        chainId: number;
+        price: {
+            usd: number;
+        };
+    };
+    maturity: number;
+    createdAt: number;
+    pools: SpectraPoolData[];
+    maturityValue: {
+        underlying: number;
+        usd: number;
+    };
+}

package/dist/src/types/external/spectraAPI.js

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

package/dist/src/types/index.d.ts

@@ -0,0 +1,20 @@
+import type { BytesLike } from "ethers";
+export type MultiCallDataType = {
+    target: string;
+    callData: BytesLike;
+    allowFailure?: boolean;
+}[];
+export type MerklChainData = {
+    merkleRoot: string;
+    treeRoot: string;
+    lastTreeRoot: string;
+    endOfDisputePeriod: number;
+    disputeLive: boolean;
+    message: string;
+    validRewardTokens: {
+        token: string;
+        minimumAmountPerEpoch: number;
+        decimals: number;
+        symbol: string;
+    }[];
+};

package/dist/src/types/index.js

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

package/dist/src/types/returnTypes.d.ts

@@ -0,0 +1,19 @@
+export type OverviewReturnType = {
+    disputes: {
+        [chainId: number]: {
+            root: string;
+            endOfDisputePeriod: number;
+            disputeLive: boolean;
+            treeRoot: string;
+            lastTreeRoot: string;
+        };
+    };
+    rewardTokens: {
+        [chainId: number]: {
+            token: string;
+            minimumAmountPerEpoch: number;
+            decimals: number;
+            symbol: string;
+        }[];
+    };
+};

package/dist/src/types/returnTypes.js

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

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

@@ -0,0 +1,5 @@
+import type { ChainId } from "@sdk";
+export type PerChain<T> = {
+    [Chain in ChainId]?: T;
+};
+export type Stringable = string | number | bigint | boolean | null | undefined;

package/dist/src/types/utils.js

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

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

@@ -0,0 +1 @@
+export default function bigintToString(obj: unknown | unknown[]): unknown | unknown[];

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/caseChanges.d.ts

@@ -0,0 +1,3 @@
+export declare function camelToKebabCase(str: string): string;
+export declare function kebabToCamelCase(str: string): string;
+export declare function kebabToPascalCase(str: string): string;

package/dist/src/utils/caseChanges.js

@@ -0,0 +1,12 @@
+export function camelToKebabCase(str) {
+    return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+export function kebabToCamelCase(str) {
+    return str.replace(/-./g, match => match[1].toUpperCase());
+}
+export function kebabToPascalCase(str) {
+    return str
+        .split("-")
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join("");
+}

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

@@ -0,0 +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;

package/dist/src/utils/decodeCalls.js

@@ -0,0 +1,306 @@
+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, VePufferInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
+export function decodeCall(calls, index, key, type) {
+    const returnData = calls[index];
+    return decodeReturnValue(returnData, key, type);
+}
+export function decodeReturnValue(returnData, key, type) {
+    switch (key) {
+        case "tokens":
+            return LPManagerInterface.decodeFunctionResult("tokens", returnData)[0];
+        case "getTokensCount":
+            return LPManagerInterface.decodeFunctionResult("getTokensCount", returnData)[0];
+        case "getTotalValue":
+            return LPManagerHelperInterface.decodeFunctionResult("getTotalValue", returnData)[0];
+        case "domain":
+            return CurveStableSwapNGInterface.decodeFunctionResult("DOMAIN_SEPARATOR", returnData)[0];
+        case "SY":
+            return PendleYTInterface.decodeFunctionResult("SY", returnData)[0];
+        case "symbol":
+            return ERC20Interface.decodeFunctionResult("symbol", returnData)[0];
+        case "decimals":
+            return ERC20Interface.decodeFunctionResult("decimals", returnData)[0];
+        case "totalSupply":
+            switch (type) {
+                case tokenType.lendle_lending:
+                case tokenType.lendle_borrowing:
+                    return LendleInterface.decodeFunctionResult("scaledTotalSupply", returnData)[0];
+                default:
+                    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 "owner":
+            return LayerBankERC20Interface.decodeFunctionResult("owner", returnData)[0];
+        case "token0":
+            return UniswapV2PoolInterface.decodeFunctionResult("token0", returnData)[0];
+        case "token1":
+            return UniswapV2PoolInterface.decodeFunctionResult("token1", returnData)[0];
+        case "lp_token":
+            switch (type) {
+                case tokenType.beraborrow_gauge:
+                case tokenType.beratrax_vault:
+                    return ERC4626Interface.decodeFunctionResult("asset", returnData)[0];
+                default:
+                    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:
+                case tokenType.pendleYT:
+                    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.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:
+                    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:
+                case tokenType.venus:
+                    return IonicInterface.decodeFunctionResult("underlying", returnData)[0];
+                case tokenType.reactor_fusion:
+                    try {
+                        return IonicInterface.decodeFunctionResult("underlying", returnData)[0];
+                    }
+                    catch (e) {
+                        return "0x000000000000000000000000000000000000800A";
+                    }
+                case tokenType.layerbank:
+                    return LayerBankInterface.decodeFunctionResult("underlying", returnData)[0];
+                case tokenType.holdstation:
+                    return DefutureVaultInterface.decodeFunctionResult("asset", returnData)[0];
+                case tokenType.euler_borrow:
+                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`);
+            }
+        // 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:
+                case tokenType.venus:
+                case tokenType.reactor_fusion:
+                    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:
+                case tokenType.maha:
+                    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 "N_COINS":
+            try {
+                return CurveStableSwapNGInterface.decodeFunctionResult("N_COINS", returnData)[0];
+            }
+            catch (e) {
+                return 2;
+            }
+        case "balances":
+            return CurveStableSwapNGInterface.decodeFunctionResult("balances", 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.anglesLiquid:
+                case tokenType.cian:
+                case tokenType.rfx_slv:
+                case tokenType.beratrax_vault:
+                case tokenType.beraborrow_gauge:
+                case tokenType.metamorpho:
+                    return ERC4626Interface.decodeFunctionResult("totalAssets", returnData)[0];
+                case tokenType.concrete:
+                    return ERC4626Interface.decodeFunctionResult("totalAssets", returnData)[0];
+                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];
+        case "boostedPositionInformation":
+            return MaverickBPLensInterface.decodeFunctionResult("boostedPositionInformation", returnData)[0];
+        case "coins":
+            return ZFStableSwapThreePoolInterface.decodeFunctionResult("coins", returnData)[0];
+        case "minter":
+            switch (type) {
+                case tokenType.spectra_lpt:
+                    return CurveLPTokenInterface.decodeFunctionResult("minter", returnData)[0];
+                default:
+                    return ZFStableLPINterface.decodeFunctionResult("minter", returnData)[0];
+            }
+        case "principalToken":
+            return SpectraYTInterface.decodeFunctionResult("getPT", returnData)[0];
+        case "getTokenAddresses":
+            switch (type) {
+                case tokenType.tempestStaking: {
+                    return RswEthStrategyInterface.decodeFunctionResult("getTokenAddresses", returnData)[0];
+                }
+                default:
+                    return SymetricAmbientStrategyInterface.decodeFunctionResult("getTokenAddresses", returnData)[0];
+            }
+        case "getPositions":
+            switch (type) {
+                case tokenType.tempestStaking: {
+                    return RswEthStrategyInterface.decodeFunctionResult("getPositions", returnData);
+                }
+                default:
+                    return SymetricAmbientStrategyInterface.decodeFunctionResult("getPositions", returnData);
+            }
+        case "lockNFT":
+            return VePufferInterface.decodeFunctionResult("lockNFT", returnData)[0];
+        case "tvl":
+            return DefutureVaultInterface.decodeFunctionResult("tvl", returnData)[0];
+        case "eip712DomainName":
+            return MetamorphoInterface.decodeFunctionResult("eip712Domain", returnData)[1];
+        case "getRate":
+            return AccountantWithRateProvidersInterface.decodeFunctionResult("getRate", returnData)[0];
+        case "base":
+            return AccountantWithRateProvidersInterface.decodeFunctionResult("base", returnData)[0];
+        case "tokensRaw":
+            return [
+                CPMMGammaPoolMainInterface.decodeFunctionResult("tokens", returnData)[0][0],
+                CPMMGammaPoolMainInterface.decodeFunctionResult("tokens", returnData)[0][1],
+            ];
+        case "tokenBalances":
+            return CPMMGammaPoolMainInterface.decodeFunctionResult("getLatestCFMMBalances", returnData)[0];
+        case "reserve0":
+            return SyncSwapClassicPoolInterface.decodeFunctionResult("reserve0", returnData)[0];
+        case "reserve1":
+            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);
+        case "hub":
+            return BunniV2TokenInterface.decodeFunctionResult("hub", returnData)[0];
+        case "poolKey":
+            return BunniV2TokenInterface.decodeFunctionResult("poolKey", returnData)[0];
+        case "poolState":
+            return BunniV2HubInterface.decodeFunctionResult("poolState", returnData)[0];
+        default:
+            throw new Error(`Key not recognized for ${key}`);
+    }
+}

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

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