@merkl/api 0.19.6 → 0.19.8

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

@@ -1,5 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-type ReturnType = CampaignDynamicData<Campaign.HYPERDRIVELOGPROCESSOR | Campaign.HYPERDRIVELOGFIXPROCESSOR>[];
-export declare function HyperdriveDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.HYPERDRIVELOGPROCESSOR | Campaign.HYPERDRIVELOGFIXPROCESSOR>[]): Promise<UncachedResult<Partial<ReturnType>>>;
-export {};

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

@@ -1,99 +0,0 @@
-import { BN2Number, ETH_ADDRESS, HyperDriveSubCampaignType, HyperdriveTargetInterface, YEAR, } from "@sdk";
-import { Pricer } from "../../../utils/pricer";
-export async function HyperdriveDynamicData(chainId, campaigns) {
-    const pricer = await Pricer.load();
-    const calls = [];
-    for (const campaign of campaigns) {
-        calls.push({
-            allowFailure: false,
-            callData: HyperdriveTargetInterface.encodeFunctionData("getPoolInfo"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: false,
-            callData: HyperdriveTargetInterface.encodeFunctionData("getPoolConfig"),
-            target: campaign.campaignParameters.targetToken,
-        });
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                let i = 0;
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    try {
-                        const poolInfo = HyperdriveTargetInterface.decodeFunctionResult("getPoolInfo", result[i])[0];
-                        const poolConfig = HyperdriveTargetInterface.decodeFunctionResult("getPoolConfig", result[i + 1])[0];
-                        const priceRewardToken = (await pricer.get({
-                            address: campaign.rewardToken,
-                            chainId,
-                            symbol: campaign.campaignParameters.symbolRewardToken,
-                        })) ?? 0;
-                        const lpSupply = BN2Number(poolInfo.lpTotalSupply, 18);
-                        const longSupply = BN2Number(poolInfo.longsOutstanding, 18);
-                        const shortSupply = BN2Number(poolInfo.shortsOutstanding, 18);
-                        const marketSupply = lpSupply * BN2Number(poolInfo.lpSharePrice, 18);
-                        const priceBaseToken = (poolConfig.baseToken === ETH_ADDRESS
-                            ? await pricer.get({
-                                chainId,
-                                symbol: "ETH",
-                            })
-                            : await pricer.get({
-                                address: campaign.campaignParameters.baseToken,
-                                chainId,
-                                symbol: campaign.campaignParameters.baseTokenSymbol,
-                            })) ?? 0;
-                        const tvl = campaign.campaignSubType === HyperDriveSubCampaignType.LP
-                            ? priceBaseToken * marketSupply
-                            : campaign.campaignSubType === HyperDriveSubCampaignType.LONG
-                                ? priceBaseToken * longSupply
-                                : priceBaseToken * shortSupply;
-                        dynamicData.push({
-                            ...campaign,
-                            totalSupplyTargetToken: marketSupply,
-                            tvl: tvl,
-                            apr: priceRewardToken !== 0
-                                ? (priceRewardToken *
-                                    BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                                    YEAR *
-                                    100) /
-                                    campaign.campaignParameters.duration /
-                                    tvl
-                                : 0,
-                            priceRewardToken: priceRewardToken,
-                        });
-                    }
-                    catch (e) {
-                        dynamicData.push({
-                            ...campaign,
-                            totalSupplyTargetToken: 0,
-                            tvl: 0,
-                            apr: 0,
-                            priceRewardToken: 0,
-                        });
-                        console.error(e);
-                    }
-                    i += 2;
-                }
-                return dynamicData;
-            },
-        },
-    };
-}
-// enum AssetIdPrefix {
-//   LP = 0,
-//   Long = 1,
-//   Short = 2,
-//   WithdrawalShare = 3,
-// }
-// function encodeAssetId(prefix: AssetIdPrefix, timestamp: bigint): bigint {
-//   // Check if the timestamp is within the valid range
-//   const maxTimestamp = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-//   if (timestamp > maxTimestamp) {
-//     throw new Error("InvalidTimestamp");
-//   }
-//   // Encode the asset ID
-//   return (BigInt(prefix) << BigInt(248)) | timestamp;
-// }

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

@@ -1,5 +0,0 @@
-import type { Campaign, CampaignDynamicData, CampaignParameters, MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-type ReturnType = CampaignDynamicData<Campaign.JSON_AIRDROP>[];
-export declare function JSON_AIRDROPDynamicData(_chainId: MerklChainId, campaigns: CampaignParameters<Campaign.JSON_AIRDROP>[]): Promise<UncachedResult<Partial<ReturnType>>>;
-export {};

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

@@ -1,19 +0,0 @@
-export async function JSON_AIRDROPDynamicData(_chainId, campaigns) {
-    const calls = [];
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (_result) => {
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    dynamicData.push({
-                        ...campaign,
-                    });
-                }
-                return dynamicData;
-            },
-        },
-    };
-}

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

@@ -1,5 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-type ReturnType = Partial<CampaignDynamicData<Campaign.MORPHO>[]>;
-export declare function MORPHODynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.MORPHO>[]): Promise<UncachedResult<ReturnType>>;
-export {};

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

@@ -1,112 +0,0 @@
-import { BN2Number, MetamorphoInterface, 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",
-    };
-    for (const campaign of campaigns) {
-        if (campaign.campaignSubType === MorphoSubCampaignType.META) {
-            calls.push({
-                allowFailure: true,
-                callData: MetamorphoInterface.encodeFunctionData("totalAssets"),
-                target: campaign.campaignParameters.targetToken,
-            }, {
-                allowFailure: true,
-                callData: MetamorphoInterface.encodeFunctionData("totalSupply"),
-                target: campaign.campaignParameters.targetToken,
-            });
-        }
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                const dynamicData = [];
-                let index = 0;
-                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 totalAssets = BN2Number(MetamorphoInterface.decodeFunctionResult("totalAssets", result[index++])[0], campaign.campaignParameters.decimalsUnderlyingToken);
-                        const totalSupply = BN2Number(MetamorphoInterface.decodeFunctionResult("totalSupply", result[index++])[0], campaign.campaignParameters.decimalsTargetToken);
-                        const priceAsset = (await pricer.get({
-                            symbol: campaign.campaignParameters.symbolUnderlyingToken,
-                        })) ?? 0;
-                        tvl = priceAsset * totalAssets;
-                        totalSupplyTargetToken = totalSupply;
-                    }
-                    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.d.ts

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

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

@@ -1,122 +0,0 @@
-import { ComputedValueService } from "@/modules/v4/computedValue";
-import { engineDbClient } from "@db";
-import { BN2Number, ERC20Interface, NULL_ADDRESS, RadiantInterface, 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";
-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);
-                    let lastEligibilityRatio = 1;
-                    if (!!campaign.campaignParameters.hooks?.length) {
-                        for (const campaignId of [campaign.campaignId, ...backupCampaignIds]) {
-                            lastEligibilityRatio =
-                                (await ComputedValueService.findCampaignValue({
-                                    campaignId: `${campaignId}-${chainId}`,
-                                    field: "averageBoost",
-                                }))?.averageBoost ?? 1;
-                            if (lastEligibilityRatio !== 1)
-                                break;
-                        }
-                    }
-                    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.d.ts

@@ -1,7 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import { utils } from "ethers";
-import type { UncachedResult } from "../../../utils/execute";
-export declare const SILO_INTERFACE: utils.Interface;
-type ReturnType = Partial<CampaignDynamicData<Campaign.SILO>>[];
-export declare function SILODynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.SILO>[]): Promise<UncachedResult<ReturnType>>;
-export {};

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

@@ -1,115 +0,0 @@
-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;
-                    const forwarders = (campaign.campaignParameters.forwarders ??
-                        []);
-                    for (const _forwarder of 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
-                                forwarders[0].siloAsset = siloAsset;
-                                forwarders[0].siloAssetSymbol = siloAssetSymbol;
-                            }
-                        }
-                    }
-                    if (campaign.campaignParameters.whitelist.length === 1) {
-                        j++;
-                    }
-                    // Remove all silo forwarders
-                    campaign.campaignParameters.forwarders = 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/campaignTypes/UniswapV4DynamicData.d.ts

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