@merkl/api 0.10.162 → 0.10.164

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

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

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

@@ -53,6 +53,7 @@ export var tokenType;
     tokenType["pendle"] = "pendle";
     tokenType["maverickBoostedPosition"] = "maverickBoostedPosition";
     tokenType["zkSwapThreePool"] = "zkSwapThreePool";
+    tokenType["maha"] = "maha";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave" },
@@ -115,4 +116,7 @@ export const tokenTypeToProtocol = {
     [tokenType.zkSwapThreePool]: {
         protocol: "ZKSwap",
     },
+    [tokenType.maha]: {
+        protocol: "Maha",
+    },
 };

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

@@ -25,6 +25,7 @@ import { UniswapProcessor } from "./UniswapProcessor";
 import { WoofiProcessor } from "./WoofiProcessor";
 import { ZkSwapThreePoolProcessor } from "./ZkSwapThreePoolProcessor";
 import { CurveProcessor } from "./curveProcessor";
+import { StakedCurveProcessor } from "./stakedCurveProcessor";
 export const processorMapping = {
     [tokenType.uniswapv2]: UniswapProcessor,
     [tokenType.balancerGauge]: BalancerGaugeProcessor,
@@ -78,4 +79,5 @@ export const processorMapping = {
     [tokenType.woofi]: WoofiProcessor,
     [tokenType.maverickBoostedPosition]: MaverickBPProcessor,
     [tokenType.zkSwapThreePool]: ZkSwapThreePoolProcessor,
+    [tokenType.maha]: StakedCurveProcessor,
 };

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

@@ -0,0 +1,54 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawStakedCurve;
+    call: string;
+    target: keyof callKeysStakedCurve;
+    metaData?: keyof callKeysStakedCurve;
+    optional?: boolean;
+};
+type callKeysStakedCurve = mandatoryCallKeys & {
+    lp_price: string;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+    underlying: string;
+    amount: string;
+};
+type dataRawStakedCurve = callKeysStakedCurve & {
+    poolTokens: {
+        [key: string]: string;
+    };
+    toAssets: string;
+    symbolUnderlyingToken: string;
+};
+type dataTypeStakedCurve = dataType & {
+    lp_price: number;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    underlying: string;
+    symbolToken2: string;
+    symbolUnderlyingToken: string;
+    poolTokens: {
+        [key: string]: string;
+    };
+};
+export declare class StakedCurveProcessor extends GenericProcessor<callKeysStakedCurve, dataRawStakedCurve, dataTypeStakedCurve> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound3(typeInfo: dataRawStakedCurve): void;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawStakedCurve, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeStakedCurve>;
+}
+export {};

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

@@ -0,0 +1,77 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { BigNumber } from "ethers";
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor } from "./GenericProcessor";
+export class StakedCurveProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
+        round2: [
+            { key: "lp_price", call: "lp_price", target: "underlying" },
+            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
+            { key: "token0", call: "coin0", target: "underlying" },
+            { key: "token1", call: "coin1", target: "underlying" },
+            { key: "token2", call: "coin2", target: "underlying", optional: true },
+        ],
+        round3: [
+            { key: "symbolToken0", call: "symbol", target: "token0" },
+            { key: "symbolToken1", call: "symbol", target: "token1" },
+            { key: "symbolToken2", call: "symbol", target: "token2", optional: true },
+        ],
+        round4: [
+            { key: "toAssets", call: "convertToAssets", target: "tokenAddress", metaData: "amount" },
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+        ],
+    };
+    // override computeRound1(): void {}
+    processingRound3(typeInfo) {
+        typeInfo.amount = BigNumber.from(10).pow(18).toString();
+    }
+    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 exchangeRate = BN2Number(typeInfo.toAssets, 18);
+        const tvl = priceTargetToken * totalSupply * exchangeRate;
+        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/subtypesRound1RefactoFinal.js

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

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

@@ -265,10 +265,12 @@ export class RewardService {
             return acc;
         }, {});
         const data = await RewardRepository.getUnclaimed(x);
-        return data.reduce((acc, { amount, campaignId }) => {
+        return data.reduce((acc, { amount, campaignId, claimed }) => {
             if (!acc[campaignToCampaignIds[campaignId]])
                 acc[campaignToCampaignIds[campaignId]] = "0";
-            acc[campaignToCampaignIds[campaignId]] = (BigInt(acc[campaignToCampaignIds[campaignId]]) + BigInt(amount)).toString();
+            acc[campaignToCampaignIds[campaignId]] = (BigInt(acc[campaignToCampaignIds[campaignId]]) +
+                BigInt(amount) -
+                BigInt(claimed)).toString();
             return acc;
         }, {});
     }

package/dist/src/routes/v3/rewards.d.ts

@@ -1,5 +1,10 @@
 import type { App } from "../../index";
 import { RewardService } from "../../modules/v4/reward";
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    user: import("@sinclair/typebox").TString;
+    creatorTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
 declare const _default: (app: App) => import("elysia").default<"", false, {
     decorator: {};
     store: {};

package/dist/src/routes/v3/rewards.js

@@ -1,14 +1,14 @@
 import { RewardService } from "../../modules/v4/reward";
 import { RewardConvertorService } from "../../modules/v4/reward/subservices/converter";
-import { throwOnInvalidRequiredAddress } from "../../utils/throw";
 import { ChainId, isSupportedChain } from "@sdk";
 import { t } from "elysia";
-const QueryDto = t.Object({
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+export const query = t.Object({
     chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
     user: t.String(),
     creatorTag: t.Optional(t.String()),
 });
-export default (app) => app.get("", async ({ query }) => {
+export default (app) => app.use(checkQueryAddressValidity()).get("", async ({ query }) => {
     let rawChainIds = query.chainIds;
     if (typeof rawChainIds === "string" && rawChainIds.includes(",")) {
         rawChainIds = rawChainIds.split(",");
@@ -30,10 +30,4 @@ export default (app) => app.get("", async ({ query }) => {
     const v4Res = await RewardService.getUserRewardsByChain(user, false, chainIds);
     const v3Res = RewardConvertorService.convertV4toRewardV3(v4Res);
     return v3Res;
-}, {
-    query: QueryDto,
-    tags: ["Rewards"],
-    beforeHandle: ({ query }) => {
-        throwOnInvalidRequiredAddress(query.user);
-    },
-});
+}, { query, tags: ["Rewards"] });

package/dist/src/utils/decodeCalls.js

@@ -79,6 +79,7 @@ export function decodeCall(calls, index, key, type) {
                     return LayerBankInterface.decodeFunctionResult("underlying", returnData)[0];
                 case tokenType.euler_borrow:
                 case tokenType.euler_lend:
+                case tokenType.maha:
                     return EulerInterface.decodeFunctionResult("asset", returnData)[0];
                 default:
                     throw new Error(`Need tokenType for this key ${key}, or type ${type} not matched`);
@@ -111,6 +112,7 @@ export function decodeCall(calls, index, key, type) {
                 case tokenType.curve:
                     return CurveInterface.decodeFunctionResult("lp_price", returnData)[0];
                 case tokenType.curve_2:
+                case tokenType.maha:
                     return CurveInterface.decodeFunctionResult("get_virtual_price", returnData)[0];
                 default:
                     throw new Error(`Need tokenType for this key ${key}`);

package/dist/src/utils/encodeCalls.js

@@ -12,6 +12,7 @@ export function createCall(target, key, type, metaData) {
                 case tokenType.curve:
                     return { allowFailure: true, callData: CurveInterface.encodeFunctionData("lp_price"), target };
                 case tokenType.curve_2:
+                case tokenType.maha:
                     return { allowFailure: true, callData: CurveInterface.encodeFunctionData("get_virtual_price"), target };
                 default:
                     throw new Error(`Need tokenType for this key ${key}`);
@@ -68,6 +69,7 @@ export function createCall(target, key, type, metaData) {
                 case tokenType.fluid:
                     return { allowFailure: true, callData: FluidInterface.encodeFunctionData("asset"), target };
                 case tokenType.euler_borrow:
+                case tokenType.maha:
                 case tokenType.euler_lend:
                     return {
                         allowFailure: true,

package/dist/src/utils/generateCardName.js

@@ -87,6 +87,8 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
             return `Hold (or stake) Maverick Boosted Position ${campaign.campaignParameters.symbolTargetToken} on ${typeInfo.protocol}`;
         case tokenType.zkSwapThreePool:
             return `Hold (or stake) ${campaign.campaignParameters.symbolTargetToken} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}-${typeInfo.symbolToken2} on ${typeInfo.protocol}`;
+        case tokenType.maha:
+            return `Stake ${typeInfo.symbolToken0}/${typeInfo.symbolToken1} LP on ${typeInfo.protocol}`;
         default:
             return `Hold ${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken})`;
     }