@merkl/api 0.9.15

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

@@ -0,0 +1,61 @@
+import { PriceSourceMethod } from "@db/api";
+import axios from "axios";
+import { log } from "../../logger";
+export default class CoingeckoService {
+    static instance = new CoingeckoService();
+    constructor() { }
+    baseUrl = "https://coins.llama.fi/prices/current/";
+    async getPrice(tickers) {
+        const filteredTokens = tickers.filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.COINGECKO);
+        if (filteredTokens.length === 0)
+            return [];
+        return await this.fetchPrices(filteredTokens);
+    }
+    buildUrl(tokens) {
+        const tikerParams = tokens
+            .map(token => {
+            const args = token.args;
+            if (!args?.ticker)
+                return log.warn(`❌ CoingeckoService ticker not found for ${token.symbol}`);
+            return `coingecko:${args.ticker}`;
+        })
+            .join(",");
+        return this.baseUrl.concat(tikerParams);
+    }
+    async fetchPrices(tickers) {
+        const chunkSize = 200;
+        const chunks = [];
+        for (let i = 0; i < tickers.length; i += chunkSize) {
+            chunks.push(tickers.slice(i, Math.min(tickers.length, i + chunkSize)));
+        }
+        const promises = (await Promise.all(chunks.map(async (chunk) => {
+            const url = this.buildUrl(chunk);
+            return axios
+                .get(url, { timeout: 10000 })
+                .then(res => this.formatResponse(res, chunk))
+                .catch(err => {
+                log.error("❌ CoingeckoService not responding", err);
+                throw "❌ CoingeckoService not responding";
+            });
+        }))).filter(result => !!result);
+        return promises.reduce((acc, val) => acc.concat(val), []);
+    }
+    // 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?.ticker)
+                return;
+            if (!data.data.coins[`coingecko:${args.ticker}`]?.price) {
+                log.warn(`❌ CoinGecko data failed for ${token.symbol} with ticker ${args.ticker}`);
+                return;
+            }
+            return {
+                token: token.symbol,
+                rate: data.data.coins[`coingecko:${args.ticker}`].price ?? -1,
+            };
+        })
+            .filter(item => !!item);
+    }
+}

package/dist/src/utils/prices/services/defillamaService.d.ts

@@ -0,0 +1,12 @@
+import { type PriceSource } from "@db/api";
+import type PriceFetcher from "./priceFetcher";
+import type { ResponsePriceType } from "./priceFetcher";
+export default class DefillamaService implements PriceFetcher {
+    static readonly instance: DefillamaService;
+    private constructor();
+    private baseUrl;
+    getPrice(sources: PriceSource[]): Promise<ResponsePriceType[]>;
+    private buildUrl;
+    private fetchPrices;
+    private formatResponse;
+}

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

@@ -0,0 +1,53 @@
+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.d.ts

@@ -0,0 +1,12 @@
+import { type PriceSource } from "@db/api";
+import type PriceFetcher from "./priceFetcher";
+import type { ResponsePriceType } from "./priceFetcher";
+export default class DexScreenerService implements PriceFetcher {
+    static readonly instance: PriceFetcher;
+    private baseUrl;
+    private constructor();
+    getPrice(tokens: PriceSource[]): Promise<ResponsePriceType[]>;
+    private getTokenByChain;
+    /** @description Create a list by chain dexscreener only supports one chain at a time */
+    private fetchPrices;
+}

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

@@ -0,0 +1,62 @@
+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.d.ts

@@ -0,0 +1,9 @@
+import { type PriceSource } from "@db/api";
+import type PriceFetcher from "./priceFetcher";
+import type { ResponsePriceType } from "./priceFetcher";
+export default class ERC4626Service implements PriceFetcher {
+    static readonly instance: PriceFetcher;
+    private constructor();
+    getPrice(tokens: PriceSource[]): Promise<ResponsePriceType[]>;
+    private priceCalculation;
+}

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

@@ -0,0 +1,38 @@
+import { PriceService } from "@/modules/v4/price";
+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.d.ts

@@ -0,0 +1,4 @@
+import { type ChainId } from "@sdk";
+type ReturnType = number;
+export declare function getERC4626Price(chainId: ChainId, contractAddress: string, assetDecimals?: number, vaultDecimals?: number): Promise<ReturnType>;
+export {};

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

@@ -0,0 +1,11 @@
+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.d.ts

@@ -0,0 +1,12 @@
+import { type PriceSource } from "@db/api";
+import type PriceFetcher from "./priceFetcher";
+import type { ResponsePriceType } from "./priceFetcher";
+export default class IndexCoop implements PriceFetcher {
+    static readonly instance: IndexCoop;
+    private baseUrl;
+    private constructor();
+    getPrice(tokens: PriceSource[]): Promise<ResponsePriceType[]>;
+    private getTokenByChain;
+    private fetchPrice;
+    private buildUrl;
+}

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

@@ -0,0 +1,55 @@
+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.d.ts

@@ -0,0 +1,8 @@
+import type { PriceSource } from "@db/api";
+export default interface PriceFetcher {
+    getPrice(tickers: PriceSource[]): Promise<ResponsePriceType[]>;
+}
+export type ResponsePriceType = {
+    token: string;
+    rate: number;
+};

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

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

package/dist/src/utils/prices/uniV2Price.d.ts

@@ -0,0 +1,7 @@
+import { type ChainId } from "@sdk";
+type ReturnType = number;
+export declare function getCurveV2Price(chainId: ChainId, prices: {
+    [t: string]: number;
+}, pool: string, token: string): Promise<ReturnType>;
+export declare function getUniV2Price(chainId: ChainId, priceToken0: number, priceToken1: number, poolAddress: string): Promise<ReturnType>;
+export {};

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

@@ -0,0 +1,40 @@
+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.d.ts

@@ -0,0 +1,13 @@
+import { type ethers } from "ethers";
+export declare const providers: {
+    [x: string]: ethers.providers.StaticJsonRpcProvider | ethers.providers.InfuraProvider;
+};
+export declare const archiveProviders: {
+    [x: string]: ethers.providers.StaticJsonRpcProvider | ethers.providers.InfuraProvider;
+};
+export declare const multicalls: {
+    [chainId: number]: Multicall;
+};
+export declare const archiveMulticalls: {
+    [chainId: number]: Multicall;
+};

package/dist/src/utils/providers.js

@@ -0,0 +1,37 @@
+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.d.ts

@@ -0,0 +1,2 @@
+import { Prisma } from "@db/engine";
+export declare const ALL_CAMPAIGNS_FOR_CHAIN_AFTER: (chainId: number, after: number) => Prisma.Sql;

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

@@ -0,0 +1,12 @@
+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/stryke.d.ts

@@ -0,0 +1,2 @@
+import { AMM } from "@sdk";
+export declare function isStrykeCampaign(amm: AMM): boolean;

package/dist/src/utils/stryke.js

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

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

@@ -0,0 +1,21 @@
+import { type ChainId } from "@sdk";
+/**
+ * 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 declare const throwOnInvalidRequiredAddress: (address: string) => string;
+/**
+ * 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 declare const throwOnInvalidAddress: (address: string | undefined) => string | undefined;
+/**
+ * Use this function to throw an error if the chainId is not supported by Merkl
+ */
+export declare const throwOnUnsupportedChainId: (chainId: ChainId) => void;

package/dist/src/utils/throw.js

@@ -0,0 +1,44 @@
+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);
+};