@merkl/api 0.20.85 → 0.20.86

package/dist/src/engine/dynamicData/factory.js

@@ -6,6 +6,8 @@ import { ClammDynamicData } from "./implementations/Clamm";
 import { CompoundDynamicData } from "./implementations/Compound";
 import { CompoundV3DynamicData } from "./implementations/CompoundV3";
 import { DolomiteDynamicData } from "./implementations/Dolomite";
+import { ERC721DynamicData } from "./implementations/ERC721";
+import { ERCMultiTokenDynamicData } from "./implementations/ERCMultiToken";
 import { EigenLayerDynamicData } from "./implementations/EigenLayer";
 import { EncompassingDynamicData } from "./implementations/Encompassing";
 import { Erc20DynamicData } from "./implementations/Erc20";
@@ -54,11 +56,11 @@ const map = {
     [Campaign.MORPHOSUPPLY]: new DefaultDynamicData(), // TODO
     [Campaign.SYNCSWAP_VAULT]: new DefaultDynamicData(), // TODO
     [Campaign.MAVERICK_BP]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC6909]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC6909FIXAPR]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC1155]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC1155FIXAPR]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC721]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC721FIXAPR]: new DefaultDynamicData(), // TODO
+    [Campaign.ERC6909]: new ERCMultiTokenDynamicData(),
+    [Campaign.ERC6909FIXAPR]: new ERCMultiTokenDynamicData(),
+    [Campaign.ERC1155]: new ERCMultiTokenDynamicData(),
+    [Campaign.ERC1155FIXAPR]: new ERCMultiTokenDynamicData(),
+    [Campaign.ERC721]: new ERC721DynamicData(),
+    [Campaign.ERC721FIXAPR]: new ERC721DynamicData(),
 };
 export const dynamicDataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/dynamicData/implementations/ERC721.d.ts

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

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

@@ -0,0 +1,85 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { AragornEscrowInterface, BN2Number, ChainInteractionService, ERC20Interface, YEAR, } from "@sdk";
+import { ERC721SubCampaignType } from "libs/sdk/src/types/merkl/campaignTypes/erc721";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+import { getFixedApr, hasFixedAprConfig } from "../utils/getFixedApr";
+export class ERC721DynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        const calls = [];
+        for (const campaign of campaigns) {
+            if (campaign.campaignSubType === ERC721SubCampaignType.VOTING_POWER) {
+                calls.push({
+                    allowFailure: true,
+                    callData: AragornEscrowInterface.encodeFunctionData("totalLocked"),
+                    target: campaign.campaignParameters.extraContracts[0],
+                });
+            }
+            else {
+                calls.push({
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"), // TODO do not fit global interface
+                    target: campaign.campaignParameters.targetToken,
+                });
+            }
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            let totalSupply;
+            let symbolToken = campaign.campaignParameters.symbolTargetToken;
+            let token = campaign.campaignParameters.targetToken;
+            if (campaign.campaignSubType === ERC721SubCampaignType.VOTING_POWER) {
+                symbolToken = campaign.campaignParameters.symbolUnderlyingToken;
+                token = campaign.campaignParameters.extraContracts[1];
+                try {
+                    totalSupply = BN2Number(AragornEscrowInterface.decodeFunctionResult("totalLocked", result[i].returnData)[0], campaign.campaignParameters.decimalsTargetToken);
+                }
+                catch {
+                    log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and token ${campaign.campaignParameters.targetToken}`);
+                    totalSupply = 0.0000001;
+                }
+            }
+            else {
+                try {
+                    totalSupply = 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}`);
+                    totalSupply = 0.0000001;
+                }
+            }
+            i++;
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            const priceTargetToken = (await pricer.get({
+                address: token,
+                chainId: campaign.computeChainId,
+                // Remove the `c` at the beginning of the symbol and the `v3` at the end
+                symbol: symbolToken,
+            })) ?? 0;
+            let apr = (priceRewardToken * BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) * YEAR * 100) /
+                campaign.campaignParameters.duration /
+                (totalSupply * priceTargetToken);
+            const rewardTokens = await TokenService.findManyOrCreate([
+                { chainId: campaign.chainId, address: campaign.rewardToken },
+            ]);
+            const rewardToken = rewardTokens[0];
+            if (rewardToken.isPoint) {
+                apr = apr / 365 / 100;
+            }
+            else if (hasFixedAprConfig(campaign.campaignParameters)) {
+                apr = getFixedApr(campaign, priceRewardToken, priceTargetToken);
+            }
+            dynamicData.push({
+                ...campaign,
+                apr,
+                totalSupplyTargetToken: totalSupply,
+                tvl: totalSupply * priceTargetToken,
+                priceRewardToken: priceRewardToken,
+            });
+        }
+        return dynamicData;
+    }
+}

package/dist/src/engine/dynamicData/implementations/ERCMultiToken.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.ERC6909 | Campaign.ERC6909FIXAPR | Campaign.ERC1155 | Campaign.ERC1155FIXAPR;
+export declare class ERCMultiTokenDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<ERC6909CampaignDynamicData[]>;
+}
+export {};

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

@@ -0,0 +1,159 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { BN2Number, ChainInteractionService, CloberBookManagerInterface, CloberPoolInterface, ERC20Interface, ERC6909Interface, YEAR, } from "@sdk";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+import { getFixedApr, hasFixedAprConfig } from "../utils/getFixedApr";
+export class ERCMultiTokenDynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        const calls = [];
+        for (const campaign of campaigns) {
+            calls.push({
+                allowFailure: true,
+                callData: ERC6909Interface.encodeFunctionData("totalSupply", [campaign.campaignParameters.tokenId]),
+                target: campaign.campaignParameters.targetToken,
+            });
+            calls.push({
+                allowFailure: true,
+                callData: CloberPoolInterface.encodeFunctionData("bookManager"),
+                target: campaign.campaignParameters.targetToken,
+            });
+            calls.push({
+                allowFailure: true,
+                callData: CloberPoolInterface.encodeFunctionData("getBookPairs", [campaign.campaignParameters.tokenId]),
+                target: campaign.campaignParameters.targetToken,
+            });
+            calls.push({
+                allowFailure: true,
+                callData: CloberPoolInterface.encodeFunctionData("getLiquidity", [campaign.campaignParameters.tokenId]),
+                target: campaign.campaignParameters.targetToken,
+            });
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            let totalSupply;
+            let tvl;
+            let priceTargetToken;
+            try {
+                totalSupply = BN2Number(ERC6909Interface.decodeFunctionResult("totalSupply", result[i].returnData)[0], campaign.campaignParameters.decimalsTargetToken);
+            }
+            catch {
+                log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and token ${campaign.campaignParameters.targetToken}`);
+                totalSupply = 0.0000001;
+            }
+            i++;
+            // Specific to Clober so far
+            try {
+                const bookManager = CloberPoolInterface.decodeFunctionResult("bookManager", result[i + 1].returnData)[0];
+                const bookPairs = CloberPoolInterface.decodeFunctionResult("getBookPairs", result[i + 2].returnData);
+                const liquidity = CloberPoolInterface.decodeFunctionResult("getLiquidity", result[i + 3].returnData);
+                const liquidityToken0 = BigInt(liquidity[0].reserve) + BigInt(liquidity[0].cancelable) + BigInt(liquidity[0].claimable);
+                const liquidityToken1 = BigInt(liquidity[1].reserve) + BigInt(liquidity[1].cancelable) + BigInt(liquidity[1].claimable);
+                const bookPair0 = bookPairs[0] < bookPairs[1] ? bookPairs[0] : bookPairs[1];
+                const bookPair1 = bookPairs[0] < bookPairs[1] ? bookPairs[1] : bookPairs[0];
+                let token0;
+                let token1;
+                let symbol0;
+                let symbol1;
+                let decimals0;
+                let decimals1;
+                {
+                    const bookManagerCalls = [
+                        {
+                            allowFailure: true,
+                            callData: CloberBookManagerInterface.encodeFunctionData("getBookKey", [bookPair0]),
+                            target: bookManager,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: CloberBookManagerInterface.encodeFunctionData("getBookKey", [bookPair1]),
+                            target: bookManager,
+                        },
+                    ];
+                    const resultBookManager = await ChainInteractionService(chainId).fetchState(bookManagerCalls);
+                    let j = 0;
+                    const bookKey0 = CloberBookManagerInterface.decodeFunctionResult("getBookKey", resultBookManager[j++].returnData)[0];
+                    const bookKey1 = CloberBookManagerInterface.decodeFunctionResult("getBookKey", resultBookManager[j++].returnData)[0];
+                    token0 = bookKey0[0];
+                    token1 = bookKey1[0];
+                }
+                {
+                    const tokenCalls = [
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("symbol"),
+                            target: token0,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("symbol"),
+                            target: token1,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("decimals"),
+                            target: token0,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("decimals"),
+                            target: token1,
+                        },
+                    ];
+                    const resultTokens = await ChainInteractionService(chainId).fetchState(tokenCalls);
+                    let j = 0;
+                    symbol0 = ERC20Interface.decodeFunctionResult("symbol", resultTokens[j++].returnData)[0];
+                    symbol1 = ERC20Interface.decodeFunctionResult("symbol", resultTokens[j++].returnData)[0];
+                    decimals0 = ERC20Interface.decodeFunctionResult("decimals", resultTokens[j++].returnData)[0];
+                    decimals1 = ERC20Interface.decodeFunctionResult("decimals", resultTokens[j++].returnData)[0];
+                }
+                const priceToken0 = (await pricer.get({
+                    address: token0,
+                    chainId: campaign.computeChainId,
+                    symbol: symbol0,
+                })) ?? 0;
+                const priceToken1 = (await pricer.get({
+                    address: token1,
+                    chainId: campaign.computeChainId,
+                    symbol: symbol1,
+                })) ?? 0;
+                tvl = priceToken0 * BN2Number(liquidityToken0, decimals0) + priceToken1 * BN2Number(liquidityToken1, decimals1);
+                priceTargetToken = tvl / totalSupply;
+            }
+            catch {
+                priceTargetToken =
+                    (await pricer.get({
+                        address: campaign.campaignParameters.targetToken,
+                        chainId: campaign.computeChainId,
+                        symbol: campaign.campaignParameters.symbolTargetToken,
+                    })) ?? 0;
+                tvl = totalSupply * priceTargetToken;
+            }
+            i += 4;
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            const rewardTokens = await TokenService.findManyOrCreate([
+                { chainId: campaign.chainId, address: campaign.rewardToken },
+            ]);
+            const rewardToken = rewardTokens[0];
+            let apr = (priceRewardToken * BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) * YEAR * 100) /
+                campaign.campaignParameters.duration /
+                tvl;
+            if (rewardToken.isPoint) {
+                apr = apr / 365 / 100;
+            }
+            else if (hasFixedAprConfig(campaign.campaignParameters)) {
+                apr = getFixedApr(campaign, priceRewardToken, priceTargetToken);
+            }
+            dynamicData.push({
+                ...campaign,
+                apr,
+                totalSupplyTargetToken: totalSupply,
+                tvl,
+                priceRewardToken: priceRewardToken,
+            });
+        }
+        return dynamicData;
+    }
+}

package/dist/src/engine/dynamicData/utils/getFixedApr.d.ts

@@ -4,6 +4,6 @@ export type BaseFixAPRConfig = {
     targetTokenPricing: boolean;
     rewardTokenPricing: boolean;
 };
-export type FixedAprCampaignType = Campaign.ERC20_FIX_APR | Campaign.HYPERDRIVELOGFIXPROCESSOR;
+export type FixedAprCampaignType = Campaign.ERC20_FIX_APR | Campaign.HYPERDRIVELOGFIXPROCESSOR | Campaign.ERC6909FIXAPR | Campaign.ERC1155FIXAPR | Campaign.ERC721FIXAPR;
 export declare function hasFixedAprConfig<T>(params: T): params is T & BaseFixAPRConfig;
 export declare function getFixedApr(campaignParameters: CampaignParameters<FixedAprCampaignType>, priceRewardToken: number, priceTargetToken: number): number;

package/dist/src/engine/opportunityMetadata/factory.js

@@ -7,6 +7,8 @@ import { CompoundMetadata } from "./implementations/Compound";
 import { CompoundV3Metadata } from "./implementations/CompoundV3";
 import { DefaultMetadata } from "./implementations/Default";
 import { DolomiteMetadata } from "./implementations/Dolomite";
+import { ERC721Metadata } from "./implementations/ERC721";
+import { ERCMultiTokenMetadata } from "./implementations/ERCMultiToken";
 import { EigenLayerMetadata } from "./implementations/EigenLayer";
 import { EncompassingMetadata } from "./implementations/Encompassing";
 import { Erc20Metadata } from "./implementations/Erc20";
@@ -57,11 +59,11 @@ const map = {
     [Campaign.EVENT_BASED]: new EventBasedMetadata(),
     [Campaign.ERC20REBASEFIXAPR]: new Erc20Metadata(),
     [Campaign.MAVERICK_BP]: new DefaultMetadata(), // TODO
-    [Campaign.ERC6909]: new DefaultMetadata(), // TODO
-    [Campaign.ERC6909FIXAPR]: new DefaultMetadata(), // TODO
-    [Campaign.ERC1155]: new DefaultMetadata(), // TODO
-    [Campaign.ERC1155FIXAPR]: new DefaultMetadata(), // TODO
-    [Campaign.ERC721]: new DefaultMetadata(), // TODO
-    [Campaign.ERC721FIXAPR]: new DefaultMetadata(), // TODO
+    [Campaign.ERC6909]: new ERCMultiTokenMetadata(),
+    [Campaign.ERC6909FIXAPR]: new ERCMultiTokenMetadata(),
+    [Campaign.ERC1155]: new ERCMultiTokenMetadata(),
+    [Campaign.ERC1155FIXAPR]: new ERCMultiTokenMetadata(),
+    [Campaign.ERC721]: new ERC721Metadata(),
+    [Campaign.ERC721FIXAPR]: new ERC721Metadata(),
 };
 export const metadataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/opportunityMetadata/implementations/ERC721.d.ts

@@ -0,0 +1,16 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ERC721 | CampaignEnum.ERC721FIXAPR;
+export declare class ERC721Metadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "HOLD";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: undefined;
+        depositUrl: undefined;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/ERC721.js

@@ -0,0 +1,12 @@
+import { OpportunityAction } from "@db/api";
+export class ERC721Metadata {
+    async build(computeChainId, params) {
+        return {
+            action: OpportunityAction.HOLD,
+            name: `Hold ${params.symbolTargetToken}`,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: undefined,
+            depositUrl: undefined,
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/ERCMultiToken.d.ts

@@ -0,0 +1,16 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ERC1155 | CampaignEnum.ERC1155FIXAPR | CampaignEnum.ERC6909 | CampaignEnum.ERC6909FIXAPR;
+export declare class ERCMultiTokenMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "HOLD";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: undefined;
+        depositUrl: undefined;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/ERCMultiToken.js

@@ -0,0 +1,12 @@
+import { OpportunityAction } from "@db/api";
+export class ERCMultiTokenMetadata {
+    async build(computeChainId, params) {
+        return {
+            action: OpportunityAction.HOLD,
+            name: `Hold ${params.symbolTargetToken} with token ID ${params.tokenId}`,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: undefined,
+            depositUrl: undefined,
+        };
+    }
+}