@merkl/api 0.19.14 → 0.19.16

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

@@ -10,6 +10,7 @@ import { Prisma, Status } from "@db/api";
 import { Campaign as CampaignEnum } from "@sdk";
 import moment from "moment";
 import { metadataBuilderFactory } from "../../../engine/opportunityMetadata/factory";
+import { ProtocolService } from "../protocol/protocol.service";
 import { OpportunityRepository } from "./opportunity.repository";
 export class OpportunityService {
     static hashId(opportunity) {
@@ -44,17 +45,36 @@ export class OpportunityService {
             identifier: campaign.opportunityIdentifier,
             type: campaignType,
         });
+        const protocol = (await ProtocolService.findMany({ id: metadata.mainProtocol }))?.[0];
+        const tokens = await Promise.all(metadata.tokens.map(async (t) => {
+            return await TokenService.findMany(t);
+        }));
         const params = JSON.parse(campaign.params);
+        const now = moment().unix();
         const opportunity = {
             id: opportunityId,
             chainId: campaign.computeChainId,
             type: campaignType,
             identifier: campaign.opportunityIdentifier, // mainParameter
             name: metadata.name,
-            status: Status.SOON,
+            status: now >= +campaign.startTimestamp && now < +campaign.endTimestamp
+                ? Status.LIVE
+                : now > +campaign.endTimestamp
+                    ? Status.PAST
+                    : Status.SOON,
             action: metadata.action,
+            tokens,
             mainProtocol: metadata.mainProtocol,
-            depositUrl: !!params.url ? params.url : undefined,
+            // If creator has specified a deposit URL, use it
+            // Else if we have the specific logic to handle the deposit URL, use it
+            // Else if the protocol has a deposit URL, use it
+            depositUrl: !!params.url
+                ? params.url
+                : !!metadata.depositUrl
+                    ? metadata.depositUrl
+                    : !!metadata.mainProtocol && !!protocol.url
+                        ? protocol.url
+                        : undefined,
             tags,
         };
         return opportunity;
@@ -69,8 +89,9 @@ export class OpportunityService {
             type: campaignType,
         });
         const tokens = (await TokenService.findManyOrCreate(metadata.tokens)).filter(t => t !== undefined);
-        const params = JSON.parse(campaign.params);
         const now = moment().unix();
+        const protocol = (await ProtocolService.findMany({ id: metadata.mainProtocol }))?.[0];
+        const params = JSON.parse(campaign.params);
         const opportunity = {
             id: opportunityId,
             chainId: campaign.computeChainId,
@@ -85,7 +106,16 @@ export class OpportunityService {
             action: metadata.action,
             tokens,
             mainProtocol: metadata.mainProtocol,
-            depositUrl: !!params.url ? params.url : undefined,
+            // If creator has specified a deposit URL, use it
+            // Else if we have the specific logic to handle the deposit URL, use it
+            // Else if the protocol has a deposit URL, use it
+            depositUrl: !!params.url
+                ? params.url
+                : !!metadata.depositUrl
+                    ? metadata.depositUrl
+                    : !!metadata.mainProtocol && !!protocol.url
+                        ? protocol.url
+                        : undefined,
             tags,
         };
         await OpportunityRepository.create(opportunity, upsert);
@@ -94,36 +124,6 @@ export class OpportunityService {
     static async updateStatus(opportunityId, status) {
         return await OpportunityRepository.update(opportunityId, { status });
     }
-    static async updateStatusFromCampaign(campaign, upsert = true) {
-        const campaignType = CampaignService.getTypeFromV3(campaign.type);
-        const metadata = await OpportunityService.#getMetadata(campaign);
-        const opportunityId = OpportunityService.hashId({
-            chainId: campaign.computeChainId,
-            identifier: campaign.opportunityIdentifier,
-            type: campaignType,
-        });
-        const currentOpportunity = await OpportunityService.getUniqueOrThrow(opportunityId, true);
-        const now = moment().unix();
-        const opportunity = {
-            id: opportunityId,
-            chainId: campaign.computeChainId,
-            type: campaignType,
-            identifier: campaign.opportunityIdentifier, // mainParameter
-            name: currentOpportunity.name,
-            status: now >= +campaign.startTimestamp && now < +campaign.endTimestamp
-                ? Status.LIVE
-                : now > +campaign.endTimestamp
-                    ? Status.PAST
-                    : Status.SOON,
-            action: metadata.action,
-            tokens: currentOpportunity.tokens,
-            mainProtocol: metadata.mainProtocol,
-            depositUrl: currentOpportunity.depositUrl,
-            tags: currentOpportunity.tags,
-        };
-        await OpportunityRepository.create(opportunity, upsert);
-        return opportunity;
-    }
     /**
      * deletes and recreates an opportunity with fresh data
      */

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

@@ -786,11 +786,7 @@ declare const EtherlinkInterfaceCampaigns: {
             };
         };
         decodeDataValue: string[];
-        expectedChecks: {
-            index: number;
-            key: string;
-            expectedValue: string;
-        }[];
+        expectedChecks: never[];
         whitelist: never[];
         blacklist: string[];
         forwarders: never[];
@@ -827,11 +823,7 @@ declare const EtherlinkInterfaceCampaigns: {
             };
         };
         decodeDataValue: string[];
-        expectedChecks: {
-            index: number;
-            key: string;
-            expectedValue: string;
-        }[];
+        expectedChecks: never[];
         whitelist: never[];
         blacklist: string[];
         forwarders: never[];
@@ -868,11 +860,7 @@ declare const EtherlinkInterfaceCampaigns: {
             };
         };
         decodeDataValue: string[];
-        expectedChecks: {
-            index: number;
-            key: string;
-            expectedValue: string;
-        }[];
+        expectedChecks: never[];
         whitelist: never[];
         blacklist: string[];
         forwarders: never[];

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

@@ -673,18 +673,7 @@ const EtherlinkInterfaceCampaigns = {
             "bool",
             "bool",
         ],
-        expectedChecks: [
-            {
-                index: 8,
-                key: "data",
-                expectedValue: "true",
-            },
-            {
-                index: 9,
-                key: "data",
-                expectedValue: "false",
-            },
-        ],
+        expectedChecks: [],
         whitelist: [],
         blacklist: blacklistEtherlink,
         forwarders: [],
@@ -713,18 +702,7 @@ const EtherlinkInterfaceCampaigns = {
             "bool",
             "bool",
         ],
-        expectedChecks: [
-            {
-                index: 8,
-                key: "data",
-                expectedValue: "true",
-            },
-            {
-                index: 9,
-                key: "data",
-                expectedValue: "false",
-            },
-        ],
+        expectedChecks: [],
         whitelist: [],
         blacklist: blacklistEtherlink,
         forwarders: [],
@@ -753,18 +731,7 @@ const EtherlinkInterfaceCampaigns = {
             "bool",
             "bool",
         ],
-        expectedChecks: [
-            {
-                index: 8,
-                key: "data",
-                expectedValue: "true",
-            },
-            {
-                index: 9,
-                key: "data",
-                expectedValue: "false",
-            },
-        ],
+        expectedChecks: [],
         whitelist: [],
         blacklist: blacklistEtherlink,
         forwarders: [],

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

@@ -9,7 +9,7 @@ export type Protocol = Resource<"Protocol", undefined, {
     numberOfLiveCampaigns?: number;
     opportunityLiveTags?: string[];
 }>;
-declare const protocolTypes: readonly ["uniswap", "ambient", "arthswap", "baseswap", "camelot", "crust", "fenix", "horiza", "izumi", "kim", "pancakeswap", "quickswap", "ramses", "retro", "stryke", "sushiswap", "swapr", "thruster", "voltage", "zero", "koi", "supswap", "zkswap", "thirdtrade", "velodrome", "aerodrome", "balancer", "curve", "cross_curve", "curveNPool", "aura", "akron", "beefy", "dragonswap", "poolside", "koi", "syncswap", "neptune", "zkSwapThreePool", "syncswap", "rfx", "radiant", "aave", "euler", "gearbox", "compound", "sturdy", "frax", "ionic", "moonwell", "fluid", "silo", "morpho", "coumpound", "dolomite", "badger", "ajna", "layerbank", "ion", "venus", "woofi", "reactor_fusion", "eigenlayer", "vest", "zerolend", "hyperdrive", "gamma", "oku", "hourglass", "veda", "kyo", "sonex", "quickswap-algebra", "velodrome"];
+declare const protocolTypes: readonly ["uniswap", "ambient", "arthswap", "baseswap", "camelot", "crust", "fenix", "horiza", "izumi", "kim", "pancakeswap", "quickswap", "ramses", "retro", "stryke", "sushiswap", "swapr", "thruster", "voltage", "zero", "koi", "supswap", "zkswap", "thirdtrade", "velodrome", "aerodrome", "balancer", "curve", "cross_curve", "curveNPool", "aura", "akron", "beefy", "dragonswap", "poolside", "koi", "syncswap", "neptune", "zkSwapThreePool", "syncswap", "rfx", "radiant", "aave", "euler", "gearbox", "compound", "sturdy", "frax", "ionic", "moonwell", "fluid", "silo", "morpho", "coumpound", "dolomite", "badger", "ajna", "layerbank", "ion", "venus", "woofi", "reactor_fusion", "eigenlayer", "vest", "zerolend", "hyperdrive", "gamma", "oku", "hourglass", "veda", "kyo", "sonex", "velodrome"];
 export type ProtocolId = (typeof protocolTypes)[number];
 export declare const ProtocolResourceDto: import("@sinclair/typebox").TObject<{
     id: import("@sinclair/typebox").TString;

package/dist/src/modules/v4/protocol/protocol.model.js

@@ -75,7 +75,6 @@ const protocolTypes = [
     "veda",
     "kyo",
     "sonex",
-    "quickswap-algebra",
     "velodrome",
 ];
 // ─── DTOs ────────────────────────────────────────────────────────────────────

package/dist/src/modules/v4/router.d.ts

@@ -1116,6 +1116,175 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
+        } & {
+            "dry-run": {
+                ":campaignId": {
+                    "dynamic-data": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: unknown[];
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            "dry-run": {
+                ":campaignId": {
+                    "meta-data": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: {
+                                    id: string;
+                                    chainId: number;
+                                    type: string;
+                                    identifier: string;
+                                    name: string;
+                                    status: "PAST" | "LIVE" | "SOON";
+                                    action: any;
+                                    tokens: ({
+                                        symbol: string;
+                                        id: string;
+                                        name: string | null;
+                                        icon: string;
+                                        address: string;
+                                        chainId: number;
+                                        decimals: number;
+                                        verified: boolean;
+                                        isTest: boolean;
+                                        isPoint: boolean;
+                                        isNative: boolean;
+                                    } & {
+                                        price?: number | null | undefined;
+                                    })[][];
+                                    mainProtocol: string | undefined;
+                                    depositUrl: any;
+                                    tags: string[];
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            index: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        type?: string | undefined;
+                        status?: "NONE" | "PAST" | "LIVE" | "SOON" | undefined;
+                        items?: number | undefined;
+                        subType?: number | undefined;
+                        page?: number | undefined;
+                        types?: string[] | undefined;
+                        campaignId?: string | undefined;
+                        opportunityId?: string | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        creatorAddress?: string | undefined;
+                        chainId?: number | undefined;
+                        creatorId?: string | undefined;
+                        mainParameter?: string | undefined;
+                        point?: boolean | undefined;
+                        tokenAddress?: string | undefined;
+                        test?: boolean | undefined;
+                        creatorTag?: string | undefined;
+                        distributionChainIds?: number[] | undefined;
+                        tokenSymbol?: string | undefined;
+                        withOpportunity?: boolean | undefined;
+                        createdAfter?: Date | null | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            params: any;
+                            chain: {
+                                id: number;
+                                name: string;
+                                icon: string;
+                            };
+                            endTimestamp: number;
+                            startTimestamp: number;
+                            rewardToken: {
+                                symbol: string;
+                                id: string;
+                                name: string | null;
+                                icon: string;
+                                address: string;
+                                chainId: number;
+                                decimals: number;
+                                verified: boolean;
+                                isTest: boolean;
+                                isPoint: boolean;
+                                isNative: boolean;
+                            } & {
+                                price?: number | null | undefined;
+                            };
+                            distributionChain: {
+                                id: number;
+                                name: string;
+                                icon: string;
+                            } | undefined;
+                            campaignStatus: {
+                                computedUntil: number;
+                                processingStarted: number;
+                                error: string;
+                                status: import("@db/api").$Enums.RunStatus;
+                                details: import("database/api/.generated/runtime/library").JsonValue;
+                                campaignId: string;
+                            } | undefined;
+                            creatorAddress: string;
+                            creator: {
+                                tags: string[];
+                                address: string;
+                                creatorId: string | null;
+                            };
+                            createdAt: string;
+                            Opportunity: {
+                                id: string;
+                                name: string;
+                                type: string;
+                                status: import("@db/api").$Enums.Status;
+                                tags: string[];
+                                identifier: string;
+                                action: import("@db/api").$Enums.OpportunityAction;
+                                chainId: number;
+                                depositUrl: string | null;
+                                mainProtocolId: string | null;
+                                tvl: number;
+                                apr: number;
+                                dailyRewards: number;
+                            };
+                            id: string;
+                            type: string;
+                            subType: number | null;
+                            computeChainId: number;
+                            distributionChainId: number;
+                            campaignId: string;
+                            rewardTokenId: string;
+                            amount: string;
+                            opportunityId: string;
+                        }[];
+                    };
+                };
+            };
         } & {
             ":id": {
                 get: {

package/dist/src/utils/decodeCalls.js

@@ -47,7 +47,13 @@ export function decodeReturnValue(returnData, key, type) {
         case "token1":
             return UniswapV2PoolInterface.decodeFunctionResult("token1", returnData)[0];
         case "lp_token":
-            return BalancerGaugeInterface.decodeFunctionResult("lp_token", returnData)[0];
+            switch (type) {
+                case tokenType.beraborrow_gauge:
+                case tokenType.beratrax_vault:
+                    return ERC4626Interface.decodeFunctionResult("asset", returnData)[0];
+                default:
+                    return BalancerGaugeInterface.decodeFunctionResult("lp_token", returnData)[0];
+            }
         case "operator":
             return AuraInterface.decodeFunctionResult("operator", returnData)[0];
         case "pid":
@@ -200,6 +206,8 @@ export function decodeReturnValue(returnData, key, type) {
                 case tokenType.anglesLiquid:
                 case tokenType.cian:
                 case tokenType.rfx_slv:
+                case tokenType.beratrax_vault:
+                case tokenType.beraborrow_gauge:
                 case tokenType.metamorpho:
                     return ERC4626Interface.decodeFunctionResult("totalAssets", returnData)[0];
                 case tokenType.concrete:

package/dist/src/utils/encodeCalls.js

@@ -49,7 +49,13 @@ export function createCall(target, key, type, metaData) {
         case "pid":
             return { allowFailure: true, callData: AuraInterface.encodeFunctionData("pid"), target };
         case "lp_token":
-            return { allowFailure: true, callData: BalancerGaugeInterface.encodeFunctionData("lp_token"), target };
+            switch (type) {
+                case tokenType.beraborrow_gauge:
+                case tokenType.beratrax_vault:
+                    return { allowFailure: true, callData: ERC4626Interface.encodeFunctionData("asset"), target };
+                default:
+                    return { allowFailure: true, callData: BalancerGaugeInterface.encodeFunctionData("lp_token"), target };
+            }
         case "stakingToken":
             return { allowFailure: true, callData: OneInchStakingInterface.encodeFunctionData("stakingToken"), target };
         case "eVault":
@@ -271,6 +277,8 @@ export function createCall(target, key, type, metaData) {
                 case tokenType.cian:
                 case tokenType.rfx_slv:
                 case tokenType.metamorpho:
+                case tokenType.beratrax_vault:
+                case tokenType.beraborrow_gauge:
                     return {
                         allowFailure: true,
                         callData: ERC4626Interface.encodeFunctionData("totalAssets"),

package/dist/src/utils/generateCardName.js

@@ -46,6 +46,9 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""], displ
             return `Provide ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
         case tokenType.balancerGauge:
             return `${typeInfo.protocol} ${symbols.join("-")}`;
+        case tokenType.beraborrow_gauge:
+        case tokenType.beratrax_vault:
+            return `Deposit ${symbols.join("-")} on ${typeInfo.protocol}`;
         case tokenType.balancerPool: {
             if (campaign.computeChainId === ChainId.SONIC) {
                 typeInfo.protocol = "Beets";