@merkl/api 0.19.6 → 0.19.8

package/dist/src/engine/dynamicData/implementations/Hyperdrive.js

@@ -0,0 +1,96 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { Pricer } from "@/utils/pricer";
+import { BN2Number, ChainInteractionService, ETH_ADDRESS, HyperDriveSubCampaignType, HyperdriveTargetInterface, YEAR, } from "@sdk";
+export class HyperdriveDynamicData {
+    async build(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,
+            });
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            try {
+                const poolInfo = HyperdriveTargetInterface.decodeFunctionResult("getPoolInfo", result[i].returnData)[0];
+                const poolConfig = HyperdriveTargetInterface.decodeFunctionResult("getPoolConfig", result[i + 1].returnData)[0];
+                // const priceRewardToken =
+                //   (await pricer.get({
+                //     address: campaign.rewardToken,
+                //     chainId,
+                //     symbol: campaign.campaignParameters.symbolRewardToken,
+                //   })) ?? 0;
+                const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                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/engine/dynamicData/implementations/Morpho.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.MORPHO;
+export declare class MorphoDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<MorphoCampaignDynamicData[]>;
+}
+export {};

package/dist/src/engine/dynamicData/implementations/Morpho.js

@@ -0,0 +1,109 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { BN2Number, ChainInteractionService, MetamorphoInterface, MorphoSubCampaignType, YEAR, } from "@sdk";
+import axios from "axios";
+import { Pricer } from "../../../utils/pricer";
+export class MorphoDynamicData {
+    async build(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,
+                });
+            }
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        const dynamicData = [];
+        let index = 0;
+        for (const campaign of campaigns) {
+            // const priceRewardToken =
+            //   (await pricer.get({
+            //     address: campaign.rewardToken,
+            //     chainId,
+            //     symbol: campaign.campaignParameters.symbolRewardToken,
+            //   })) ?? 0;
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            let tvl = 0;
+            let totalSupplyTargetToken = 0;
+            if (campaign.campaignSubType === MorphoSubCampaignType.META) {
+                const totalAssets = BN2Number(MetamorphoInterface.decodeFunctionResult("totalAssets", result[index++].returnData)[0], campaign.campaignParameters.decimalsUnderlyingToken);
+                const totalSupply = BN2Number(MetamorphoInterface.decodeFunctionResult("totalSupply", result[index++].returnData)[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/engine/dynamicData/implementations/Radiant.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.RADIANT;
+export declare class RadiantDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<RadiantCampaignDynamicData[]>;
+}
+export {};

package/dist/src/engine/dynamicData/implementations/Radiant.js

@@ -0,0 +1,117 @@
+import { ComputedValueService } from "@/modules/v4/computedValue";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { engineDbClient } from "@db";
+import { BN2Number, ChainInteractionService, 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";
+export class RadiantDynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        const calls = [];
+        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,
+            });
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            let totalSupplyTargetToken;
+            try {
+                totalSupplyTargetToken = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[i++].returnData)[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;
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            let priceDecimals = 8;
+            let rizRegistry = "";
+            try {
+                rizRegistry = RadiantPoolInterface.decodeFunctionResult("getRizRegistry", result[i].returnData)[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].returnData)[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/engine/dynamicData/implementations/Silo.d.ts

@@ -0,0 +1,9 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import { utils } from "ethers";
+import type { DynamicDataBuilder } from "../interface";
+export declare const SILO_INTERFACE: utils.Interface;
+type campaignType = Campaign.SILO;
+export declare class SiloDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<any[]>;
+}
+export {};

package/dist/src/engine/dynamicData/implementations/Silo.js

@@ -0,0 +1,109 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { BN2Number, ChainInteractionService, ERC20Interface, Forwarder, YEAR, } from "@sdk";
+import { utils } from "ethers";
+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 class SiloDynamicData {
+    async build(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 ChainInteractionService(chainId).fetchState(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++;
+            }
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        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 priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            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].returnData)[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++].returnData)[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/engine/dynamicData/implementations/UniswapV4.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.UNISWAP_V4;
+export declare class UniswapV4DynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<UniswapV4CampaignDynamicData[]>;
+}
+export {};