@merkl/api 0.19.6 → 0.19.8

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

@@ -1,265 +0,0 @@
-import { BucketService } from "@/modules/v4/bucket/bucket.service";
-import { engineDbClient } from "@db";
-import { BN2Number, ChainInteractionService, EAprBreakdownType, NETWORK_LABELS, UniswapV4Addresses, UniswapV4StateViewInterface, getSqrtRatioAtTick, shortenAddress, } from "@sdk";
-import moment from "moment";
-import { log } from "../../../utils/logger";
-import { Pricer } from "../../../utils/pricer";
-// Constants
-const CALLS_LENGTH = 2;
-/**
- * Compute TVL
- * @dev important: using the most recent state save with current prices
- *      it's only an estimate
- */
-async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID, priceCurrency0, priceCurrency1, decimalsCurrency0, decimalsCurrency1) {
-    let stateSave;
-    let blockNumber;
-    let states = {};
-    try {
-        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
-        const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
-            where: {
-                id: `UniswapV4_${chainId}_${poolID}`,
-                blockNumber: {
-                    lte: currentBlock,
-                },
-            },
-            orderBy: {
-                blockNumber: "desc",
-            },
-        });
-        stateSave = mostRecentStateSave.state;
-        blockNumber = mostRecentStateSave?.blockNumber;
-        states = stateSave.states;
-        // const globalState = stateSave.globalState as { tick: number; liquidity: string };
-    }
-    catch (e) {
-        log.warn(`merklDynamic data - failed to read a recent state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
-    }
-    const { fileName, bucketName } = states;
-    // Bucket service
-    let tvl = 0;
-    let amount0 = 0;
-    let amount1 = 0;
-    try {
-        const bucket = new BucketService(bucketName, "merkl-production");
-        const storedStates = JSON.parse(await bucket.pull(fileName));
-        for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
-            amount0 += BN2Number(value.amount0, decimalsCurrency0);
-            amount1 += BN2Number(value.amount1, decimalsCurrency1);
-        }
-        tvl = amount0 * (priceCurrency0 ?? 0) + amount1 * (priceCurrency1 ?? 0);
-    }
-    catch (e) {
-        console.log(e);
-        log.warn(`merklDynamic data - failed to decode state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
-    }
-    return { tvl, amount0, amount1, blockNumber: blockNumber };
-}
-export async function UniswapV4DynamicData(chainId, campaigns) {
-    const dynamicData = [];
-    const pricer = await Pricer.load();
-    const calls = [];
-    /** Dedupe pools from campaigns to build pool list */
-    const poolList = [];
-    for (const campaign of campaigns ?? []) {
-        /** Loop through all campaigns to add pools */
-        if (!poolList?.map(p => p.mainParameter.toLowerCase()).includes(campaign.mainParameter.toLowerCase())) {
-            poolList.push({
-                poolId: campaign.campaignParameters.poolId,
-                mainParameter: campaign.mainParameter, // FIXME
-            });
-        }
-    }
-    if (!!poolList) {
-        for (const pool of poolList) {
-            calls.push({
-                allowFailure: true,
-                callData: UniswapV4StateViewInterface.encodeFunctionData("getLiquidity", [pool.poolId]),
-                target: UniswapV4Addresses[chainId].StateView,
-            }, {
-                allowFailure: true,
-                callData: UniswapV4StateViewInterface.encodeFunctionData("getSlot0", [pool.poolId]),
-                target: UniswapV4Addresses[chainId].StateView,
-            });
-        }
-        return {
-            cached: false,
-            call: {
-                callData: calls,
-                handler: () => { },
-                reducer: async (result) => {
-                    let i = 0;
-                    if (!!poolList) {
-                        for (const pool of poolList) {
-                            // This liquidity call gives the active liquidity on the pool. To get the total liquidity we would need to loop over all positions
-                            let poolTotalLiquidity;
-                            let sqrtPrice;
-                            let tick;
-                            let poolBalanceToken0 = 0;
-                            let poolBalanceToken1 = 0;
-                            const campaignsForPool = campaigns?.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase());
-                            const prevI = i;
-                            try {
-                                poolTotalLiquidity = UniswapV4StateViewInterface.decodeFunctionResult("getLiquidity", result[i++])[0].toString();
-                                const poolData = UniswapV4StateViewInterface.decodeFunctionResult("getSlot0", result[i++]);
-                                tick = poolData.tick;
-                                sqrtPrice = getSqrtRatioAtTick(tick).toString();
-                            }
-                            catch {
-                                log.warn(`merklDynamic data - failed to decode state of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
-                                i = prevI + CALLS_LENGTH;
-                                continue;
-                            }
-                            const decimalsCurrency0 = campaignsForPool[0].campaignParameters.decimalsCurrency0;
-                            const decimalsCurrency1 = campaignsForPool[0].campaignParameters.decimalsCurrency1;
-                            const symbolCurrency0 = campaignsForPool[0].campaignParameters.symbolCurrency0;
-                            const symbolCurrency1 = campaignsForPool[0].campaignParameters.symbolCurrency1;
-                            const priceToken0 = (await pricer.get({
-                                address: campaignsForPool[0].campaignParameters.currency0,
-                                chainId: chainId,
-                                symbol: symbolCurrency0,
-                            }));
-                            const priceToken1 = (await pricer.get({
-                                address: campaignsForPool[0].campaignParameters.currency1,
-                                chainId: chainId,
-                                symbol: symbolCurrency1,
-                            }));
-                            const { tvl, amount0, amount1, blockNumber } = await computeUniV4PoolTVLFromMostRecentStateSave(chainId, pool.poolId, priceToken0, priceToken1, decimalsCurrency0, decimalsCurrency1);
-                            poolBalanceToken0 += amount0;
-                            poolBalanceToken1 += amount1;
-                            /** Iterate over distributions to compute APRs */
-                            for (const campaign of campaignsForPool) {
-                                const c = campaign;
-                                const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
-                                const startTimestamp = BN2Number(c.startTimestamp, 0);
-                                const endTimestamp = BN2Number(c.endTimestamp, 0);
-                                const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
-                                const totalWeight = BN2Number(c.campaignParameters.weightFees, 4) +
-                                    BN2Number(c.campaignParameters.weightToken0, 4) +
-                                    BN2Number(c.campaignParameters.weightToken1, 4);
-                                // Proportions in percentage
-                                const propFees = (BN2Number(c.campaignParameters.weightFees, 4) / totalWeight) * 100;
-                                const propToken0 = (BN2Number(c.campaignParameters.weightToken0, 4) / totalWeight) * 100;
-                                const propToken1 = (BN2Number(c.campaignParameters.weightToken1, 4) / totalWeight) * 100;
-                                let distributionMeanAPR = 0;
-                                const blacklistedBalance0 = 0;
-                                const blacklistedBalance1 = 0;
-                                const blacklistedLiquidity = 0;
-                                const aprs = {};
-                                const aprBreakdowns = [];
-                                let priceRewardToken = 0;
-                                if (isLive && c.campaignParameters.symbolRewardToken !== "aglaMerkl") {
-                                    priceRewardToken = (await pricer.get({
-                                        address: c.rewardToken,
-                                        chainId: chainId,
-                                        symbol: c.campaignParameters.symbolRewardToken,
-                                    }));
-                                    /**
-                                     * Handle whitelisted/blacklisted addresses to compute APR
-                                     */
-                                    if (c.campaignParameters.whitelist.length > 0) {
-                                        // TODO
-                                    }
-                                    else if (c.campaignParameters.blacklist.length > 0) {
-                                        // TODO
-                                    }
-                                    /** Yearly rewards in $ */
-                                    const yearlyToken0Rewards = (propToken0 * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
-                                    const yearlyToken1Rewards = (propToken1 * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
-                                    const yearlyFeeRewards = (propFees * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
-                                    let poolAPRkey = "";
-                                    /**
-                                     * General APR (@notice potentially with a boost)
-                                     */
-                                    const poolBalanceToken0WithoutBlacklist = poolBalanceToken0;
-                                    const poolBalanceToken1WithoutBlacklist = poolBalanceToken1;
-                                    //   const poolLiquidityWithoutBlacklist = poolTotalLiquidity - (blacklistedLiquidity ?? 0);
-                                    const tvl = poolBalanceToken0WithoutBlacklist * priceToken0 + poolBalanceToken1WithoutBlacklist * priceToken1;
-                                    distributionMeanAPR = (yearlyToken0Rewards + yearlyToken1Rewards + yearlyFeeRewards) / tvl;
-                                    distributionMeanAPR =
-                                        !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
-                                    /**
-                                     * @dev We cannot include a whitelisted distrib apr into the mean APR
-                                     */
-                                    if (c.campaignParameters.whitelist.length === 0) {
-                                        poolAPRkey = "Average APR (rewards / pool TVL)";
-                                        if (!aprs[poolAPRkey])
-                                            aprs[poolAPRkey] = 0;
-                                        aprs[poolAPRkey] += distributionMeanAPR;
-                                        // @Hugo wip: new way to structure aprBreakdowns
-                                        aprBreakdowns.push({
-                                            address: pool.poolId,
-                                            value: distributionMeanAPR,
-                                            type: EAprBreakdownType.AVERAGE,
-                                            label: "Average APR (rewards / pool TVL)",
-                                        });
-                                        // APR per token
-                                        poolAPRkey = `APR for holding ${c.campaignParameters.symbolCurrency0} in pool`;
-                                        if (!aprs[poolAPRkey])
-                                            aprs[poolAPRkey] = 0;
-                                        aprs[poolAPRkey] += yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0);
-                                        // @Hugo wip: new way to structure aprBreakdowns
-                                        aprBreakdowns.push({
-                                            address: pool.poolId,
-                                            value: yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0),
-                                            type: EAprBreakdownType.TOKEN1,
-                                            label: c.campaignParameters.symbolCurrency0,
-                                        });
-                                        poolAPRkey = `APR for holding  ${c.campaignParameters.symbolCurrency1} in pool`;
-                                        if (!aprs[poolAPRkey])
-                                            aprs[poolAPRkey] = 0;
-                                        aprs[poolAPRkey] += yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1);
-                                        // @Hugo wip: new way to structure aprBreakdowns
-                                        aprBreakdowns.push({
-                                            address: pool.poolId,
-                                            value: yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1),
-                                            type: EAprBreakdownType.TOKEN2,
-                                            label: c.campaignParameters.symbolCurrency1,
-                                        });
-                                    }
-                                    else {
-                                        for (const _ of c.campaignParameters.whitelist) {
-                                            const poolAPRkey = `Whitelisted campaign on UniswapV4 via address ${shortenAddress(c.campaignParameters.whitelist[0])} Average APR`;
-                                            if (!aprs[poolAPRkey])
-                                                aprs[poolAPRkey] = 0;
-                                        }
-                                        aprs[poolAPRkey] += distributionMeanAPR;
-                                    }
-                                }
-                                dynamicData.push({
-                                    ...campaign,
-                                    apr: distributionMeanAPR,
-                                    aprs,
-                                    aprBreakdowns,
-                                    blacklistedBalance0,
-                                    blacklistedBalance1,
-                                    blacklistedLiquidity,
-                                    poolBalanceToken0,
-                                    poolBalanceToken1,
-                                    poolTotalLiquidity,
-                                    sqrtPrice,
-                                    tick: tick,
-                                    priceRewardToken: priceRewardToken,
-                                    tvl: poolBalanceToken0 * priceToken0 + poolBalanceToken1 * priceToken1,
-                                });
-                            }
-                        }
-                    }
-                    return dynamicData;
-                },
-            },
-        };
-    }
-    // Fallback in case something fails
-    return {
-        cached: false,
-        call: {
-            callData: [],
-            handler: () => { },
-            reducer: async (_result) => {
-                return campaigns;
-            },
-        },
-    };
-}

package/dist/src/libs/campaigns/campaignTypes/VestDynamicData.d.ts

@@ -1,5 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-export declare const VEST_TREASURY = "0x7ccF5BbeC69c790D27dA3b5398B9e0d6D6EeC9F3";
-export declare const VEST_TOKEN = "0x3355df6D4c9C3035724Fd0e3914dE96A5a83aaf4";
-export declare function VestDynamicData(_chainId: MerklChainId, campaigns: CampaignParameters<Campaign.VEST>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.VEST>[]>>>;

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

@@ -1,61 +0,0 @@
-import { BN2Number, ERC20Interface, YEAR, } from "@sdk";
-import { log } from "../../../utils/logger";
-import { Pricer } from "../../../utils/pricer";
-export const VEST_TREASURY = "0x7ccF5BbeC69c790D27dA3b5398B9e0d6D6EeC9F3";
-export const VEST_TOKEN = "0x3355df6D4c9C3035724Fd0e3914dE96A5a83aaf4";
-export async function VestDynamicData(_chainId, campaigns) {
-    const pricer = await Pricer.load();
-    const calls = [];
-    for (const campaign of campaigns) {
-        calls.push({
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("balanceOf", [VEST_TREASURY]),
-            target: VEST_TOKEN,
-        });
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                let i = 0;
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    let totalSupply;
-                    try {
-                        totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i++])[0], 6);
-                    }
-                    catch {
-                        log.warn(`Error getting totalSupply for campaign ${campaign.campaignId}`);
-                        totalSupply = 0.0000001;
-                    }
-                    const priceRewardToken = (await pricer.get({
-                        address: campaign.rewardToken,
-                        chainId: campaign.chainId,
-                        symbol: campaign.campaignParameters.symbolRewardToken,
-                    })) ?? 0;
-                    const priceTargetToken = (await pricer.get({
-                        address: VEST_TOKEN,
-                        chainId: campaign.computeChainId,
-                        symbol: "USDC.e",
-                    })) ?? 0;
-                    const tvl = totalSupply * priceTargetToken;
-                    dynamicData.push({
-                        ...campaign,
-                        apr: (priceRewardToken *
-                            BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                            YEAR *
-                            100) /
-                            campaign.campaignParameters.duration /
-                            (totalSupply * priceTargetToken),
-                        totalSupplyTargetToken: totalSupply,
-                        tvl,
-                        priceRewardToken: priceRewardToken,
-                    });
-                }
-                return dynamicData;
-            },
-        },
-    };
-}

package/dist/src/libs/campaigns/campaignsDynamicData.d.ts

@@ -1,3 +0,0 @@
-import { Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../utils/execute";
-export declare function campaignsDynamicData<T extends Campaign>(chainId: MerklChainId, campaigns: CampaignParameters<T>[], type: T | string): Promise<UncachedResult<Partial<CampaignDynamicData<T>[]>>>;

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

@@ -1,131 +0,0 @@
-import { UserService } from "@/modules/v4/user/user.service";
-import { Campaign } from "@sdk";
-import { AjnaDynamicData } from "./campaignTypes/AjnaDynamicData";
-import { AmbientDynamicData } from "./campaignTypes/AmbientDynamicData";
-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 { ERC20_SNAPSHOTDynamicData } from "./campaignTypes/ERC20_SNAPSHOTDynamicData";
-import { EigenLayerDynamicData } from "./campaignTypes/EigenLayerDynamicData";
-import { EncompassingDynamicData } from "./campaignTypes/EncompassingDynamicData";
-import { EventBasedDynamicData } from "./campaignTypes/EventBasedDynamicData";
-import { HyperdriveDynamicData } from "./campaignTypes/HyperdriveDynamicData";
-import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData";
-import { MORPHODynamicData } from "./campaignTypes/MORPHODynamicData";
-import { RadiantDynamicData } from "./campaignTypes/RadiantDynamicData";
-import { SILODynamicData } from "./campaignTypes/SILODynamicData";
-import { UniswapV4DynamicData } from "./campaignTypes/UniswapV4DynamicData";
-import { VestDynamicData } from "./campaignTypes/VestDynamicData";
-export async function campaignsDynamicData(chainId, campaigns, type) {
-    try {
-        for (const campaign of campaigns) {
-            const tags = (await UserService.findUnique(campaign.creator))?.tags;
-            campaign.tags = tags || [];
-        }
-    }
-    catch (_err) { }
-    switch (type) {
-        case "ERC20":
-        case Campaign.ERC20: {
-            return ERC20DynamicData(chainId, campaigns);
-        }
-        case "ERC20LOGPROCESSOR":
-        case Campaign.ERC20LOGPROCESSOR: {
-            return ERC20DynamicData(chainId, campaigns);
-        }
-        case "ERC20REBASELOGPROCESSOR":
-        case Campaign.ERC20REBASELOGPROCESSOR: {
-            return ERC20DynamicData(chainId, campaigns);
-        }
-        case "CLAMM":
-        case Campaign.CLAMM: {
-            return CLAMMDynamicData(chainId, campaigns);
-        }
-        case "ERC20_SNAPSHOT":
-        case Campaign.ERC20_SNAPSHOT: {
-            return ERC20_SNAPSHOTDynamicData(chainId, campaigns);
-        }
-        case "JSON_AIRDROP":
-        case Campaign.JSON_AIRDROP: {
-            return JSON_AIRDROPDynamicData(chainId, campaigns);
-        }
-        case "SILO":
-        case Campaign.SILO: {
-            return SILODynamicData(chainId, campaigns);
-        }
-        case "RADIANT":
-        case Campaign.RADIANT: {
-            return RadiantDynamicData(chainId, campaigns);
-        }
-        case "MORPHO":
-        case Campaign.MORPHO: {
-            return MORPHODynamicData(chainId, campaigns);
-        }
-        case "EULER":
-        case Campaign.EULER: {
-            return ERC20DynamicData(chainId, campaigns);
-        }
-        case "DOLOMITE":
-        case Campaign.DOLOMITE: {
-            return DolomiteDynamicData(chainId, campaigns);
-        }
-        case "BADGER":
-        case Campaign.BADGER: {
-            return BadgerDynamicData(chainId, campaigns);
-        }
-        case "AJNA":
-        case Campaign.AJNA: {
-            return AjnaDynamicData(chainId, campaigns);
-        }
-        case "COMPOUND":
-        case Campaign.COMPOUND: {
-            return CompoundDynamicData(chainId, campaigns);
-        }
-        case "EIGENLAYER":
-        case Campaign.EIGENLAYER: {
-            return EigenLayerDynamicData(chainId, campaigns);
-        }
-        case "VEST":
-        case Campaign.VEST: {
-            return VestDynamicData(chainId, campaigns);
-        }
-        case "ERC20_FIX_APR":
-        case Campaign.ERC20_FIX_APR: {
-            return ERC20DynamicData(chainId, campaigns);
-        }
-        case "HYPERDRIVELOGPROCESSOR":
-        case "HYPERDRIVELOGFIXPROCESSOR":
-        case Campaign.HYPERDRIVELOGPROCESSOR:
-        case Campaign.HYPERDRIVELOGFIXPROCESSOR: {
-            return HyperdriveDynamicData(chainId, campaigns);
-        }
-        case "AMBIENTPROCESSOR":
-        case Campaign.AMBIENTPROCESSOR: {
-            return AmbientDynamicData(chainId, campaigns);
-        }
-        case "UNISWAP_V4":
-        case Campaign.UNISWAP_V4: {
-            return UniswapV4DynamicData(chainId, campaigns);
-        }
-        case "ENCOMPASSING":
-        case Campaign.ENCOMPASSING: {
-            return EncompassingDynamicData(chainId, campaigns);
-        }
-        case "EVENT_BASED":
-        case Campaign.EVENT_BASED: {
-            return EventBasedDynamicData(chainId, campaigns);
-        }
-    }
-    return {
-        cached: false,
-        call: {
-            callData: [],
-            handler: () => { },
-            reducer: async (_) => {
-                return campaigns;
-            },
-        },
-    };
-}