@merkl/api 0.20.62 → 0.20.63

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

@@ -4,6 +4,7 @@ import { AmbiantDynamicData } from "./implementations/Ambiant";
 import { BadgerDynamicData } from "./implementations/Badger";
 import { ClammDynamicData } from "./implementations/Clamm";
 import { CompoundDynamicData } from "./implementations/Compound";
+import { CompoundV3DynamicData } from "./implementations/CompoundV3";
 import { DolomiteDynamicData } from "./implementations/Dolomite";
 import { EigenLayerDynamicData } from "./implementations/EigenLayer";
 import { EncompassingDynamicData } from "./implementations/Encompassing";
@@ -27,6 +28,8 @@ const map = {
     [Campaign.BADGER]: new BadgerDynamicData(),
     [Campaign.CLAMM]: new ClammDynamicData(),
     [Campaign.COMPOUND]: new CompoundDynamicData(),
+    [Campaign.COMPOUND_V3]: new CompoundV3DynamicData(),
+    [Campaign.COMPOUND_V3_FIXAPR]: new CompoundV3DynamicData(),
     [Campaign.DOLOMITE]: new DolomiteDynamicData(),
     [Campaign.EIGENLAYER]: new EigenLayerDynamicData(),
     [Campaign.ENCOMPASSING]: new EncompassingDynamicData(),
@@ -53,8 +56,6 @@ const map = {
     [Campaign.MAVERICK_BP]: new DefaultDynamicData(), // TODO
     [Campaign.ERC6909]: new DefaultDynamicData(), // TODO
     [Campaign.ERC6909FIXAPR]: new DefaultDynamicData(), // TODO
-    [Campaign.COMPOUND_V3]: new DefaultDynamicData(), // TODO,
-    [Campaign.COMPOUND_V3_FIXAPR]: new DefaultDynamicData(), // TODO
     [Campaign.ERC1155]: new DefaultDynamicData(), // TODO
     [Campaign.ERC1155FIXAPR]: new DefaultDynamicData(), // TODO
 };

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

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

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

@@ -0,0 +1,69 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { BN2Number, ChainInteractionService, CompoundV3Interface, CompoundV3SubCampaignType, NULL_ADDRESS, YEAR, } from "@sdk";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+export class CompoundV3DynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        const calls = [];
+        for (const campaign of campaigns) {
+            if (campaign.campaignSubType === CompoundV3SubCampaignType.SUPPLY) {
+                calls.push({
+                    allowFailure: true,
+                    callData: CompoundV3Interface.encodeFunctionData("totalSupply"),
+                    target: campaign.campaignParameters.targetToken,
+                });
+                calls.push({
+                    allowFailure: true,
+                    callData: CompoundV3Interface.encodeFunctionData("baseToken"),
+                    target: campaign.campaignParameters.targetToken,
+                });
+            }
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            let totalSupply;
+            let underlyingToken;
+            if (campaign.campaignSubType === CompoundV3SubCampaignType.SUPPLY) {
+                try {
+                    totalSupply = BN2Number(CompoundV3Interface.decodeFunctionResult("totalSupply", result[i++].returnData)[0], campaign.campaignParameters.decimalsTargetToken);
+                    underlyingToken = CompoundV3Interface.decodeFunctionResult("baseToken", result[i++].returnData)[0];
+                }
+                catch {
+                    log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and token ${campaign.campaignParameters.targetToken}`);
+                    totalSupply = 0.0000001;
+                    underlyingToken = NULL_ADDRESS;
+                }
+            }
+            else {
+                totalSupply = 0.0000001;
+                underlyingToken = NULL_ADDRESS;
+            }
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            const priceTargetToken = (await pricer.get({
+                address: underlyingToken,
+                chainId: campaign.computeChainId,
+                // Remove the `c` at the beginning of the symbol and the `v3` at the end
+                symbol: campaign.campaignParameters.symbolTargetToken.slice(1, -2),
+            })) ?? 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];
+            apr = rewardToken.isPoint ? apr / 365 / 100 : apr;
+            dynamicData.push({
+                ...campaign,
+                apr,
+                totalSupplyTargetToken: totalSupply,
+                tvl: totalSupply * priceTargetToken,
+                priceRewardToken: priceRewardToken,
+            });
+        }
+        return dynamicData;
+    }
+}

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

@@ -4,6 +4,7 @@ import { AmbientMetadata } from "./implementations/Ambient";
 import { BadgerMetadata } from "./implementations/Badger";
 import { ClammMetadata } from "./implementations/Clamm";
 import { CompoundMetadata } from "./implementations/Compound";
+import { CompoundV3Metadata } from "./implementations/CompoundV3";
 import { DefaultMetadata } from "./implementations/Default";
 import { DolomiteMetadata } from "./implementations/Dolomite";
 import { EigenLayerMetadata } from "./implementations/EigenLayer";
@@ -35,6 +36,8 @@ const map = {
     [Campaign.AJNA]: new AjnaMetadata(),
     [Campaign.EULER]: new EulerMetadata(),
     [Campaign.COMPOUND]: new CompoundMetadata(),
+    [Campaign.COMPOUND_V3]: new CompoundV3Metadata(),
+    [Campaign.COMPOUND_V3_FIXAPR]: new CompoundV3Metadata(),
     [Campaign.ION]: new IonMetadata(),
     [Campaign.MORPHO]: new MorphoMetadata(),
     [Campaign.HYPERDRIVELOGFIXPROCESSOR]: new HyperdriveMetadata(),
@@ -56,8 +59,6 @@ const map = {
     [Campaign.MAVERICK_BP]: new DefaultMetadata(), // TODO
     [Campaign.ERC6909]: new DefaultMetadata(), // TODO
     [Campaign.ERC6909FIXAPR]: new DefaultMetadata(), // TODO
-    [Campaign.COMPOUND_V3]: new DefaultMetadata(), // TODO,
-    [Campaign.COMPOUND_V3_FIXAPR]: new DefaultMetadata(), // TODO
     [Campaign.ERC1155]: new DefaultMetadata(), // TODO
     [Campaign.ERC1155FIXAPR]: new DefaultMetadata(), // TODO
 };

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

@@ -0,0 +1,17 @@
+import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { ProtocolId } from "../../../modules/v4/protocol/protocol.model";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.COMPOUND_V3;
+export declare class CompoundV3Metadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: ProtocolId;
+        depositUrl: undefined;
+    }>;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import { OpportunityAction } from "@db/api";
+import { CompoundV3SubCampaignType } from "@sdk";
+export class CompoundV3Metadata {
+    async build(computeChainId, params, subType) {
+        const symbolUnderlyingToken = params.symbolTargetToken.slice(1, -2);
+        return {
+            action: subType === CompoundV3SubCampaignType.SUPPLY ? OpportunityAction.LEND : OpportunityAction.BORROW,
+            name: [
+                subType === CompoundV3SubCampaignType.SUPPLY
+                    ? `Supply ${symbolUnderlyingToken} on`
+                    : `Borrow ${symbolUnderlyingToken} on`,
+                "Compound V3",
+            ].join(" "),
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: "compound",
+            depositUrl: undefined, // TODO, shall depend on compFork
+        };
+    }
+}

package/dist/src/jobs/update-analytics.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/jobs/update-analytics.js

@@ -0,0 +1,21 @@
+import { CacheService } from "@/modules/v4/cache";
+import { TTLPresets } from "@/modules/v4/cache/cache.model";
+import { RewardService } from "@/modules/v4/reward";
+import { log } from "@/utils/logger";
+const main = async () => {
+    const today = new Date();
+    const firstDayOfMonth = new Date(today.getFullYear(), today.getMonth(), 1).getTime() / 1000;
+    const promises = [
+        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributed, firstDayOfMonth).then(() => log.info("Total Distributed cache updated successfully")),
+        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByChains, firstDayOfMonth).then(() => log.info("Total Distributed by Chains cache updated successfully")),
+        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByType, firstDayOfMonth).then(() => log.info("Total Distributed by Type cache updated successfully")),
+        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByOpportunities, firstDayOfMonth).then(() => log.info("Total Distributed by Opportunities cache updated successfully")),
+    ];
+    await Promise.all(promises);
+};
+main()
+    .then(() => process.exit(0))
+    .catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/src/jobs/update-rpc-calls-cache.js

@@ -3,7 +3,8 @@ import { TTLPresets } from "@/modules/v4/cache/cache.model";
 import { ChainService } from "@/modules/v4/chain/chain.service";
 import { MerklRootRepository } from "@/modules/v4/merklRoot/merklRoot.repository";
 import { OpportunityService } from "@/modules/v4/opportunity";
-import { NETWORK_LABELS, log } from "@sdk";
+import { log } from "@/utils/logger";
+import { NETWORK_LABELS } from "@sdk";
 const main = async () => {
     try {
         const chains = await ChainService.getSupportedIds();

package/dist/src/modules/v4/campaign/campaign.controller.js

@@ -5,6 +5,8 @@ import { ChainUniqueDto } from "@/modules/v4/chain/chain.model";
 import { Campaign } from "@sdk";
 import Elysia, { t } from "elysia";
 import { throwOnUnsupportedChainId } from "src/utils/throw";
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
 import { DynamicDataService } from "../dynamicData/dynamicData.service";
 import { OpportunityConvertorService } from "../opportunity/opportunity.converter";
 import { CampaignResourceDto, CreateCampaignDto, GetCampaignQueryDto, RemoveManualOverrideDto, UpdateCampaignCreatorDto, UpdateCampaignDto, UpdateMetaDataCampaignDto, } from "./campaign.model";
@@ -149,6 +151,6 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
     beforeHandle: BackOfficeGuard,
     detail: { hide: true },
 })
-    .get("count/by-chains", async ({ query }) => await CampaignService.countByChains(query))
-    .get("/count/by-types", async ({ query }) => await CampaignService.countByType(query))
-    .get("/count/by-protocols", async ({ query }) => await CampaignService.countByProtocol(query));
+    .get("count/by-chains", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByChains, query))
+    .get("/count/by-types", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByType, query))
+    .get("/count/by-protocols", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByProtocol, query));

package/dist/src/modules/v4/opportunity/opportunity.controller.js

@@ -33,6 +33,7 @@ export const OpportunityController = new Elysia({
     params: OpportunityUniqueDto,
     body: OpportunityDeleteOverrideDto,
     beforeHandle: BackOfficeGuard,
+    detail: { hide: true },
 })
     // ─── Tries to reparse An Opportunity ─────────────────────────────────
     .post("/:id", async ({ params }) => {

package/dist/src/modules/v4/programPayload/programPayload.model.d.ts

@@ -1,4 +1,4 @@
-import type { Campaign, CompFork, CompoundSubCampaignType, Forwarder, ForwarderParameters, HOOK, HookParameters, MerklChainId, MorphoSubCampaignType } from "@sdk";
+import type { Campaign, CompFork, CompoundSubCampaignType, CompoundV3SubCampaignType, Forwarder, ForwarderParameters, HOOK, HookParameters, MerklChainId, MorphoSubCampaignType } from "@sdk";
 export declare const CampaignPayloadInputDto: import("@sinclair/typebox").TObject<{
     campaign: import("@sinclair/typebox").TString;
     program: import("@sinclair/typebox").TString;
@@ -154,6 +154,16 @@ export type partialConfigERC20 = {
     forwarders: ForwarderParameters<Forwarder>[];
     apr?: number;
 };
+export type partialConfigCompoundV3 = {
+    computeChainId?: MerklChainId;
+    hooks?: (HookParameters<HOOK> | string)[];
+    campaignType: Campaign;
+    targetToken: string;
+    whitelist: string[];
+    blacklist: string[];
+    url?: string;
+    subCampaignType: CompoundV3SubCampaignType;
+};
 export type partialConfigMorpho = {
     computeChainId?: MerklChainId;
     hooks?: (HookParameters<HOOK> | string)[];
@@ -200,7 +210,7 @@ export type partialConfigAirdrop = {
     hooks?: (HookParameters<HOOK> | string)[];
     campaignType: Campaign;
 };
-export type partialConfig = partialConfigERC20 | partialConfigMorpho | partialConfigCLAMM | partialConfigIonic | partialConfigAirdrop;
+export type partialConfig = partialConfigERC20 | partialConfigMorpho | partialConfigCLAMM | partialConfigIonic | partialConfigCompoundV3 | partialConfigAirdrop;
 export declare const safeTemplate: {
     version: string;
     chainId: string;

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

@@ -18,7 +18,8 @@ export declare enum roninCampaigns {
     Katana_WETH_RON_Ronin = "Katana WETH-RON Ronin 0x90f31f1907a4d1443a6aacdc91ac2312f91bafa7",
     Katana_AXS_RON_Ronin = "Katana AXS-RON Ronin 0x3230b903e8a5d6e46b5a5028470dd33e7b673722",
     Katana_USDC_RON_Ronin = "Katana USDC-RON Ronin 0x392d372f2a51610e9ac5b741379d5631ca9a1c7f",
-    Katana_LRON_RON_Ronin = "Katana LRON-RON Ronin 0x0fbe1a7f0f006a4a4d817b2aa922889612758ce8"
+    Katana_LRON_RON_Ronin = "Katana LRON-RON Ronin 0x0fbe1a7f0f006a4a4d817b2aa922889612758ce8",
+    Supply_WETH_Compound_Ronin = "Supply WETH Compound Ronin 0x4006ed4097ee51c09a04c3b0951d28ccf19e6dfe"
 }
 export declare enum anglesCampaigns {
     Angles_supply_in_angles_liquid = "0x15E96CDecA34B9DE1B31586c1206206aDb92E69D",
@@ -476,6 +477,16 @@ declare const RoninInterfaceCampaigns: {
         weightToken0: number;
         weightToken1: number;
     };
+    "Supply WETH Compound Ronin 0x4006ed4097ee51c09a04c3b0951d28ccf19e6dfe": {
+        campaignType: any;
+        computeChainId: any;
+        hooks: never[];
+        targetToken: string;
+        whitelist: never[];
+        blacklist: never[];
+        url: string;
+        subCampaignType: any;
+    };
 };
 export declare enum tacCampaigns {
     TAC_Supply_TACETH = "TAC Supply tacETH 0x294eecec65A0142e84AEdfD8eB2FBEA8c9a9fbad",

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

@@ -1,4 +1,4 @@
-import { BalanceCallType, Campaign, ChainId, CompFork, CompoundSubCampaignType, ComputeScoreMethod, Forwarder, HOOK, MorphoSubCampaignType, StandardType, boostingFunction, boostingReferralFunction, contractStateBoost, defaultBoost, defaultReferralBoost, selectionRaffleMethod, } from "@sdk";
+import { BalanceCallType, Campaign, ChainId, CompFork, CompoundSubCampaignType, CompoundV3SubCampaignType, ComputeScoreMethod, Forwarder, HOOK, MorphoSubCampaignType, StandardType, boostingFunction, boostingReferralFunction, contractStateBoost, defaultBoost, defaultReferralBoost, selectionRaffleMethod, } from "@sdk";
 import { id } from "ethers/lib/utils";
 export var program;
 (function (program) {
@@ -22,6 +22,7 @@ export var roninCampaigns;
     roninCampaigns["Katana_AXS_RON_Ronin"] = "Katana AXS-RON Ronin 0x3230b903e8a5d6e46b5a5028470dd33e7b673722";
     roninCampaigns["Katana_USDC_RON_Ronin"] = "Katana USDC-RON Ronin 0x392d372f2a51610e9ac5b741379d5631ca9a1c7f";
     roninCampaigns["Katana_LRON_RON_Ronin"] = "Katana LRON-RON Ronin 0x0fbe1a7f0f006a4a4d817b2aa922889612758ce8";
+    roninCampaigns["Supply_WETH_Compound_Ronin"] = "Supply WETH Compound Ronin 0x4006ed4097ee51c09a04c3b0951d28ccf19e6dfe";
 })(roninCampaigns || (roninCampaigns = {}));
 export var anglesCampaigns;
 (function (anglesCampaigns) {
@@ -502,9 +503,9 @@ const RoninInterfaceCampaigns = {
         url: "https://app.roninchain.com/liquidity/v3/0x90f31f1907a4d1443a6aacdc91ac2312f91bafa7",
         forwarders: [],
         isOutOfRangeIncentivized: false,
-        weightFees: 2000,
-        weightToken0: 4000,
-        weightToken1: 4000,
+        weightFees: 1500,
+        weightToken0: 1500,
+        weightToken1: 7000,
     },
     [roninCampaigns.Katana_AXS_RON_Ronin]: {
         campaignType: Campaign.CLAMM,
@@ -516,9 +517,9 @@ const RoninInterfaceCampaigns = {
         url: "https://app.roninchain.com/liquidity/v3/0x3230b903e8a5d6e46b5a5028470dd33e7b673722",
         forwarders: [],
         isOutOfRangeIncentivized: false,
-        weightFees: 2000,
-        weightToken0: 4000,
-        weightToken1: 4000,
+        weightFees: 1000,
+        weightToken0: 3500,
+        weightToken1: 5500,
     },
     [roninCampaigns.Katana_USDC_RON_Ronin]: {
         campaignType: Campaign.CLAMM,
@@ -530,9 +531,9 @@ const RoninInterfaceCampaigns = {
         url: "https://app.roninchain.com/liquidity/v3/0x392d372f2a51610e9ac5b741379d5631ca9a1c7f",
         forwarders: [],
         isOutOfRangeIncentivized: false,
-        weightFees: 2000,
-        weightToken0: 4000,
-        weightToken1: 4000,
+        weightFees: 1000,
+        weightToken0: 2500,
+        weightToken1: 6500,
     },
     [roninCampaigns.Katana_LRON_RON_Ronin]: {
         campaignType: Campaign.CLAMM,
@@ -544,9 +545,19 @@ const RoninInterfaceCampaigns = {
         url: "https://app.roninchain.com/liquidity/v3/0x0fbe1a7f0f006a4a4d817b2aa922889612758ce8",
         forwarders: [],
         isOutOfRangeIncentivized: false,
-        weightFees: 2000,
-        weightToken0: 4000,
-        weightToken1: 4000,
+        weightFees: 1000,
+        weightToken0: 4500,
+        weightToken1: 4500,
+    },
+    [roninCampaigns.Supply_WETH_Compound_Ronin]: {
+        campaignType: Campaign.COMPOUND_V3,
+        computeChainId: ChainId.RONIN,
+        hooks: [],
+        targetToken: "0x4006eD4097Ee51c09A04c3B0951D28CCf19e6DFE",
+        whitelist: [],
+        blacklist: [],
+        url: "",
+        subCampaignType: CompoundV3SubCampaignType.SUPPLY,
     },
 };
 export var tacCampaigns;

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

@@ -6,6 +6,8 @@ import { TokenService } from "@/modules/v4/token/token.service";
 import bigintToString from "@/utils/bigintToString";
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
 import Elysia, { t } from "elysia";
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
 import { CampaignIdDto, CampaignIdWithoutPageDto, CampaignRewardsDto, CreateManyBreakdownDto, CreateManyRewardDto, RegisterClaimsDto, TokenIdDto, } from "./reward.model";
 import { RewardService } from "./reward.service";
 // ─── Rewards Controller ──────────────────────────────────────────────────────
@@ -131,6 +133,6 @@ export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags:
 })
     .get("/total/distributed", async ({ query }) => await RewardService.getTotalDistributed(query.since.getTime() / 1000))
     .get("/total/distributed/by-opportunities", async ({ query }) => JSON.stringify(bigintToString(Array.from((await RewardService.getTotalDistributedByOpportunities(query.since.getTime() / 1000)).entries()))))
-    .get("/total/distributed/by-chains", async ({ query }) => await RewardService.getTotalDistributedByChains(query.since.getTime() / 1000))
-    .get("/total/distributed/by-types", async ({ query }) => await RewardService.getTotalDistributedByType(query.since.getTime() / 1000))
-    .get("/total/distributed/by-protocols", async ({ query }) => await RewardService.getTotalDistributedByProtocol(query.since.getTime() / 1000));
+    .get("/total/distributed/by-chains", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, RewardService.getTotalDistributedByChains, query.since.getTime() / 1000))
+    .get("/total/distributed/by-types", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, RewardService.getTotalDistributedByType, query.since.getTime() / 1000))
+    .get("/total/distributed/by-protocols", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, RewardService.getTotalDistributedByProtocol, query.since.getTime() / 1000));

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

@@ -297,8 +297,7 @@ export class TokenService {
                 });
             }
             catch (err) {
-                console.error("Failed to create price source.");
-                console.error(err);
+                log.error("Failed to create price source.", err);
             }
         }
         return await TokenService.update(token.id, {