@merkl/api 0.21.46 → 1.0.0

package/dist/src/utils/prices/services/defillamaService.js

@@ -1,53 +0,0 @@
-import { PriceSourceMethod } from "@db/api";
-import axios from "axios";
-import { log } from "../../logger";
-export default class DefillamaService {
-    static instance = new DefillamaService();
-    constructor() { }
-    baseUrl = "https://coins.llama.fi/prices/current/";
-    async getPrice(sources) {
-        const filteredTokens = sources.filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.DEFILLAMA);
-        if (filteredTokens.length === 0)
-            return [];
-        return await this.fetchPrices(filteredTokens);
-    }
-    buildUrl(tokens) {
-        const tikerParams = tokens
-            .map(token => {
-            const args = token.args;
-            if (!args?.address || !args?.chain)
-                return log.warn(`❌ DefillamaService address not found for ${token.symbol}`);
-            return `${args?.chain}:${args.address}`;
-        })
-            .join(",");
-        return this.baseUrl.concat(tikerParams);
-    }
-    async fetchPrices(sources) {
-        const url = this.buildUrl(sources);
-        return axios
-            .get(url, { timeout: 10000 })
-            .then(res => this.formatResponse(res, sources))
-            .catch(err => {
-            log.error("❌ DefillamaService not responding", err);
-            throw "❌ DefillamaService not responding";
-        });
-    }
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation> Need to be typed according to coinguekko answer type
-    formatResponse(data, tokens) {
-        return tokens
-            .map(token => {
-            const args = token.args;
-            if (!args?.address || !args?.chain)
-                return undefined;
-            if (!data.data.coins[`${args?.chain}:${args.address}`]?.price) {
-                log.warn(`❌ DefillamaService data failed for ${token.symbol} with address ${args.address}`);
-                return undefined;
-            }
-            return {
-                token: token.symbol,
-                rate: data.data.coins[`${args?.chain}:${args.address}`].price ?? -1,
-            };
-        })
-            .filter(item => !!item);
-    }
-}

package/dist/src/utils/prices/services/dexScreenerService.js

@@ -1,62 +0,0 @@
-import { PriceSourceMethod } from "@db/api";
-import axios from "axios";
-import { log } from "../../logger";
-export default class DexScreenerService {
-    static instance = new DexScreenerService();
-    baseUrl = "https://api.dexscreener.com/latest/dex/pairs/";
-    constructor() { }
-    async getPrice(tokens) {
-        const filteredTokens = tokens.filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.DEXSCREENER);
-        if (filteredTokens.length === 0)
-            return [];
-        const tokensByChain = this.getTokenByChain(filteredTokens); // supports only one chain at a time
-        if (tokensByChain === undefined)
-            return [];
-        return this.fetchPrices(tokensByChain);
-    }
-    getTokenByChain(tokens) {
-        const tokensByChain = {};
-        for (const token of tokens) {
-            const args = token.args;
-            if (args?.chain && args?.pair) {
-                const chain = args.chain.toLowerCase();
-                const pair = args.pair;
-                // Initialize array if it doesn't exist for the chain
-                if (!tokensByChain[chain])
-                    tokensByChain[chain] = [];
-                tokensByChain[chain].push(pair);
-            }
-            else
-                log.warn(`⚠️ DexScrenner Invalid token args: ${JSON.stringify(token.args)}`);
-        }
-        return tokensByChain;
-    }
-    /** @description Create a list by chain dexscreener only supports one chain at a time */
-    async fetchPrices(tokensByChain) {
-        // let tickerCallResult: AxiosResponse;
-        const res = [];
-        const fetchPromises = Object.entries(tokensByChain).map(async ([chain, pairs]) => {
-            const url = `${this.baseUrl}${chain.toLowerCase()}/${pairs.join(",")}`;
-            try {
-                const { data } = await axios.get(url, {
-                    timeout: 10000,
-                });
-                if (!data.pairs) {
-                    log.warn(`⚠️ DexScrenner No pairs found in the response for chain ${chain}`);
-                    return [];
-                }
-                return data.pairs.map((pair) => ({
-                    rate: Number.parseFloat(pair.priceUsd),
-                    token: pair.baseToken.symbol,
-                }));
-            }
-            catch (error) {
-                log.error(`❌ DexScreener error fetching prices for chain ${chain}:`, error);
-                return [];
-            }
-        });
-        const results = await Promise.all(fetchPromises);
-        results.forEach(result => res.push(...result));
-        return res;
-    }
-}

package/dist/src/utils/prices/services/erc4626Service.js

@@ -1,38 +0,0 @@
-import { PriceService } from "@/modules/v4/price/price.service";
-import { PriceSourceMethod } from "@db/api";
-import { log } from "../../logger";
-import { getERC4626Price } from "./getERC4626";
-export default class ERC4626Service {
-    static instance = new ERC4626Service();
-    constructor() { }
-    async getPrice(tokens) {
-        const pricePromises = tokens
-            .filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.ERC4626)
-            .map(async (token) => {
-            const args = token.args;
-            if (!args?.chainId || !args.address || !args.vaultToken) {
-                log.warn(`❌ ERC4626Service ticker not found for ${token.symbol}`);
-                return undefined;
-            }
-            const rate = await getERC4626Price(args.chainId, args.address, args.decimals, args.vaultDecimals);
-            // 2 returned tokens as stUSD and STUSD (business requirement)
-            const price = await this.priceCalculation(rate, args.vaultToken);
-            const res = [
-                { token: token.symbol, rate: price },
-                { token: token.symbol.toUpperCase(), rate: price },
-            ];
-            return res;
-        });
-        const resolvedPrices = (await Promise.all(pricePromises)).filter(result => !!result);
-        return resolvedPrices.flat();
-    }
-    async priceCalculation(rate, vaultToken) {
-        try {
-            const vaultTokenPrice = await PriceService.fetchPriceBySymbol(vaultToken);
-            return rate * vaultTokenPrice;
-        }
-        catch {
-            return Number.NaN;
-        }
-    }
-}

package/dist/src/utils/prices/services/getERC4626.js

@@ -1,11 +0,0 @@
-import { BN2Number } from "@sdk";
-import { Contract, utils } from "ethers";
-import { log } from "../../logger";
-import { providers } from "../../providers";
-export async function getERC4626Price(chainId, contractAddress, assetDecimals = 18, vaultDecimals = 18) {
-    const contract = new Contract(contractAddress, ["function convertToAssets(uint256) external view returns(uint256)"], providers[chainId]);
-    const assetAmount = await contract.convertToAssets(utils.parseUnits("1", vaultDecimals));
-    if (!assetAmount || Number.isNaN(assetAmount))
-        log.error("❌ ERC4626Service convertToAssets failed for address:", contractAddress);
-    return BN2Number(assetAmount, assetDecimals);
-}

package/dist/src/utils/prices/services/indexCoopService.js

@@ -1,55 +0,0 @@
-import { PriceSourceMethod } from "@db/api";
-import axios from "axios";
-import { log } from "../../logger";
-export default class IndexCoop {
-    static instance = new IndexCoop();
-    baseUrl = "https://api.indexcoop.com/";
-    constructor() { }
-    async getPrice(tokens) {
-        const filteredTokens = tokens.filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.INDEXCOOP);
-        if (filteredTokens.length === 0)
-            return [];
-        const tokensByChain = this.getTokenByChain(filteredTokens);
-        if (tokensByChain === undefined)
-            return [];
-        return this.fetchPrice(tokensByChain);
-    }
-    getTokenByChain(tokens) {
-        const tokensByChain = {};
-        for (const token of tokens) {
-            // Ensure `args` has the expected structure
-            const args = token.args;
-            if (args?.chainId !== undefined) {
-                // Initialize array if it doesn't exist for the chain
-                if (!tokensByChain[args.chainId])
-                    tokensByChain[args.chainId] = [];
-                tokensByChain[args.chainId].push(token.symbol);
-            }
-            else
-                log.warn(`⚠️ IndexCoop invalid token args: ${JSON.stringify(token.args)}`);
-        }
-        return tokensByChain;
-    }
-    async fetchPrice(tokensByChain) {
-        const res = [];
-        const fetchPromises = Object.entries(tokensByChain).flatMap(([chain, pairs]) => pairs.map(async (symbol) => {
-            const indexCoopUrl = this.buildUrl(chain, symbol);
-            try {
-                const { data } = await axios.get(indexCoopUrl, {
-                    timeout: 10000,
-                });
-                res.push({ rate: Number.parseFloat(data.nav), token: symbol });
-            }
-            catch (e) {
-                log.error(`❌ IndexCoop not responding for chain ${chain}`, e);
-            }
-        }));
-        await Promise.all(fetchPromises);
-        return res;
-    }
-    buildUrl(chainId, symbol) {
-        return chainId !== "0"
-            ? `${this.baseUrl}${chainId}/${symbol.toLowerCase()}/nav`
-            : `${this.baseUrl}${symbol.toLowerCase()}/nav`;
-    }
-}

package/dist/src/utils/prices/services/priceFetcher.js

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

package/dist/src/utils/prices/uniV2Price.js

@@ -1,40 +0,0 @@
-import { BN2Number, Stable, UniswapV2PoolInterface } from "@sdk";
-import { Contract } from "ethers";
-import { multicalls, providers } from "../providers";
-export async function getCurveV2Price(chainId, prices, pool, token) {
-    const abi = [
-        "function balances(uint256) external view returns(uint256)",
-        "function totalSupply() external view returns(uint256)",
-        "function token() external view returns(address)",
-    ];
-    const contract = new Contract(pool, abi, providers[chainId]);
-    const tokenContract = new Contract(token, abi, providers[chainId]);
-    return ((BN2Number(await contract.balances(0)) * prices["FRAX"] +
-        BN2Number(await contract.balances(1)) * prices[Stable.EUR]) /
-        BN2Number(await tokenContract.totalSupply()));
-}
-export async function getUniV2Price(chainId, priceToken0, priceToken1, poolAddress) {
-    const [, result] = await multicalls[chainId].callStatic.aggregate([
-        {
-            callData: UniswapV2PoolInterface.encodeFunctionData("getReserves"),
-            target: poolAddress,
-        },
-        {
-            callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
-            target: poolAddress,
-        },
-        {
-            callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
-            target: poolAddress,
-        },
-        {
-            callData: UniswapV2PoolInterface.encodeFunctionData("totalSupply"),
-            target: poolAddress,
-        },
-    ]);
-    const [reserve0, reserve1] = UniswapV2PoolInterface.decodeFunctionResult("getReserves", result[0]);
-    const _token0 = UniswapV2PoolInterface.decodeFunctionResult("token0", result[1])[0];
-    const _token1 = UniswapV2PoolInterface.decodeFunctionResult("token1", result[2])[0];
-    const totalSupply = UniswapV2PoolInterface.decodeFunctionResult("token1", result[3])[0];
-    return (BN2Number(reserve0) * priceToken0 + BN2Number(reserve1) * priceToken1) / BN2Number(totalSupply);
-}

package/dist/src/utils/providers.js

@@ -1,37 +0,0 @@
-import { ChainId, MULTICALL_ADDRESS, Multicall__factory } from "@sdk";
-import { providers as p } from "ethers";
-const getProviders = () => {
-    let parsedProviders = undefined;
-    if (!!process.env.PROVIDERS)
-        parsedProviders = JSON.parse(process.env.PROVIDERS);
-    const providers = Object.keys(ChainId).reduce((prev, chainId) => {
-        const url = !!parsedProviders ? parsedProviders[chainId] : process.env?.[`PROVIDER_${chainId}`];
-        if (!!url)
-            prev[chainId] = new p.StaticJsonRpcProvider(url);
-        return prev;
-    }, {});
-    return providers;
-};
-export const providers = getProviders();
-export const archiveProviders = Object.keys(ChainId).reduce((prev, chainId) => {
-    const url = !!process.env?.[`PROVIDER_ARCHIVE_${chainId}`]
-        ? process.env?.[`PROVIDER_ARCHIVE_${chainId}`]
-        : process.env?.[`PROVIDER_${chainId}`];
-    if (!!url)
-        prev[chainId] = new p.StaticJsonRpcProvider(url);
-    return prev;
-}, {});
-export const multicalls = Object.keys(ChainId).reduce((prev, chainId) => {
-    if (!!providers[chainId])
-        prev[chainId] = Multicall__factory.connect(MULTICALL_ADDRESS(chainId), providers[chainId]);
-    // else {
-    // if (Number.parseInt(chainId).toString() === chainId)
-    // log.warn(`No provider found for chain ${NETWORK_LABELS[chainId as unknown as ChainId]}`);
-    // }
-    return prev;
-}, {});
-export const archiveMulticalls = Object.keys(ChainId).reduce((prev, chainId) => {
-    if (!!archiveProviders[chainId])
-        prev[chainId] = Multicall__factory.connect("0xcA11bde05977b3631167028862bE2a173976CA11", archiveProviders[chainId]);
-    return prev;
-}, {});

package/dist/src/utils/queries/allCampaigns.js

@@ -1,12 +0,0 @@
-import { Prisma } from "@db/engine";
-export const ALL_CAMPAIGNS_FOR_CHAIN_AFTER = (chainId, after) => Prisma.sql `
-    SELECT
-        *
-    FROM "Campaigns"
-    WHERE
-        (("chainId" = ${chainId} AND "computeChainId" = 0) OR "computeChainId" = ${chainId}) AND
-        "campaignType" != 0 AND
-        "endTimestamp" >= ${after} AND
-        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
-        
-    `;

package/dist/src/utils/sanitizeChain.js

@@ -1,6 +0,0 @@
-import { ChainId, NETWORK_LABELS } from "@sdk";
-export const sanitizeChainName = (computeChainId) => {
-    return computeChainId === ChainId.MAINNET
-        ? "ethereum"
-        : NETWORK_LABELS[computeChainId]?.toLowerCase().replaceAll(" ", "");
-};

package/dist/src/utils/stryke.js

@@ -1,4 +0,0 @@
-import { AMM } from "@sdk";
-export function isStrykeCampaign(amm) {
-    return [AMM.Stryke, AMM.StrykePCS, AMM.StrykeSushi].includes(amm);
-}

package/dist/src/utils/throw.js

@@ -1,55 +0,0 @@
-import { OpportunityAction } from "@db/api";
-import { isSupportedChain } from "@sdk";
-import { utils } from "ethers";
-import { InvalidParameter, UnsupportedNetwork } from "./error";
-/**
- * Use this function to throw an error if the address is invalid
- * and normalize the address to its checksum version
- *
- * @dev Usage: params.address = throwOnInvalidAddress(params.address);
- */
-export const throwOnInvalidRequiredAddress = (address) => {
-    try {
-        if (!address)
-            throw new InvalidParameter("Address is required");
-        return utils.getAddress(address?.toLowerCase());
-    }
-    catch (_) {
-        throw new InvalidParameter(`Address ${address} is invalid`);
-    }
-};
-/**
- * Use this function to throw an error if the address is invalid
- * and normalize the address to its checksum version
- *
- * Address can be null or undefined
- *
- * @dev Usage: params.address = throwOnInvalidAddress(params.address);
- */
-export const throwOnInvalidAddress = (address) => {
-    try {
-        if (!address)
-            return;
-        return utils.getAddress(address?.toLowerCase());
-    }
-    catch (_) {
-        throw new InvalidParameter(`Address ${address} is invalid`);
-    }
-};
-/**
- * Use this function to throw an error if the chainId is not supported by Merkl
- */
-export const throwOnUnsupportedChainId = (chainId) => {
-    if (chainId && !isSupportedChain(chainId, "merkl"))
-        throw new UnsupportedNetwork(chainId);
-};
-export const throwOnUnsupportedActionList = (actionList) => {
-    if (!!actionList) {
-        const actions = actionList.split(",");
-        for (const action of actions) {
-            if (!Object.values(OpportunityAction).includes(action)) {
-                throw new Error(`Invalid action: ${action}`);
-            }
-        }
-    }
-};