@merkl/api 0.10.165 → 0.10.167

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.d.ts

@@ -52,7 +52,8 @@ export declare enum tokenType {
     pendle = "pendle",
     maverickBoostedPosition = "maverickBoostedPosition",
     zkSwapThreePool = "zkSwapThreePool",
-    maha = "maha"
+    maha = "maha",
+    tempest = "tempest"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.js

@@ -54,6 +54,7 @@ export var tokenType;
     tokenType["maverickBoostedPosition"] = "maverickBoostedPosition";
     tokenType["zkSwapThreePool"] = "zkSwapThreePool";
     tokenType["maha"] = "maha";
+    tokenType["tempest"] = "tempest";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave" },
@@ -119,4 +120,7 @@ export const tokenTypeToProtocol = {
     [tokenType.maha]: {
         protocol: "Maha",
     },
+    [tokenType.tempest]: {
+        protocol: "Tempest",
+    },
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/TempestVaultProcessor.d.ts

@@ -0,0 +1,50 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawTempest;
+    call: string;
+    target: keyof callKeysTempest;
+    metaData?: keyof callKeysTempest;
+};
+type callKeysTempest = mandatoryCallKeys & {
+    addressToken0: string;
+    addressToken1: string;
+    addressesReturnData: string;
+};
+type dataRawTempest = callKeysTempest & {
+    addressToken0: string;
+    addressToken1: string;
+    addressesReturnData: {
+        [key: string]: string | number;
+    };
+    amount0Idle: string;
+    amount0Invested: string;
+    amount1Idle: string;
+    amount1Invested: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    positionsReturnData: {
+        [key: string]: string | number;
+    };
+    symbolToken0: string;
+    symbolToken1: string;
+};
+type dataTypeTempest = dataType & {
+    addressToken0: string;
+    addressToken1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+};
+export declare class TempestVaultProcessor extends GenericProcessor<callKeysTempest, dataRawTempest, dataTypeTempest> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawTempest): void;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawTempest, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeTempest>;
+}
+export {};

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

@@ -0,0 +1,48 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class TempestVaultProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "addressesReturnData", call: "getTokenAddresses", target: "tokenAddress" },
+            { key: "positionsReturnData", call: "getPositions", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "symbolToken0", call: "symbol", target: "addressToken0" },
+            { key: "symbolToken1", call: "symbol", target: "addressToken1" },
+            { key: "decimalsToken0", call: "decimals", target: "addressToken0" },
+            { key: "decimalsToken1", call: "decimals", target: "addressToken1" },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    processingRound2(typeInfo) {
+        typeInfo.addressToken0 = typeInfo.addressesReturnData[0];
+        typeInfo.addressToken1 = typeInfo.addressesReturnData[1];
+        typeInfo.amount0Invested = typeInfo.positionsReturnData[0];
+        typeInfo.amount1Invested = typeInfo.positionsReturnData[1];
+        typeInfo.amount0Idle = typeInfo.positionsReturnData[2];
+        typeInfo.amount1Idle = typeInfo.positionsReturnData[3];
+    }
+    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 amount0 = BN2Number(typeInfo.amount0Idle, decimalsToken0) + BN2Number(typeInfo.amount0Invested, decimalsToken0);
+        const amount1 = BN2Number(typeInfo.amount1Idle, decimalsToken1) + BN2Number(typeInfo.amount1Invested, decimalsToken1);
+        const tokenAPRice = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+        const tokenBPrice = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        const tvl = tokenAPRice * amount0 + tokenBPrice * amount1;
+        const priceTargetToken = tvl / totalSupply;
+        const { addressesReturnData, positionsReturnData, ...rest } = typeInfo;
+        return {
+            ...rest,
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+            priceTargetToken: priceTargetToken,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+        };
+    }
+}

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

@@ -20,6 +20,7 @@ import { RadiantProcessor } from "./RadiantProcessor";
 import { RfxProcessor } from "./RfxProcessor";
 import { SpliceProcessor } from "./SpliceProcessor";
 import { SturdySiloProcessor } from "./SturdySiloProcessor";
+import { TempestVaultProcessor } from "./TempestVaultProcessor";
 import { TorosProcessor } from "./TorosProcessor";
 import { UniswapProcessor } from "./UniswapProcessor";
 import { WoofiProcessor } from "./WoofiProcessor";
@@ -80,4 +81,5 @@ export const processorMapping = {
     [tokenType.maverickBoostedPosition]: MaverickBPProcessor,
     [tokenType.zkSwapThreePool]: ZkSwapThreePoolProcessor,
     [tokenType.maha]: StakedCurveProcessor,
+    [tokenType.tempest]: TempestVaultProcessor,
 };

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

@@ -90,6 +90,8 @@ function satisfiesNameConditions(name, type) {
             return lowerCaseName.includes("zf");
         case tokenType.maha:
             return lowerCaseName.includes("staked") && lowerCaseName.includes("maha");
+        case tokenType.tempest:
+            return lowerCaseName.startsWith("ts");
         default:
             return false;
     }

package/dist/src/modules/v4/reward/reward.repository.d.ts

@@ -149,7 +149,7 @@ export declare abstract class RewardRepository {
         campaignId: string;
         amount: bigint;
     }>;
-    static getUnclaimed(x: CampaignIdWithoutPageModel): Promise<{
+    static getAmountAndClaimedForCampaigns(root: string, x: CampaignIdWithoutPageModel): Promise<{
         campaignId: string;
         amount: string;
         claimed: string;

package/dist/src/modules/v4/reward/reward.repository.js

@@ -223,7 +223,7 @@ export class RewardRepository {
         }, { campaignId, amount: 0n });
         return reducedData;
     }
-    static async getUnclaimed(x) {
+    static async getAmountAndClaimedForCampaigns(root, x) {
         return await apiDbClient.rewardBreakdown.findMany({
             select: {
                 claimed: true,
@@ -234,6 +234,9 @@ export class RewardRepository {
                 campaignId: {
                     in: x.campaignIds.map(campaignId => CampaignService.hashId({ distributionChain: x.chainId, campaignId })),
                 },
+                Reward: {
+                    root,
+                },
             },
         });
     }

package/dist/src/modules/v4/reward/reward.service.js

@@ -264,7 +264,8 @@ export class RewardService {
             acc[CampaignService.hashId({ distributionChain: x.chainId, campaignId })] = campaignId;
             return acc;
         }, {});
-        const data = await RewardRepository.getUnclaimed(x);
+        const currentRoot = await MerklRootService.fetch(x.chainId);
+        const data = await RewardRepository.getAmountAndClaimedForCampaigns(currentRoot.live, x);
         return data.reduce((acc, { amount, campaignId, claimed }) => {
             if (!acc[campaignToCampaignIds[campaignId]])
                 acc[campaignToCampaignIds[campaignId]] = "0";

package/dist/src/utils/decodeCalls.js

@@ -1,4 +1,4 @@
-import { AaveInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerVaultInterface, BeefyInterface, CompoundInterface, CurveInterface, ERC20Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, IonicInterface, LayerBankInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, RadiantInterface, RfxInterface, SturdyInterface, TorosInterface, UniswapV2PoolInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
+import { AaveInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerVaultInterface, BeefyInterface, CompoundInterface, CurveInterface, ERC20Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, IonicInterface, LayerBankInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, RadiantInterface, RfxInterface, SturdyInterface, SymetricAmbientStrategyInterface, TorosInterface, UniswapV2PoolInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
 import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
 export function decodeCall(calls, index, key, type) {
     const returnData = calls[index];
@@ -174,6 +174,10 @@ export function decodeCall(calls, index, key, type) {
             return ZFStableSwapThreePoolInterface.decodeFunctionResult("coins", returnData)[0];
         case "minter":
             return ZFStableLPINterface.decodeFunctionResult("minter", returnData)[0];
+        case "getTokenAddresses":
+            return SymetricAmbientStrategyInterface.decodeFunctionResult("getTokenAddresses", returnData)[0];
+        case "getPositions":
+            return SymetricAmbientStrategyInterface.decodeFunctionResult("getPositions", returnData);
         default:
             throw new Error(`Key not recognized for ${key}`);
     }

package/dist/src/utils/encodeCalls.js

@@ -1,5 +1,5 @@
 import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
-import { AaveInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerVaultInterface, BeefyInterface, CompoundInterface, CurveInterface, ERC20Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, IonicInterface, LayerBankInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, RadiantInterface, RfxDatastoreInterface, SturdyInterface, TorosInterface, UniswapV2PoolInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
+import { AaveInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerVaultInterface, BeefyInterface, CompoundInterface, CurveInterface, ERC20Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, IonicInterface, LayerBankInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, RadiantInterface, RfxDatastoreInterface, SturdyInterface, SymetricAmbientStrategyInterface, TorosInterface, UniswapV2PoolInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
 import { fluidInterface } from "src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1";
 export function createCall(target, key, type, metaData) {
     switch (key) {
@@ -260,6 +260,18 @@ export function createCall(target, key, type, metaData) {
                 callData: ZFStableLPINterface.encodeFunctionData("minter"),
                 target: target,
             };
+        case "getTokenAddresses":
+            return {
+                allowFailure: true,
+                callData: SymetricAmbientStrategyInterface.encodeFunctionData("getTokenAddresses"),
+                target: target,
+            };
+        case "getPositions":
+            return {
+                allowFailure: true,
+                callData: SymetricAmbientStrategyInterface.encodeFunctionData("getPositions"),
+                target: target,
+            };
         default:
             throw new Error(`Unknown key ${key}`);
     }