@merkl/api 0.10.129 → 0.10.130

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SturdySiloProcessor.js

@@ -0,0 +1,37 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class SturdySiloProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "underlying", call: "underlying", target: "tokenAddress" },
+            { key: "sharePrice", call: "pricePerShare", target: "tokenAddress" },
+            { key: "collateral", call: "collateralContract", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
+            { key: "symbolCollateral", call: "symbol", target: "collateral" },
+            { key: "decimalsUnderlyingToken", call: "decimals", target: "underlying" },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const sharePrice = BN2Number(typeInfo.sharePrice, 18);
+        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 1;
+        const tvl = sharePrice * totalSupply * priceUnderlying;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            tvl,
+            sharePrice,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/TemplateProcessor.js

@@ -0,0 +1,40 @@
+import { GenericProcessor } from "./GenericProcessor";
+export class TemplateProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [],
+        round3: [],
+        round4: [],
+    };
+    // override computeRound1(): void {}
+    processingRound1(typeInfo) {
+        super.processingRound1(typeInfo);
+    }
+    processingRound2(typeInfo) {
+        super.processingRound2(typeInfo);
+    }
+    processingRound3(typeInfo) {
+        super.processingRound3(typeInfo);
+    }
+    processingRound4(typeInfo) {
+        super.processingRound4(typeInfo);
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        return super.processingRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+    computeRound1(type, typeInfo) {
+        return super.computeRound1(type, typeInfo);
+    }
+    computeRound2(index, type, typeInfo, calls) {
+        return super.computeRound2(index, type, typeInfo, calls);
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        return super.computeRound4(index, type, typeInfo, calls, campaign);
+    }
+    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
+        return super.computeRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/TorosProcessor.js

@@ -0,0 +1,33 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class TorosProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [],
+        round3: [],
+        round4: [
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+            { key: "tokenPrice", call: "tokenPrice", target: "tokenAddress" },
+        ],
+    };
+    // override computeRound1(): void {}
+    async processingRound5(_index, type, typeInfo, _calls, campaign, _pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceTargetToken = BN2Number(typeInfo.tokenPrice, 18);
+        const tvl = priceTargetToken * totalSupply;
+        let symbolUnderlyingToken = "unknow";
+        const match = typeInfo.name.match(/\b[A-Z]+\b/g);
+        symbolUnderlyingToken = match ? match[0] : "unknown";
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            symbolUnderlyingToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/UniswapProcessor.js

@@ -0,0 +1,48 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class UniswapProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "token0", call: "token0", target: "tokenAddress" },
+            { key: "token1", call: "token1", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "symbolToken0", call: "symbol", target: "token0" },
+            { key: "symbolToken1", call: "symbol", target: "token1" },
+            { key: "decimalsToken0", call: "decimals", target: "token0" },
+            { key: "decimalsToken1", call: "decimals", target: "token1" },
+            { key: "balanceToken0", call: "balanceOf", target: "token0", metaData: "tokenAddress" },
+            { key: "balanceToken1", call: "balanceOf", target: "token1", metaData: "tokenAddress" },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const decimalsToken0 = Number(typeInfo.decimalsToken0);
+        const decimalsToken1 = Number(typeInfo.decimalsToken1);
+        const priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+        const priceToken1 = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        const balanceToken0 = BN2Number(typeInfo.balanceToken0, decimalsToken0);
+        const balanceToken1 = BN2Number(typeInfo.balanceToken1, decimalsToken1);
+        let tvl = 0;
+        if (priceToken0 !== 0 && priceToken1 !== 0) {
+            tvl = priceToken0 * balanceToken0 + priceToken1 * balanceToken1;
+        }
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            priceTargetToken,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            tvl,
+            cardName: generateCardName(type, typeInfo, campaign),
+            decimalsToken0,
+            decimalsToken1,
+            balanceToken0,
+            balanceToken1,
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/WoofiProcessor.js

@@ -0,0 +1,40 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class WoofiProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "pricePerShare", call: "getPricePerFullShare", target: "tokenAddress" },
+            { key: "underlying", call: "want", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "symbolUnderlying", call: "symbol", target: "underlying" },
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+            { key: "decimalsToken", call: "decimals", target: "underlying" },
+        ],
+        round3: [],
+        round4: [],
+    };
+    // override computeRound1(): void {}
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceToken = (await pricer.get({ symbol: typeInfo.symbolUnderlying })) ?? 0;
+        let normalizedFactor = 1;
+        if (Number(typeInfo.decimalsToken) < campaign.campaignParameters.decimalsTargetToken) {
+            normalizedFactor = 10 ** (campaign.campaignParameters.decimalsTargetToken - Number(typeInfo.decimalsToken));
+        }
+        const pricePerShare = BN2Number(typeInfo.pricePerShare);
+        const priceTargetToken = priceToken * pricePerShare * normalizedFactor;
+        const tvl = priceTargetToken * totalSupply;
+        return {
+            ...typeInfo,
+            priceTargetToken,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+            pricePerShare,
+            tvl,
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/curveProcessor.js

@@ -0,0 +1,68 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor } from "./GenericProcessor";
+export class CurveProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "lp_price", call: "lp_price", target: "tokenAddress" },
+            { key: "token0", call: "coin0", target: "tokenAddress" },
+            { key: "token1", call: "coin1", target: "tokenAddress" },
+            { key: "token2", call: "coin2", target: "tokenAddress", optional: true },
+        ],
+        round2: [
+            { key: "symbolToken0", call: "symbol", target: "token0" },
+            { key: "symbolToken1", call: "symbol", target: "token1" },
+            { key: "symbolToken2", call: "symbol", target: "token2", optional: true },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const lp_price = BN2Number(typeInfo.lp_price, 18);
+        let priceTargetToken = lp_price;
+        if (typeInfo.token2) {
+            typeInfo.poolTokens = {
+                [typeInfo.token0]: typeInfo.symbolToken0,
+                [typeInfo.token1]: typeInfo.symbolToken1,
+                [typeInfo.token2]: typeInfo.symbolToken2,
+            };
+        }
+        else {
+            typeInfo.poolTokens = {
+                [typeInfo.token0]: typeInfo.symbolToken0,
+                [typeInfo.token1]: typeInfo.symbolToken1,
+            };
+        }
+        if (type === tokenType.curve_2) {
+            const prices = [];
+            for (const symbol of Object.values(typeInfo.poolTokens)) {
+                const price = (await pricer.get({ symbol: symbol })) ?? 0;
+                prices.push(price);
+            }
+            let minPrice = Math.min(...prices);
+            if (!minPrice) {
+                minPrice = 1;
+            }
+            priceTargetToken = priceTargetToken * minPrice;
+        }
+        const tvl = priceTargetToken * totalSupply;
+        return {
+            ...typeInfo,
+            lp_price,
+            poolTokens: {
+                [typeInfo.token0]: typeInfo.symbolToken0,
+                [typeInfo.token1]: typeInfo.symbolToken1,
+                [typeInfo.token2]: typeInfo.symbolToken2,
+            },
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/processorMapping.js

@@ -0,0 +1,77 @@
+import { tokenType } from "../helpers/tokenType";
+import { AaveProcessor } from "./AaveProcessor";
+import { AssetProcessor } from "./AssetProcessor";
+import { AuraProcessor } from "./AuraProcessor";
+import { BalancerGaugeProcessor } from "./BalancerGaugeProcessor";
+import { BalancerPoolProcessor } from "./BalancerPoolProcessor";
+import { BeefyProcessor } from "./BeefyProcessor";
+import { CompoundProcessor } from "./CompoundProcessor";
+import { EnzymeProcessor } from "./EnzymeProcessor";
+import { EulerBorrowProcessor } from "./EulerBorrowProcessor";
+import { EulerLendProcessor } from "./EulerLendProcessor";
+import { FluidProcessor } from "./FluidProcessor";
+import { FraxProcessor } from "./FraxProcessor";
+import { GearboxProcessor } from "./GearboxProcessor";
+import { GenericProcessor } from "./GenericProcessor";
+import { MetamorphoProcessor } from "./MetamorphoProcessor";
+import { PendleProcessor } from "./PendleProcessor";
+import { RadiantProcessor } from "./RadiantProcessor";
+import { RfxProcessor } from "./RfxProcessor";
+import { SpliceProcessor } from "./SpliceProcessor";
+import { SturdySiloProcessor } from "./SturdySiloProcessor";
+import { TorosProcessor } from "./TorosProcessor";
+import { UniswapProcessor } from "./UniswapProcessor";
+import { WoofiProcessor } from "./WoofiProcessor";
+import { CurveProcessor } from "./curveProcessor";
+export const processorMapping = {
+    [tokenType.uniswapv2]: UniswapProcessor,
+    [tokenType.balancerGauge]: BalancerGaugeProcessor,
+    [tokenType.balancerPool]: BalancerPoolProcessor,
+    [tokenType.syncswap]: UniswapProcessor,
+    [tokenType.ra]: UniswapProcessor,
+    [tokenType.yei_borrowing]: AaveProcessor,
+    [tokenType.yei_lending]: AaveProcessor,
+    [tokenType.zerolend_borrowing]: AaveProcessor,
+    [tokenType.zerolend_lending]: AaveProcessor,
+    [tokenType.ironclad_lending]: AaveProcessor,
+    [tokenType.ironclad_borrowing]: AaveProcessor,
+    [tokenType.poolside]: UniswapProcessor,
+    [tokenType.gearbox]: GearboxProcessor,
+    [tokenType.compound]: CompoundProcessor,
+    [tokenType.radiant_borrow]: RadiantProcessor,
+    [tokenType.radiant_lend]: RadiantProcessor,
+    [tokenType.ionic]: AssetProcessor,
+    [tokenType.metamorpho]: MetamorphoProcessor,
+    [tokenType.aerodrome]: UniswapProcessor,
+    [tokenType.velodrome]: UniswapProcessor,
+    [tokenType.moonwell]: AssetProcessor,
+    [tokenType.aave_lending]: AaveProcessor,
+    [tokenType.aave_borrowing]: AaveProcessor,
+    [tokenType.fraxlend]: FraxProcessor,
+    [tokenType.curve]: CurveProcessor,
+    [tokenType.sturdy_aggregator]: FraxProcessor,
+    [tokenType.koi]: UniswapProcessor,
+    [tokenType.baseswap]: UniswapProcessor,
+    [tokenType.layerbank]: AssetProcessor,
+    [tokenType.zkswap]: UniswapProcessor,
+    [tokenType.akron]: UniswapProcessor,
+    [tokenType.aura]: AuraProcessor,
+    [tokenType.dragonswap]: UniswapProcessor,
+    [tokenType.sturdy_silo]: SturdySiloProcessor,
+    [tokenType.silostaking]: FraxProcessor,
+    [tokenType.fluid]: FluidProcessor,
+    [tokenType.filament]: FluidProcessor,
+    [tokenType.enzyme]: EnzymeProcessor,
+    [tokenType.curve_2]: CurveProcessor,
+    [tokenType.fenix]: UniswapProcessor,
+    [tokenType.euler_lend]: EulerLendProcessor,
+    [tokenType.euler_borrow]: EulerBorrowProcessor,
+    [tokenType.beefy]: BeefyProcessor,
+    [tokenType.unknown]: GenericProcessor,
+    [tokenType.toros]: TorosProcessor,
+    [tokenType.splice]: SpliceProcessor,
+    [tokenType.pendle]: PendleProcessor,
+    [tokenType.ironcladStaking]: GenericProcessor,
+    [tokenType.rfx]: RfxProcessor,
+    [tokenType.woofi]: WoofiProcessor,
+};