@merkl/api 0.10.128 → 0.10.130

package/dist/src/libs/campaigns/campaignTypes/MORPHODynamicData.js

@@ -0,0 +1,120 @@
+import { BN2Number, MorphoSubCampaignType, YEAR, } from "@sdk";
+import { Pricer } from "../../../utils/pricer";
+const axios = require("axios");
+export async function MORPHODynamicData(chainId, campaigns) {
+    const pricer = await Pricer.load();
+    const calls = [];
+    const endpoint = "https://blue-api.morpho.org/graphql";
+    const headers = {
+        "content-type": "application/json",
+    };
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const dynamicData = [];
+                for (const campaign of campaigns) {
+                    const priceRewardToken = (await pricer.get({
+                        address: campaign.rewardToken,
+                        chainId,
+                        symbol: campaign.campaignParameters.symbolRewardToken,
+                    })) ?? 0;
+                    let tvl = 0;
+                    let totalSupplyTargetToken = 0;
+                    if (campaign.campaignSubType === MorphoSubCampaignType.META) {
+                        const graphqlQueryVaults = {
+                            query: `query VaultByAddress($address: String!, $chainId: Int) {
+              vaultByAddress(address: $address, chainId: $chainId) {
+                state {
+                  totalAssetsUsd
+                  totalAssets
+                  totalSupply
+                }
+              }
+            }
+            `,
+                            variables: {
+                                address: campaign.campaignParameters.targetToken,
+                                chainId: campaign.computeChainId,
+                            },
+                        };
+                        try {
+                            const response = await axios({
+                                url: endpoint,
+                                method: "post",
+                                headers: headers,
+                                data: graphqlQueryVaults,
+                            });
+                            tvl = response.data.data.vaultByAddress.state.totalAssetsUsd;
+                            totalSupplyTargetToken = response.data.data.vaultByAddress.state.totalAssets;
+                        }
+                        catch (e) {
+                            console.log(e);
+                        }
+                    }
+                    if (campaign.campaignSubType === MorphoSubCampaignType.SUPPLY_BLUE ||
+                        campaign.campaignSubType === MorphoSubCampaignType.BORROWING_BLUE ||
+                        campaign.campaignSubType === MorphoSubCampaignType.COLLATERAL_BLUE) {
+                        const graphqlQueryMarket = {
+                            query: `query MarketByUniqueKey($uniqueKey: String!, $chainId: Int) {
+              marketByUniqueKey(uniqueKey: $uniqueKey, chainId: $chainId) {
+                state {
+                  borrowAssetsUsd
+                  borrowAssets
+                  collateralAssets
+                  collateralAssetsUsd
+                  supplyAssets
+                  supplyAssetsUsd
+                }
+              }
+            }
+            `,
+                            variables: {
+                                uniqueKey: campaign.campaignParameters.marketId,
+                                chainId: campaign.computeChainId,
+                            },
+                        };
+                        try {
+                            const response = await axios({
+                                url: endpoint,
+                                method: "post",
+                                headers: headers,
+                                data: graphqlQueryMarket,
+                            });
+                            if (campaign.campaignSubType === MorphoSubCampaignType.SUPPLY_BLUE) {
+                                tvl = response.data.data.marketByUniqueKey.state.supplyAssetsUsd;
+                                totalSupplyTargetToken = response.data.data.marketByUniqueKey.state.supplyAssets;
+                            }
+                            if (campaign.campaignSubType === MorphoSubCampaignType.BORROWING_BLUE) {
+                                tvl = response.data.data.marketByUniqueKey.state.borrowAssetsUsd;
+                                totalSupplyTargetToken = response.data.data.marketByUniqueKey.state.borrowAssets;
+                            }
+                            if (campaign.campaignSubType === MorphoSubCampaignType.COLLATERAL_BLUE) {
+                                tvl = response.data.data.marketByUniqueKey.state.collateralAssetsUsd;
+                                totalSupplyTargetToken = response.data.data.marketByUniqueKey.state.collateralAssets;
+                            }
+                        }
+                        catch (e) {
+                            console.log(e);
+                        }
+                    }
+                    dynamicData.push({
+                        ...campaign,
+                        apr: (priceRewardToken *
+                            BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                            YEAR *
+                            100) /
+                            campaign.campaignParameters.duration /
+                            tvl,
+                        totalSupplyTargetToken,
+                        tvl: tvl,
+                        priceRewardToken: priceRewardToken,
+                    });
+                }
+                return dynamicData;
+            },
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignTypes/RadiantDynamicData.js

@@ -0,0 +1,112 @@
+import { engineDbClient } from "../../../utils/prisma";
+import { BN2Number, ERC20Interface, NULL_ADDRESS, RadiantPoolInterface, YEAR, } from "@sdk";
+import { Contract } from "ethers";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+import { providers } from "../../../utils/providers";
+import { merklChainDataWithCache } from "../../merklChainData";
+import { getLastEligibilityRatio } from "../utils/getLastEligibilityRatio";
+import { radiantInterface } from "./ERC20SubTypes/subtypesRound1";
+export async function RadiantDynamicData(chainId, campaigns) {
+    const pricer = await Pricer.load();
+    const calls = [];
+    const currentRoot = (await merklChainDataWithCache(chainId)).merkleRoot;
+    for (const campaign of campaigns) {
+        calls.push({
+            allowFailure: true,
+            callData: ERC20Interface.encodeFunctionData("totalSupply"),
+            target: campaign.campaignParameters.targetToken,
+        });
+        calls.push({
+            allowFailure: true,
+            callData: RadiantPoolInterface.encodeFunctionData("getRizRegistry"),
+            target: campaign.campaignParameters.poolAddressProvider ?? NULL_ADDRESS,
+        });
+        calls.push({
+            allowFailure: true,
+            callData: radiantInterface.encodeFunctionData("getAssetPrice"),
+            target: campaign.campaignParameters.targetToken,
+        });
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                let i = 0;
+                const dynamicData = [];
+                for (const campaign of campaigns) {
+                    let totalSupplyTargetToken;
+                    try {
+                        totalSupplyTargetToken = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[i++])[0], campaign.campaignParameters.decimalsTargetToken);
+                    }
+                    catch {
+                        log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and token ${campaign.campaignParameters.targetToken}`);
+                        totalSupplyTargetToken = 0.0000001;
+                    }
+                    const backupCampaignIds = (await engineDbClient.campaigns.findMany({
+                        select: {
+                            campaignId: true,
+                            campaignParameters: true,
+                            endTimestamp: true,
+                        },
+                        where: {
+                            chainId: chainId,
+                            mainParameter: campaign.mainParameter,
+                        },
+                    }))
+                        .filter(c => c.campaignParameters?.symbolRewardToken === "mtwRDNT")
+                        .sort((a, b) => b.endTimestamp - a.endTimestamp)
+                        .map(c => c?.campaignId);
+                    const lastEligibilityRatio = await getLastEligibilityRatio(campaign, chainId, currentRoot, backupCampaignIds);
+                    const priceRewardToken = (await pricer.get({
+                        address: campaign.rewardToken,
+                        chainId,
+                        symbol: campaign.campaignParameters.symbolRewardToken,
+                    })) ?? 0;
+                    let priceDecimals = 8;
+                    let rizRegistry = "";
+                    try {
+                        rizRegistry = RadiantPoolInterface.decodeFunctionResult("getRizRegistry", result[i])[0];
+                        const isRiz = await new Contract(rizRegistry, RadiantPoolInterface, providers[chainId]).isLendingPoolValid(campaign.campaignParameters.pool);
+                        if (isRiz)
+                            priceDecimals = 18;
+                    }
+                    catch {
+                        // If it is doesn't work it means it's not a Radiant Innovation Zone Market
+                    }
+                    i++;
+                    let priceTargetToken = 0;
+                    try {
+                        priceTargetToken = BN2Number(radiantInterface.decodeFunctionResult("getAssetPrice", result[i])[0], priceDecimals);
+                    }
+                    catch (e) {
+                        log.local("Error getting priceTargetToken");
+                        priceTargetToken =
+                            (await pricer.get({
+                                symbol: campaign.campaignParameters.symbolTargetToken,
+                                address: campaign.campaignParameters.targetToken,
+                            })) ?? 0;
+                    }
+                    i++;
+                    dynamicData.push({
+                        ...campaign,
+                        apr: (lastEligibilityRatio *
+                            priceRewardToken *
+                            BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                            YEAR *
+                            100) /
+                            campaign.campaignParameters.duration /
+                            (totalSupplyTargetToken * priceTargetToken),
+                        totalSupplyTargetToken,
+                        tvl: totalSupplyTargetToken * priceTargetToken,
+                        lastEligibilityRatio,
+                        priceRewardToken: priceRewardToken,
+                    });
+                }
+                return dynamicData;
+            },
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignTypes/SILODynamicData.js

@@ -0,0 +1,113 @@
+import { BN2Number, ERC20Interface, Forwarder, YEAR, } from "@sdk";
+import { utils } from "ethers";
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+const SILO_ABI = [
+    "function getAssets() view returns (address[])",
+    "function assetStorage(address) external view returns (address,address,address,uint256,uint256,uint256)",
+    "function siloAsset() view returns (address)",
+];
+export const SILO_INTERFACE = new utils.Interface(SILO_ABI);
+export async function SILODynamicData(chainId, campaigns) {
+    const pricer = await Pricer.load();
+    const siloAssetsCalls = [];
+    for (const campaign of campaigns) {
+        if (campaign.campaignParameters.whitelist.length === 1) {
+            siloAssetsCalls.push({
+                allowFailure: true,
+                callData: SILO_INTERFACE.encodeFunctionData("siloAsset"),
+                target: campaign.campaignParameters.whitelist[0],
+            });
+        }
+    }
+    const siloAssetsCallsResults = await batchMulticallCallWithRetry(chainId, {
+        calls: siloAssetsCalls,
+    });
+    const calls = [];
+    let i = 0;
+    for (const campaign of campaigns) {
+        for (const forwarder of campaign.campaignParameters.forwarders) {
+            if (forwarder.forwarderType === Forwarder.ERC20) {
+                calls.push({
+                    allowFailure: true,
+                    callData: SILO_INTERFACE.encodeFunctionData("assetStorage", [campaign.campaignParameters.targetToken]),
+                    target: forwarder.sender,
+                });
+                if (campaign.campaignParameters.whitelist.length === 1) {
+                    const siloAsset = SILO_INTERFACE.decodeFunctionResult("siloAsset", siloAssetsCallsResults[i].returnData)[0];
+                    calls.push({
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("symbol"),
+                        target: siloAsset,
+                    });
+                }
+            }
+        }
+        if (campaign.campaignParameters.whitelist.length === 1) {
+            i++;
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                let i = 0;
+                let j = 0;
+                const dynamicData = [];
+                for (const campaign of campaigns) {
+                    const priceRewardToken = (await pricer.get({
+                        address: campaign.rewardToken,
+                        chainId,
+                        symbol: campaign.campaignParameters.symbolRewardToken,
+                    })) ?? 0;
+                    const priceTargetToken = (await pricer.get({
+                        address: campaign.campaignParameters.targetToken,
+                        chainId,
+                        symbol: campaign.campaignParameters.symbolTargetToken,
+                    })) ?? 0;
+                    let totalSupplyTargetToken = 0;
+                    for (const _forwarder of campaign.campaignParameters.forwarders) {
+                        if (_forwarder.forwarderType === Forwarder.ERC20) {
+                            try {
+                                totalSupplyTargetToken += BN2Number(SILO_INTERFACE.decodeFunctionResult("assetStorage", result[i])[3 + campaign.campaignSubType], campaign.campaignParameters.decimalsTargetToken);
+                                i++;
+                            }
+                            catch (e) {
+                                log.local(`Issue with ${_forwarder.sender} on ${campaign.campaignParameters.targetToken}`);
+                                i++;
+                            }
+                            if (campaign.campaignParameters.whitelist.length === 1) {
+                                const siloAsset = SILO_INTERFACE.decodeFunctionResult("siloAsset", siloAssetsCallsResults[j].returnData)[0];
+                                const siloAssetSymbol = ERC20Interface.decodeFunctionResult("symbol", result[i++])[0];
+                                // @BaptistG not sure to get this
+                                campaign.campaignParameters.forwarders[0].siloAsset = siloAsset;
+                                campaign.campaignParameters.forwarders[0].siloAssetSymbol = siloAssetSymbol;
+                            }
+                        }
+                    }
+                    if (campaign.campaignParameters.whitelist.length === 1) {
+                        j++;
+                    }
+                    // Remove all silo forwarders
+                    campaign.campaignParameters.forwarders = campaign.campaignParameters.forwarders.filter(forwarder => forwarder.forwarderType !== Forwarder.SILO);
+                    dynamicData.push({
+                        ...campaign,
+                        apr: (priceRewardToken *
+                            BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                            YEAR *
+                            100) /
+                            campaign.campaignParameters.duration /
+                            (totalSupplyTargetToken * priceTargetToken),
+                        totalSupplyTargetToken,
+                        tvl: totalSupplyTargetToken * priceTargetToken,
+                        priceRewardToken: priceRewardToken,
+                    });
+                }
+                return dynamicData;
+            },
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignsDynamicData.js

@@ -0,0 +1,83 @@
+import { log } from "../../utils/logger";
+import { engineDbClient } from "../../utils/prisma";
+import { Campaign } from "@sdk";
+import { getAddress } from "ethers/lib/utils";
+import { AjnaDynamicData } from "./campaignTypes/AjnaDynamicData";
+import { BadgerDynamicData } from "./campaignTypes/BadgerDynamicData";
+import { CLAMMDynamicData } from "./campaignTypes/CLAMMDynamicData";
+import { CompoundDynamicData } from "./campaignTypes/CompoundDynamicData";
+import { DolomiteDynamicData } from "./campaignTypes/DolomiteDynamicData";
+import { ERC20DynamicData } from "./campaignTypes/ERC20DynamicData";
+import { ERC20DynamicDataRefacto } from "./campaignTypes/ERC20DynamicDataRefacto";
+import { ERC20_SNAPSHOTDynamicData } from "./campaignTypes/ERC20_SNAPSHOTDynamicData";
+import { EulerDynamicData } from "./campaignTypes/EulerDynamicData";
+import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData";
+import { MORPHODynamicData } from "./campaignTypes/MORPHODynamicData";
+import { RadiantDynamicData } from "./campaignTypes/RadiantDynamicData";
+import { SILODynamicData } from "./campaignTypes/SILODynamicData";
+export async function campaignsDynamicData(chainId, campaigns, type) {
+    try {
+        const tags = (await engineDbClient.campaignCreators.findMany()).reduce((acc, curr) => {
+            acc[getAddress(curr.address)] = curr.tags.split(",");
+            return acc;
+        }, {});
+        for (const campaign of campaigns) {
+            campaign.tags = tags[getAddress(campaign.creator)] || [];
+        }
+    }
+    catch (_err) {
+        log.warn("No tags assigned to creator address in database");
+    }
+    switch (type) {
+        case Campaign.ERC20: {
+            const switchRefacto = process.env.SWITCH_REFACTO_SUBTYPES_ERC20 !== undefined ? process.env.SWITCH_REFACTO_SUBTYPES_ERC20 : false;
+            if (switchRefacto) {
+                return ERC20DynamicDataRefacto(chainId, campaigns);
+            }
+            return ERC20DynamicData(chainId, campaigns);
+        }
+        case Campaign.CLAMM: {
+            return CLAMMDynamicData(chainId, campaigns);
+        }
+        case Campaign.ERC20_SNAPSHOT: {
+            return ERC20_SNAPSHOTDynamicData(chainId, campaigns);
+        }
+        case Campaign.JSON_AIRDROP: {
+            return JSON_AIRDROPDynamicData(chainId, campaigns);
+        }
+        case Campaign.SILO: {
+            return SILODynamicData(chainId, campaigns);
+        }
+        case Campaign.RADIANT: {
+            return RadiantDynamicData(chainId, campaigns);
+        }
+        case Campaign.MORPHO: {
+            return MORPHODynamicData(chainId, campaigns);
+        }
+        case Campaign.EULER: {
+            return EulerDynamicData(chainId, campaigns);
+        }
+        case Campaign.DOLOMITE: {
+            return DolomiteDynamicData(chainId, campaigns);
+        }
+        case Campaign.BADGER: {
+            return BadgerDynamicData(chainId, campaigns);
+        }
+        case Campaign.AJNA: {
+            return AjnaDynamicData(chainId, campaigns);
+        }
+        case Campaign.COMPOUND: {
+            return CompoundDynamicData(chainId, campaigns);
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: [],
+            handler: () => { },
+            reducer: async (_) => {
+                return campaigns;
+            },
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignsDynamicDataRefacto.js

@@ -0,0 +1,78 @@
+import { engineDbClient } from "../../utils/prisma";
+import { Campaign } from "@sdk";
+import { getAddress } from "ethers/lib/utils";
+import { log } from "../../utils/logger";
+import { AjnaDynamicData } from "./campaignTypes/AjnaDynamicData";
+import { BadgerDynamicData } from "./campaignTypes/BadgerDynamicData";
+import { CLAMMDynamicData } from "./campaignTypes/CLAMMDynamicData";
+import { CompoundDynamicData } from "./campaignTypes/CompoundDynamicData";
+import { DolomiteDynamicData } from "./campaignTypes/DolomiteDynamicData";
+import { ERC20DynamicDataRefacto } from "./campaignTypes/ERC20DynamicDataRefacto";
+import { ERC20_SNAPSHOTDynamicData } from "./campaignTypes/ERC20_SNAPSHOTDynamicData";
+import { EulerDynamicData } from "./campaignTypes/EulerDynamicData";
+import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData";
+import { MORPHODynamicData } from "./campaignTypes/MORPHODynamicData";
+import { RadiantDynamicData } from "./campaignTypes/RadiantDynamicData";
+import { SILODynamicData } from "./campaignTypes/SILODynamicData";
+export async function campaignsDynamicDataRefacto(chainId, campaigns, type, nextVersion = false) {
+    try {
+        const tags = (await engineDbClient.campaignCreators.findMany()).reduce((acc, curr) => {
+            acc[getAddress(curr.address)] = curr.tags.split(",");
+            return acc;
+        }, {});
+        for (const campaign of campaigns) {
+            campaign.tags = tags[getAddress(campaign.creator)] || [];
+        }
+    }
+    catch (e) {
+        log.warn("No tags assigned to creator address in database");
+    }
+    switch (type) {
+        case Campaign.ERC20: {
+            return ERC20DynamicDataRefacto(chainId, campaigns);
+        }
+        case Campaign.CLAMM: {
+            return CLAMMDynamicData(chainId, campaigns);
+        }
+        case Campaign.ERC20_SNAPSHOT: {
+            return ERC20_SNAPSHOTDynamicData(chainId, campaigns);
+        }
+        case Campaign.JSON_AIRDROP: {
+            return JSON_AIRDROPDynamicData(chainId, campaigns);
+        }
+        case Campaign.SILO: {
+            return SILODynamicData(chainId, campaigns);
+        }
+        case Campaign.RADIANT: {
+            return RadiantDynamicData(chainId, campaigns);
+        }
+        case Campaign.MORPHO: {
+            return MORPHODynamicData(chainId, campaigns);
+        }
+        case Campaign.EULER: {
+            return EulerDynamicData(chainId, campaigns);
+        }
+        case Campaign.DOLOMITE: {
+            return DolomiteDynamicData(chainId, campaigns);
+        }
+        case Campaign.BADGER: {
+            return BadgerDynamicData(chainId, campaigns);
+        }
+        case Campaign.AJNA: {
+            return AjnaDynamicData(chainId, campaigns);
+        }
+        case Campaign.COMPOUND: {
+            return CompoundDynamicData(chainId, campaigns);
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: [],
+            handler: () => { },
+            reducer: async (_) => {
+                return campaigns;
+            },
+        },
+    };
+}

package/dist/src/libs/campaigns/getCampaigns.js

@@ -0,0 +1,18 @@
+import { engineDbClient } from "../../utils/prisma";
+import { ACTIVE_CAMPAIGNS, ACTIVE_CAMPAIGNS_FOR_CHAIN } from "../../utils/queries/activeCampaigns";
+export async function getCampaigns(chainId) {
+    let campaigns = [];
+    const now = Math.floor(Date.now() / 1000);
+    if (chainId === 0) {
+        campaigns = await engineDbClient.$queryRaw(ACTIVE_CAMPAIGNS(now));
+    }
+    else {
+        campaigns = await engineDbClient.$queryRaw(ACTIVE_CAMPAIGNS_FOR_CHAIN(chainId, now));
+    }
+    // Group the campaigns by their campaignType
+    const groupedCampaigns = campaigns.reduce((r, a) => {
+        r[a.campaignType] = [...(r[a.campaignType] || []), a];
+        return r;
+    }, {});
+    return groupedCampaigns;
+}

package/dist/src/libs/campaigns/utils/fetchA51Strategies.js

@@ -0,0 +1,44 @@
+import { ALM, NETWORK_LABELS, merklSubgraphALMEndpoints, withTimeout } from "@sdk";
+import { gql, request } from "graphql-request";
+import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "../../../constants";
+import { log } from "../../../utils/logger";
+const A51StrategiesQuery = gql `
+  query Strategies($pool_in: [String]) {
+    strategies: strategies(where: { pool_in: $pool_in }, first: 1000) {
+        pool
+        vault
+        id
+        tickLower
+        tickUpper
+    }
+  }
+`;
+export async function fetchA51Strategies(chainId, pools) {
+    const tgURL = merklSubgraphALMEndpoints[chainId][ALM.A51];
+    const res = {};
+    if (!!tgURL && tgURL !== "") {
+        await withTimeout(request(tgURL, A51StrategiesQuery, {
+            pool_in: pools,
+        }), MERKL_USER_POSITION_FETCHING_TIMEOUT)
+            .then(fetchedData => {
+            for (const strategy of fetchedData.strategies) {
+                const pool = strategy.pool.toLowerCase();
+                const vault = strategy.vault.toLowerCase();
+                if (!res[pool])
+                    res[pool] = {};
+                if (!res[pool][vault])
+                    res[pool][vault] = [];
+                res[pool][vault].push({
+                    id: strategy.id,
+                    tickLower: strategy.tickLower,
+                    tickUpper: strategy.tickUpper,
+                });
+            }
+        })
+            .catch(error => {
+            const service = `Merkl ALM Subgraph for ${NETWORK_LABELS[chainId]} A51`;
+            log.error(service, error, service, tgURL);
+        });
+    }
+    return res;
+}

package/dist/src/libs/campaigns/utils/fetchClamInfo.js

@@ -0,0 +1,27 @@
+export async function fetchClamInfo(campaigns) {
+    // split the campaigns by chainId and pool
+    const campaignsByChainIdAndPool = {};
+    // mainParameter is the pool for CLAMs
+    campaigns.forEach(campaign => {
+        const { chainId, mainParameter } = campaign;
+        if (!campaignsByChainIdAndPool[chainId]) {
+            campaignsByChainIdAndPool[chainId] = {};
+        }
+        if (!campaignsByChainIdAndPool[chainId][mainParameter]) {
+            campaignsByChainIdAndPool[chainId][mainParameter] = [];
+        }
+        campaignsByChainIdAndPool[chainId][mainParameter].push(campaign);
+    });
+    // Get the raw pool info for each chain
+    // Get the ALM positions for each pool
+    // BalanceOf Token0
+    // BalanceOf Token1
+    // Price Token0 --> from prices
+    // Price Token1 --> from prices
+    // What I need
+    // Pool
+    // TVL token0
+    // TVL token1
+    // ALM Positions (ALM ID --> address + amount)
+    // Get the
+}