@merkl/api 0.10.128 → 0.10.130

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound4.js

@@ -0,0 +1,323 @@
+import { BN2Number, ERC20Interface } from "@sdk";
+import { tokenType } from "./helpers/tokenType";
+import { eulerInterface, fluidInterface, torosInterface } from "./subtypesRound1";
+import { balancerVaultInterface } from "./subtypesRound3";
+export function getTokenTypeRound4(index, type, typeInfo, calls, campaign) {
+    const blacklistedLiquidityCalls = [];
+    if (campaign.campaignParameters.blacklist.length > 0) {
+        for (const blacklistedAddress of campaign.campaignParameters.blacklist) {
+            blacklistedLiquidityCalls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("balanceOf", [blacklistedAddress]),
+                target: typeInfo.tokenAddress,
+            });
+        }
+    }
+    const whitelistedLiquidityCalls = [];
+    if (campaign.campaignParameters.whitelist.length > 0) {
+        for (const whitelistedAddress of campaign.campaignParameters.whitelist) {
+            whitelistedLiquidityCalls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("balanceOf", [whitelistedAddress]),
+                target: typeInfo.tokenAddress,
+            });
+        }
+    }
+    if (type === tokenType.uniswapv2 ||
+        type === tokenType.poolside ||
+        type === tokenType.aerodrome ||
+        type === tokenType.velodrome ||
+        type === tokenType.dragonswap ||
+        type === tokenType.akron) {
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: typeInfo.tokenAddress,
+                },
+            ].concat(blacklistedLiquidityCalls),
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+    if (type === tokenType.balancerGauge) {
+        const tokens = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[0];
+        const balances = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[1];
+        let i = 0;
+        const poolTokens = [];
+        for (const token of tokens) {
+            poolTokens.push({
+                token: token,
+                balance: balances[i].toString(),
+            });
+            i++;
+        }
+        const poolCalls = [
+            {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                target: typeInfo.tokenAddress,
+            },
+        ];
+        for (const poolToken of poolTokens) {
+            poolCalls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("symbol"),
+                target: poolToken.token,
+            });
+            poolCalls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("decimals"),
+                target: poolToken.token,
+            });
+        }
+        return {
+            type: tokenType.balancerGauge,
+            calls: poolCalls.concat(blacklistedLiquidityCalls),
+            typeInfo: {
+                ...typeInfo,
+                poolTokens: poolTokens,
+            },
+        };
+    }
+    // symbol is ECLP-USDC-USDT
+    if (type === tokenType.balancerPool) {
+        const tokens = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[0];
+        const balances = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[1];
+        let i = 0;
+        const poolTokens = [];
+        for (const token of tokens) {
+            if (token !== typeInfo.tokenAddress) {
+                poolTokens.push({
+                    token: token,
+                    balance: balances[i].toString(),
+                });
+            }
+            i++;
+        }
+        const poolCalls = [
+            {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                target: typeInfo.tokenAddress,
+            },
+        ];
+        for (const poolToken of poolTokens) {
+            poolCalls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("symbol"),
+                target: poolToken.token,
+            });
+            poolCalls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("decimals"),
+                target: poolToken.token,
+            });
+        }
+        poolCalls.push({
+            allowFailure: true,
+            callData: ERC20Interface.encodeFunctionData("balanceOf", [typeInfo.vault]),
+            target: typeInfo.tokenAddress,
+        });
+        return {
+            type: tokenType.balancerPool,
+            calls: poolCalls.concat(blacklistedLiquidityCalls),
+            typeInfo: {
+                ...typeInfo,
+                poolTokens: poolTokens,
+            },
+        };
+    }
+    if (type === tokenType.aura) {
+        const tokens = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[0];
+        const balances = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[1];
+        let i = 0;
+        const poolTokens = [];
+        for (const token of tokens) {
+            if (token !== typeInfo.tokenAddress) {
+                poolTokens.push({
+                    token: token,
+                    balance: balances[i].toString(),
+                });
+            }
+            i++;
+        }
+        const poolCalls = [
+            {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                target: typeInfo.tokenAddress,
+            },
+        ];
+        for (const poolToken of poolTokens) {
+            poolCalls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("symbol"),
+                target: poolToken.token,
+            });
+            poolCalls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("decimals"),
+                target: poolToken.token,
+            });
+        }
+        const gaugeBalance = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 1].returnData)[0];
+        const auraBalance = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 2].returnData)[0];
+        const totalSupplyGauge = ERC20Interface.decodeFunctionResult("totalSupply", calls[index + 3].returnData)[0];
+        return {
+            type: type,
+            calls: poolCalls.concat(blacklistedLiquidityCalls),
+            typeInfo: {
+                ...typeInfo,
+                poolTokens: poolTokens,
+                gaugeBalance: BN2Number(gaugeBalance, 18),
+                auraBalance: BN2Number(auraBalance, 18),
+                totalSupplyGauge: BN2Number(totalSupplyGauge, 18),
+            },
+        };
+    }
+    if (type === tokenType.gearbox) {
+        // Get the underlying gearbox token to fetch the final underlying token
+        const decimalsUnderlyingToken = ERC20Interface.decodeFunctionResult("decimals", calls[index].returnData)[0];
+        const symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index + 1].returnData)[0];
+        const totalAssets = BN2Number(typeInfo.totalAssets, decimalsUnderlyingToken);
+        return {
+            type: tokenType.gearbox,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: typeInfo.tokenAddress,
+                },
+            ].concat(blacklistedLiquidityCalls),
+            typeInfo: {
+                ...typeInfo,
+                decimalsUnderlyingToken,
+                symbolUnderlyingToken,
+                totalAssets: totalAssets,
+            },
+        };
+    }
+    if (type === tokenType.toros) {
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: typeInfo.tokenAddress,
+                },
+                {
+                    allowFailure: true,
+                    callData: torosInterface.encodeFunctionData("tokenPrice"),
+                    target: typeInfo.tokenAddress,
+                },
+            ].concat(blacklistedLiquidityCalls),
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+    if (type === tokenType.fluid) {
+        const toAssets = fluidInterface.decodeFunctionResult("convertToAssets", calls[index].returnData)[0];
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: typeInfo.tokenAddress,
+                },
+            ].concat(blacklistedLiquidityCalls),
+            typeInfo: {
+                ...typeInfo,
+                exchangeRate: BN2Number(toAssets, typeInfo.decimalsUnderlyingToken),
+            },
+        };
+    }
+    if (type === tokenType.euler_lend || type === tokenType.euler_borrow) {
+        const decimalsUnderlyingToken = ERC20Interface.decodeFunctionResult("decimals", calls[index].returnData)[0];
+        const symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index + 1].returnData)[0];
+        let call;
+        if (type === tokenType.euler_lend) {
+            call = {
+                allowFailure: true,
+                callData: eulerInterface.encodeFunctionData("totalAssets"),
+                target: typeInfo.tokenAddress,
+            };
+        }
+        else {
+            call = {
+                allowFailure: true,
+                callData: eulerInterface.encodeFunctionData("totalBorrows"),
+                target: typeInfo.vault,
+            };
+        }
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: typeInfo.tokenAddress,
+                },
+                call,
+            ].concat(blacklistedLiquidityCalls),
+            typeInfo: {
+                ...typeInfo,
+                decimalsUnderlyingToken: decimalsUnderlyingToken,
+                symbolUnderlyingToken: symbolUnderlyingToken,
+            },
+        };
+    }
+    if (type === tokenType.beefy) {
+        const symbolToken0 = ERC20Interface.decodeFunctionResult("symbol", calls[index].returnData)[0];
+        const symbolToken1 = ERC20Interface.decodeFunctionResult("symbol", calls[index + 1].returnData)[0];
+        const decimalsToken0 = ERC20Interface.decodeFunctionResult("decimals", calls[index + 2].returnData)[0];
+        const decimalsToken1 = ERC20Interface.decodeFunctionResult("decimals", calls[index + 3].returnData)[0];
+        const balanceToken0 = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 4].returnData)[0];
+        const balanceToken1 = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 5].returnData)[0];
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: typeInfo.underlyingToken,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: typeInfo.tokenAddress,
+                },
+            ],
+            typeInfo: {
+                ...typeInfo,
+                symbolToken0,
+                symbolToken1,
+                decimalsToken0,
+                decimalsToken1,
+                balanceToken0: BN2Number(balanceToken0, decimalsToken0),
+                balanceToken1: BN2Number(balanceToken1, decimalsToken1),
+            },
+        };
+    }
+    return {
+        type: type,
+        calls: [
+            {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                target: typeInfo.tokenAddress,
+            },
+        ]
+            .concat(blacklistedLiquidityCalls)
+            .concat(whitelistedLiquidityCalls),
+        typeInfo: {
+            ...typeInfo,
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound4RefactoFinal.js

@@ -0,0 +1,22 @@
+import { processorMapping } from "./processor/processorMapping";
+export function getTokenTypeRound4(index, type, typeInfo, calls, campaign) {
+    try {
+        const ProcessorClass = processorMapping[type];
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound4(index, type, typeInfo, returnValueOfCalls, campaign);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,38 @@
+import { BN2Number, ERC20Interface, } from "@sdk";
+import { Pricer } from "../../../utils/pricer";
+export async function ERC20_SNAPSHOTDynamicData(chainId, campaigns) {
+    const pricer = await Pricer.load();
+    const calls = [];
+    for (const campaign of campaigns) {
+        calls.push({
+            allowFailure: false,
+            callData: ERC20Interface.encodeFunctionData("totalSupply"),
+            target: campaign.campaignParameters.targetToken,
+        });
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                let i = 0;
+                const dynamicData = [];
+                for (const campaign of campaigns) {
+                    const priceTargetToken = await pricer.get({
+                        address: campaign.campaignParameters.targetToken,
+                        chainId,
+                        symbol: campaign.campaignParameters.symbolTargetToken,
+                    });
+                    const totalSupplyTargetToken = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[i++])[0], campaign.campaignParameters.decimalsTargetToken);
+                    dynamicData.push({
+                        ...campaign,
+                        totalSupplyTargetToken,
+                        tvl: totalSupplyTargetToken * priceTargetToken,
+                    });
+                }
+                return dynamicData;
+            },
+        },
+    };
+}

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

@@ -0,0 +1,165 @@
+import { BN2Number, ERC20Interface, EulerSubCampaignType, YEAR, } from "@sdk";
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { Pricer } from "../../../utils/pricer";
+import { fetchEulerVaultName } from "./ERC20SubTypes/helpers/eulerVaultNames";
+import { tokenType } from "./ERC20SubTypes/helpers/tokenType";
+import { getTokenPricesInfo } from "./ERC20SubTypes/subtypesPrices";
+import { enzymeInterface, factoryInterface, getTokenTypeRound1, metamorphoInterface, } from "./ERC20SubTypes/subtypesRound1";
+import { balancerPoolInterface, getTokenTypeRound2 } from "./ERC20SubTypes/subtypesRound2";
+import { getTokenTypeRound3 } from "./ERC20SubTypes/subtypesRound3";
+import { getTokenTypeRound4 } from "./ERC20SubTypes/subtypesRound4";
+export async function EulerDynamicData(chainId, campaigns) {
+    const pricer = await Pricer.load();
+    // Round 1: Get the high level type for each token (will need to be refined lated with more calls)
+    const callsRounds1 = [];
+    for (const campaign of campaigns) {
+        callsRounds1.push({
+            allowFailure: true,
+            callData: factoryInterface.encodeFunctionData("factory"),
+            target: campaign.campaignParameters.targetToken,
+        });
+        callsRounds1.push({
+            allowFailure: true,
+            callData: metamorphoInterface.encodeFunctionData("MORPHO"),
+            target: campaign.campaignParameters.targetToken,
+        });
+        callsRounds1.push({
+            allowFailure: true,
+            callData: ERC20Interface.encodeFunctionData("name"),
+            target: campaign.campaignParameters.targetToken,
+        });
+        callsRounds1.push({
+            allowFailure: true,
+            callData: balancerPoolInterface.encodeFunctionData("getPoolId"),
+            target: campaign.campaignParameters.targetToken,
+        });
+        callsRounds1.push({
+            allowFailure: true,
+            callData: enzymeInterface.encodeFunctionData("getCreator"),
+            target: campaign.campaignParameters.targetToken,
+        });
+    }
+    const resultRound1 = await batchMulticallCallWithRetry(chainId, {
+        calls: callsRounds1,
+    });
+    const tokenTypesByCampaign = {};
+    // Round 2: Decode result from round 1 and get some additional info for the types before the final calls
+    const callsRounds2 = [];
+    let i = 0;
+    for (const campaign of campaigns) {
+        let typeStruct = {
+            type: tokenType.unknown,
+            calls: [],
+            typeInfo: {},
+        };
+        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i);
+        i += 5;
+        tokenTypesByCampaign[campaign.campaignId] = typeStruct;
+        callsRounds2.push(...typeStruct.calls);
+    }
+    const resultRound2 = await batchMulticallCallWithRetry(chainId, {
+        calls: callsRounds2,
+    });
+    // Round 3: Decode result from round 2 and get some additional info for the types before the final calls
+    const callsRounds3 = [];
+    let j = 0;
+    for (const campaign of campaigns) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound2(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultRound2);
+        j += callsForCampaign;
+        callsRounds3.push(...tokenTypesByCampaign[campaign.campaignId].calls);
+    }
+    const resultRound3 = await batchMulticallCallWithRetry(chainId, {
+        calls: callsRounds3,
+    });
+    // Final round before execute
+    let callsFinal = [];
+    j = 0;
+    for (const campaign of campaigns) {
+        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound3(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultRound3);
+        j += callsForCampaign;
+        callsFinal = callsFinal.concat(tokenTypesByCampaign[campaign.campaignId].calls);
+    }
+    // Round 4: Get the final data
+    const resultsFinal = await batchMulticallCallWithRetry(chainId, {
+        calls: callsFinal,
+    });
+    j = 0;
+    let calls = [];
+    for (const campaign of campaigns) {
+        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound4(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultsFinal, campaign);
+        j += callsForCampaign;
+        calls = calls.concat(tokenTypesByCampaign[campaign.campaignId].calls);
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                let i = 0;
+                const dynamicData = [];
+                for (const campaign of campaigns) {
+                    const priceRewardToken = (await pricer.get({
+                        address: campaign.rewardToken,
+                        chainId,
+                        symbol: campaign.campaignParameters.symbolRewardToken,
+                    })) ?? 0;
+                    // Get the data from the final round and process it to get the price of the target token and some extra info
+                    const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+                    tokenTypesByCampaign[campaign.campaignId] = await getTokenPricesInfo(i, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, result, campaign, pricer);
+                    i += callsForCampaign;
+                    const totalSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply;
+                    let whitelistedSupplyTargetToken = totalSupplyTargetToken - tokenTypesByCampaign[campaign.campaignId].typeInfo.blacklistedSupply;
+                    const priceTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
+                    if (whitelistedSupplyTargetToken === 0) {
+                        whitelistedSupplyTargetToken = 0.00001;
+                    }
+                    const lastEligibilityRatio = 1;
+                    // if (!!campaign.campaignParameters.hooks?.length) {
+                    //   lastEligibilityRatio = await getLastEligibilityRatio(campaign, chainId, currentRoot!, []);
+                    // }
+                    // Card name part, There are many things not needed above I think
+                    let cardName = "";
+                    if (campaign.campaignSubType === EulerSubCampaignType.LEND) {
+                        cardName = `Supply ${campaign.campaignParameters.symbolTargetToken} on Euler V2`;
+                        const vaultName = await fetchEulerVaultName(campaign.campaignParameters.targetToken, campaign.computeChainId);
+                        if (!!vaultName) {
+                            cardName = `EULER Supply ${campaign.campaignParameters.symbolAsset} on ${vaultName} vault`;
+                        }
+                    }
+                    else {
+                        cardName = `EULER Borrow ${campaign.campaignParameters.symbolTargetToken} on Euler V2`;
+                        const vaultName = await fetchEulerVaultName(campaign.campaignParameters.targetToken, campaign.computeChainId);
+                        if (!!vaultName) {
+                            cardName = `Borrow ${campaign.campaignParameters.symbolAsset} from ${vaultName} vault`;
+                        }
+                        if (campaign.campaignSubType === EulerSubCampaignType.BORROW_FROM_COLLATERAL) {
+                            cardName = `${cardName} using ${campaign.campaignParameters.symbolCollateral}`;
+                        }
+                    }
+                    dynamicData.push({
+                        ...campaign,
+                        apr: (lastEligibilityRatio *
+                            (priceRewardToken *
+                                BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                                YEAR *
+                                100)) /
+                            campaign.campaignParameters.duration /
+                            (whitelistedSupplyTargetToken * priceTargetToken),
+                        totalSupplyTargetToken: whitelistedSupplyTargetToken,
+                        tvl: totalSupplyTargetToken * priceTargetToken,
+                        type: tokenTypesByCampaign[campaign.campaignId].type,
+                        typeInfo: { ...tokenTypesByCampaign[campaign.campaignId].typeInfo, cardName: cardName },
+                        priceRewardToken: priceRewardToken,
+                        lastEligibilityRatio,
+                    });
+                }
+                return dynamicData;
+            },
+        },
+    };
+}

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

@@ -0,0 +1,19 @@
+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;
+            },
+        },
+    };
+}