@merkl/api 0.10.177 → 0.10.181

package/dist/src/index.d.ts

@@ -495,6 +495,40 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            ":id": {
+                patch: {
+                    body: {
+                        name?: string | undefined;
+                        tags?: string[] | undefined;
+                    };
+                    params: {
+                        id: string;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            name: string;
+                            type: import("../database/api/.generated").$Enums.CampaignType;
+                            id: string;
+                            status: import("../database/api/.generated").$Enums.Status;
+                            tags: string[];
+                            identifier: string;
+                            chainId: number;
+                            action: import("../database/api/.generated").$Enums.OpportunityAction;
+                            mainProtocolId: string | null;
+                            tvl: number;
+                            apr: number;
+                            dailyRewards: number;
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {
@@ -678,19 +712,17 @@ declare const app: Elysia<"", false, {
         } & {
             "campaigns-to-process": {
                 engine: {
-                    "": {
-                        post: {
-                            body: unknown;
-                            params: {};
-                            query: {
-                                chainId: number;
-                            };
-                            headers: {
-                                authorization: string;
-                            };
-                            response: {
-                                200: string;
-                            };
+                    post: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            chainId: number;
+                        };
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: string;
                         };
                     };
                 };
@@ -743,7 +775,7 @@ declare const app: Elysia<"", false, {
                             id: string;
                             tags: import("../database/api/.generated").$Enums.ProtocolTag[];
                             icon: string;
-                        } & {})[] | null;
+                        } & {})[];
                     };
                 };
             };
@@ -762,6 +794,35 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        protocols: {
+            ":id": {
+                patch: {
+                    body: {
+                        url?: string | undefined;
+                        description?: string | undefined;
+                        icon?: string | undefined;
+                    };
+                    params: {
+                        id: string;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            name: string;
+                            url: string;
+                            description: string;
+                            id: string;
+                            tags: import("../database/api/.generated").$Enums.ProtocolTag[];
+                            icon: string;
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {
@@ -840,7 +901,7 @@ declare const app: Elysia<"", false, {
                     };
                     headers: unknown;
                     response: {
-                        200: {
+                        200: ({
                             symbol: string;
                             name: string | null;
                             id: string;
@@ -848,11 +909,11 @@ declare const app: Elysia<"", false, {
                             address: string;
                             icon: string;
                             decimals: number;
-                            displaySymbol: string;
                             verified: boolean;
                             isTest: boolean;
-                            price: number | null;
-                        }[];
+                        } & {
+                            price?: number | null | undefined;
+                        })[];
                     };
                 };
             };
@@ -878,6 +939,40 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        tokens: {
+            ":id": {
+                patch: {
+                    body: {
+                        icon?: string | undefined;
+                        displaySymbol?: string | undefined;
+                        isTest?: boolean | undefined;
+                    };
+                    params: {
+                        id: string;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            symbol: string;
+                            name: string | null;
+                            id: string;
+                            chainId: number;
+                            address: string;
+                            icon: string;
+                            decimals: number;
+                            displaySymbol: string;
+                            verified: boolean;
+                            isTest: boolean;
+                            price: number | null;
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {
@@ -1157,6 +1252,30 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        chains: {
+            ":chainId": {
+                patch: {
+                    body: {
+                        icon?: string | undefined;
+                    };
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            name: string;
+                            id: number;
+                            icon: string;
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {
@@ -1857,7 +1976,7 @@ declare const app: Elysia<"", false, {
                             id: string;
                             tags: import("../database/api/.generated").$Enums.ProtocolTag[];
                             icon: string;
-                        } & {})[] | null;
+                        } & {})[];
                     };
                 };
             };
@@ -2248,7 +2367,7 @@ declare const app: Elysia<"", false, {
     };
 } & {
     v4: {
-        positions: {
+        liquidity: {
             index: {
                 get: {
                     body: unknown;
@@ -2259,7 +2378,7 @@ declare const app: Elysia<"", false, {
                     };
                     headers: unknown;
                     response: {
-                        200: any[];
+                        200: import("./modules/v4/liquidity").PositionT[];
                     };
                 };
             };

package/dist/src/index.js

@@ -24,7 +24,7 @@ const app = new Elysia({
                 email: "contact@merkl.money",
                 name: "Angle Labs",
             },
-            description: "API to access data related to merkl campaigns, built and maintained by Angle Labs. This API is provided as is, without any warranty of any kind.",
+            description: "API to access data related to Merkl campaigns, built and maintained by Angle Labs. This API is provided as is, without any warranty of any kind.",
             license: {
                 name: "UNLICENSED",
             },

package/dist/src/libs/campaigns/campaignTypes/CLAMMDynamicData.js

@@ -341,7 +341,7 @@ export async function CLAMMDynamicData(chainId, campaigns) {
                                             const balance0 = BN2Number(amount0, decimalsToken0);
                                             const balance1 = BN2Number(amount1, decimalsToken1);
                                             const totalLiquidity = BN2Number(position.liquidity);
-                                            const inRangeLiquidity = balance0 > 0 && balance1 > 0 ? BN2Number(position.liquidity) ?? 0 : 0;
+                                            const inRangeLiquidity = balance0 > 0 && balance1 > 0 ? (BN2Number(position.liquidity) ?? 0) : 0;
                                             almTotalLiquidity += totalLiquidity;
                                             almInRangeLiquidity += inRangeLiquidity;
                                             almBalance0 += balance0;
@@ -504,7 +504,7 @@ export async function CLAMMDynamicData(chainId, campaigns) {
                                                 const balance0 = BN2Number(amount0, decimalsToken0);
                                                 const balance1 = BN2Number(amount1, decimalsToken1);
                                                 const totalLiquidity = BN2Number(position.liquidity);
-                                                const inRangeLiquidity = balance0 > 0 && balance1 > 0 ? BN2Number(position.liquidity) ?? 0 : 0;
+                                                const inRangeLiquidity = balance0 > 0 && balance1 > 0 ? (BN2Number(position.liquidity) ?? 0) : 0;
                                                 almTotalLiquidity += totalLiquidity;
                                                 almInRangeLiquidity += inRangeLiquidity;
                                                 almBalance0 += balance0;

package/dist/src/libs/campaigns/campaignTypes/ERC20DynamicDataRefacto.js

@@ -64,7 +64,7 @@ export async function ERC20DynamicDataRefacto(chainId, campaigns) {
             calls: [],
             typeInfo: {},
         };
-        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i);
+        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i, campaign);
         i += 5;
         tokenTypesByCampaign[campaign.campaignId] = typeStruct;
         callsRounds2.push(...typeStruct.calls);
@@ -124,8 +124,8 @@ export async function ERC20DynamicDataRefacto(chainId, campaigns) {
                     const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
                     tokenTypesByCampaign[campaign.campaignId] = await getTokenPricesInfo(i, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, result, campaign, pricer);
                     i += callsForCampaign;
-                    const totalSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply;
                     const whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
+                    const totalSupplyTargetToken = whitelistedSupplyTargetToken;
                     const priceTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
                     let lastEligibilityRatio = 1;
                     if (!!campaign.campaignParameters.hooks?.length) {
@@ -141,7 +141,7 @@ export async function ERC20DynamicDataRefacto(chainId, campaigns) {
                             campaign.campaignParameters.duration /
                             (whitelistedSupplyTargetToken * priceTargetToken),
                         totalSupplyTargetToken,
-                        tvl: totalSupplyTargetToken * priceTargetToken,
+                        tvl: whitelistedSupplyTargetToken * priceTargetToken,
                         type: tokenTypesByCampaign[campaign.campaignId].type,
                         typeInfo: tokenTypesByCampaign[campaign.campaignId].typeInfo,
                         priceRewardToken: priceRewardToken,

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

@@ -57,7 +57,8 @@ export declare enum tokenType {
     pendleYT = "pendleYT",
     pancakeswap = "pancakeswap",
     tempestStaking = "tempestStaking",
-    holdstation = "holdstation"
+    holdstation = "holdstation",
+    staking = "staking"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

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

@@ -59,6 +59,7 @@ export var tokenType;
     tokenType["pancakeswap"] = "pancakeswap";
     tokenType["tempestStaking"] = "tempestStaking";
     tokenType["holdstation"] = "holdstation";
+    tokenType["staking"] = "staking";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave" },
@@ -139,4 +140,7 @@ export const tokenTypeToProtocol = {
     [tokenType.holdstation]: {
         protocol: "HoldStation",
     },
+    [tokenType.staking]: {
+        protocol: "Staking",
+    },
 };

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

@@ -21,6 +21,7 @@ type callKeysAura = mandatoryCallKeys & {
     pid: string;
     gaugeBalance: string;
     auraBalance: string;
+    vaultBalance: string;
 };
 type dataRawAura = callKeysAura & {
     poolTokensRaw: Array<string[] | BigNumber[]>;

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

@@ -2,6 +2,7 @@ import { decodeCall } from "../../../../../utils/decodeCalls";
 import { createCall } from "../../../../../utils/encodeCalls";
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
+import { utils } from "ethers";
 import { GenericProcessor, roundType } from "./GenericProcessor";
 export class AuraProcessor extends GenericProcessor {
     rounds = {
@@ -21,6 +22,7 @@ export class AuraProcessor extends GenericProcessor {
             { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" },
             { key: "gaugeBalance", call: "balanceOf", target: "balancerPool", metaData: "gaugeContract" },
             { key: "auraBalance", call: "balanceOf", target: "gaugeContract", metaData: "auraStaker" },
+            { key: "vaultBalance", call: "balanceOf", target: "balancerPool", metaData: "vault" },
             { key: "totalSupplyGauge", call: "totalSupply", target: "gaugeContract" },
         ],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
@@ -43,8 +45,15 @@ export class AuraProcessor extends GenericProcessor {
         }
     }
     async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const totalSupplyBalancerPool = BN2Number(typeInfo.totalSupplyBalancerPool, 18);
+        let { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const vaultBalance = BN2Number(typeInfo.vaultBalance, 18);
+        const vaultIndex = campaign.campaignParameters.blacklist
+            ?.map(b => utils.getAddress(b))
+            ?.indexOf(utils.getAddress(typeInfo.vault));
+        if (vaultIndex !== -1) {
+            blacklistedSupply -= BN2Number(decodeCall(calls, index + vaultIndex, "balanceOf"), campaign.campaignParameters.decimalsTargetToken); // The vault balance was already removed from the total supply
+        }
+        const totalSupplyBalancerPool = BN2Number(typeInfo.totalSupplyBalancerPool, 18) - vaultBalance;
         const gaugeBalance = BN2Number(typeInfo.gaugeBalance, 18);
         const auraBalance = BN2Number(typeInfo.auraBalance, 18);
         const totalSupplyGauge = BN2Number(typeInfo.totalSupplyGauge, 18);
@@ -66,7 +75,7 @@ export class AuraProcessor extends GenericProcessor {
         }
         const percentageOfSupplyInAura = (auraBalance / totalSupplyGauge) * (gaugeBalance / totalSupplyBalancerPool);
         const tvl = poolTvl * percentageOfSupplyInAura;
-        const priceTargetToken = tvl / totalSupply;
+        const priceTargetToken = tvl / totalSupplyBalancerPool;
         return {
             ...typeInfo,
             totalSupplyBalancerPool,

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

@@ -1,5 +1,5 @@
 import type { Pricer } from "../../../../../utils/pricer";
-import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Campaign, CampaignParameters } from "@sdk";
 import type { tokenType } from "../helpers/tokenType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {

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

@@ -1,5 +1,4 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
-import { ChainId } from "@sdk";
 import { GenericProcessor } from "./GenericProcessor";
 export class PendleProcessor extends GenericProcessor {
     rounds = {
@@ -14,8 +13,7 @@ export class PendleProcessor extends GenericProcessor {
     async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const priceTargetToken = (await pricer.get({
-            address: typeInfo.tokenAddress,
-            chainId: ChainId.MAINNET,
+            symbol: typeInfo.tokenAddress,
         })) ?? 0;
         const tvl = priceTargetToken * totalSupply;
         return {

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

@@ -0,0 +1,39 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawStaking;
+    call: string;
+    target: keyof callKeysStaking;
+    metaData?: keyof callKeysStaking;
+    optional?: boolean;
+};
+type callKeysStaking = mandatoryCallKeys & {
+    stakingContract: string;
+    lockNFT: string;
+    stakingSymbol: string;
+};
+type dataRawStaking = callKeysStaking & {
+    eip712DomainName: string;
+};
+type dataTypeStaking = dataType & {};
+export declare class StakingProcessor extends GenericProcessor<callKeysStaking, dataRawStaking, dataTypeStaking> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawStaking): void;
+    processingRound2(typeInfo: dataRawStaking): void;
+    processingRound3(typeInfo: dataRawStaking): void;
+    processingRound4(typeInfo: dataRawStaking): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeStaking>;
+    computeRound1(type: tokenType, typeInfo: dataRawStaking): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+}
+export {};

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

@@ -0,0 +1,45 @@
+import { GenericProcessor } from "./GenericProcessor";
+export class StakingProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "lockNFT", call: "lockNFT", target: "stakingContract", optional: true },
+            { key: "eip712DomainName", call: "eip712DomainName", target: "stakingContract", optional: true },
+        ],
+        round2: [{ key: "stakingSymbol", call: "symbol", target: "lockNFT", optional: true }],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    processingRound1(typeInfo) {
+        if (typeInfo.stakingContract === "0x18eeD20f71BEf84B605253C89A7576E3634134C0") {
+            typeInfo.stakingSymbol = "CyberStaking";
+        }
+    }
+    processingRound2(typeInfo) {
+        typeInfo.stakingSymbol = typeInfo.eip712DomainName;
+    }
+    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/processorMapping.js

@@ -21,6 +21,7 @@ import { PendleYTProcessor } from "./PendleYTProcessor";
 import { RadiantProcessor } from "./RadiantProcessor";
 import { RfxProcessor } from "./RfxProcessor";
 import { SpliceProcessor } from "./SpliceProcessor";
+import { StakingProcessor } from "./StakingProcessor";
 import { SturdySiloProcessor } from "./SturdySiloProcessor";
 import { TempestVaultProcessor } from "./TempestVaultProcessor";
 import { TorosProcessor } from "./TorosProcessor";
@@ -88,4 +89,5 @@ export const processorMapping = {
     [tokenType.pancakeswap]: UniswapProcessor,
     [tokenType.tempestStaking]: TempestVaultProcessor,
     [tokenType.holdstation]: HoldStationProcessor,
+    [tokenType.staking]: StakingProcessor,
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1RefactoFinal.d.ts

@@ -1,3 +1,4 @@
+import type { Campaign, CampaignParameters } from "@sdk";
 import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
 import { type tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number): tokenTypeStruct;
+export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;

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

@@ -179,7 +179,27 @@ function parseForBalancer(calls, index, targetToken, name) {
         // Not a balancer pool
     }
 }
-export function getTokenTypeRound1(calls, targetToken, index) {
+function parseForStaking(campaign, calls, index, targetToken) {
+    try {
+        const whitelist = campaign.campaignParameters.whitelist;
+        console.log("whitelist", whitelist, whitelist.length);
+        if (whitelist.length === 1) {
+            const forwarders = campaign.campaignParameters.forwarders;
+            console.log("forwarders", forwarders);
+            if (forwarders.length === 1) {
+                if (forwarders[0].sender === whitelist[0]) {
+                    const name = decodeCall(calls, index + 2, "name");
+                    return generateResult(tokenType.staking, name, targetToken, { stakingContract: whitelist[0] });
+                }
+            }
+        }
+    }
+    catch (e) {
+        // No factory on this token
+        // console.log(e);
+    }
+}
+export function getTokenTypeRound1(calls, targetToken, index, campaign) {
     const returnValueOfCalls = calls.map(call => call.returnData);
     let result = parseForFactory(returnValueOfCalls, index, targetToken);
     if (result)
@@ -188,6 +208,10 @@ export function getTokenTypeRound1(calls, targetToken, index) {
     if (result)
         return result;
     result = parseForMetamorpho(returnValueOfCalls, index, targetToken);
+    if (result)
+        return result;
+    console.log("parsing for staking");
+    result = parseForStaking(campaign, returnValueOfCalls, index, targetToken);
     if (result)
         return result;
     let name;

package/dist/src/modules/v4/bucket/bucket.service.d.ts

@@ -0,0 +1,5 @@
+import type { SaveData } from "node_modules/@google-cloud/storage/build/esm/src/file";
+export declare abstract class BucketService {
+    private static storage;
+    static upload(bucketName: string, filename: string, data: SaveData, isPublic: boolean): Promise<string>;
+}

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

@@ -0,0 +1,11 @@
+import { Storage } from "@google-cloud/storage";
+export class BucketService {
+    static storage = new Storage({ projectId: "angle-production-1" });
+    static async upload(bucketName, filename, data, isPublic) {
+        const file = await BucketService.storage.bucket(bucketName).file(filename);
+        await file.save(data);
+        if (isPublic)
+            await file.makePublic();
+        return `https://storage.googleapis.com/${bucketName}/${filename}`;
+    }
+}

package/dist/src/modules/v4/campaign/campaign.controller.d.ts

@@ -192,19 +192,17 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
     } & {
         "campaigns-to-process": {
             engine: {
-                "": {
-                    post: {
-                        body: unknown;
-                        params: {};
-                        query: {
-                            chainId: number;
-                        };
-                        headers: {
-                            authorization: string;
-                        };
-                        response: {
-                            200: string;
-                        };
+                post: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        chainId: number;
+                    };
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: string;
                     };
                 };
             };

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

@@ -26,15 +26,15 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
             throwOnUnsupportedChainId(query.chainId);
         },
     })
-        // ─── Get Count of CampaignsToProcess ─────────────────────────────────
+        // ─── Get Count Of CampaignsToProcess ─────────
         .get("/count", async ({ query }) => (await CampaignService.findCampaignsToProcess(query.chainId)).length, {
         query: ChainUniqueDto,
         beforeHandle: ({ query }) => {
             throwOnUnsupportedChainId(query.chainId);
         },
     })
-        // ─── Returns a CampaignId to Process and flags it as PROCESSING ──────-
-        .post("/engine/", async ({ query }) => await CampaignService.pickCampaignToProcess(query.chainId), {
+        // ─── Marks A Campaignid As Processing ────────
+        .post("/engine", async ({ query }) => await CampaignService.pickCampaignToProcess(query.chainId), {
         query: ChainUniqueDto,
         beforeHandle: async ({ query, headers }) => {
             await EngineGuard({ headers });

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

@@ -80,7 +80,7 @@ export class CampaignRepository {
                         where: { id: opportunityId },
                         create: {
                             id: opportunityId,
-                            Chain: { connect: { id: campaign.chainId } },
+                            Chain: { connect: { id: campaign.computeChainId } },
                             type: campaignType,
                             identifier: campaign.opportunityIdentifier, // mainParameter
                             name: metadata.name,