@merkl/api 0.19.16 → 0.19.18

package/dist/src/engine/erc20SubTypeProcessors/implementations/BEXRewardGaugeProcessor.d.ts

@@ -16,6 +16,7 @@ type callKeysBG = mandatoryCallKeys & {
     poolId: string;
     vault: string;
     vaultBalance: string;
+    poolHolder: string;
 };
 type dataRawBG = callKeysBG & {
     poolTokensRaw: Array<string[] | BigNumber[]>;
@@ -23,6 +24,8 @@ type dataRawBG = callKeysBG & {
         token: string;
         balance: string;
     }>;
+    poolHolder: string;
+    poolHolderBalance: string;
 };
 type dataTypeBG = dataType & {
     gyroscopeToken: string;
@@ -36,6 +39,7 @@ type dataTypeBG = dataType & {
         balance: string;
     }>;
     vaultBalance: string;
+    poolHolderBalance: string;
 };
 export declare class BEXRewardGaugeProcessor extends GenericProcessor<callKeysBG, dataRawBG, dataTypeBG> {
     rounds: {
@@ -44,6 +48,7 @@ export declare class BEXRewardGaugeProcessor extends GenericProcessor<callKeysBG
         round3: callType[];
         round4: callType[];
     };
+    processingRound2(typeInfo: dataRawBG): void;
     processingRound4(typeInfo: dataRawBG): void;
     processingRound5(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
     computeRound4(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;

package/dist/src/engine/erc20SubTypeProcessors/implementations/BEXRewardGaugeProcessor.js

@@ -12,6 +12,7 @@ export class BEXRewardGaugeProcessor extends GenericProcessor {
             { key: "totalSupplyUnderlyingPoolTokens", call: "totalSupply", target: "gyroscopeToken" },
             { key: "poolId", call: "getPoolId", target: "gyroscopeToken" },
             { key: "vault", call: "getVault", target: "gyroscopeToken" },
+            { key: "poolHolderBalance", call: "balanceOf", target: "gyroscopeToken", metaData: "poolHolder" },
         ],
         round3: [
             { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" },
@@ -20,6 +21,9 @@ export class BEXRewardGaugeProcessor extends GenericProcessor {
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
     // override computeRound1(): void {}
+    processingRound2(typeInfo) {
+        typeInfo.poolHolder = "0xC2BaA8443cDA8EBE51a640905A8E6bc4e1f9872c";
+    }
     processingRound4(typeInfo) {
         const tokens = typeInfo.poolTokensRaw[0];
         const balances = typeInfo.poolTokensRaw[1];
@@ -52,10 +56,10 @@ export class BEXRewardGaugeProcessor extends GenericProcessor {
             tvlUnderlyingPool += poolTokensinfo[poolToken.token].price * poolTokensinfo[poolToken.token].amountInPool;
             symbols.push(symbol);
         }
-        let adjustedPoolTotalSupply = BN2Number(typeInfo.totalSupplyUnderlyingPoolTokens, 18) - BN2Number(typeInfo.vaultBalance, 18);
+        let adjustedPoolTotalSupply = BN2Number(typeInfo.totalSupplyUnderlyingPoolTokens, 18); //- BN2Number(typeInfo.vaultBalance, 18);
         if (type === tokenType.beratrax_vault) {
             // Weird edge case where the total supply is 80k higher than it should be because they minted stuff on an EOA
-            adjustedPoolTotalSupply -= 35724494.54 + 82793;
+            adjustedPoolTotalSupply -= BN2Number(typeInfo.poolHolderBalance, 18);
         }
         let percentageOfSupplyUnderlyingPoolTokens = 1;
         if (adjustedPoolTotalSupply > 0) {

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

@@ -65,6 +65,12 @@ export class ClammMetadata {
                 }
             }
         }
+        // Protocol id normalization
+        let mainProtocol = AMM[params.amm]
+            ? camelToKebabCase(AMM[params.amm].replace(/\/?(V\d+)/g, "").replaceAll("Algebra", ""))
+            : undefined;
+        if (mainProtocol?.includes("stryke"))
+            mainProtocol = "stryke";
         return {
             name: `Provide liquidity to ${whitelistNameString} ${platform} ${params.symbolToken0}-${params.symbolToken1}${params.poolFee ? ` ${params.poolFee}%` : ""}`,
             action: OpportunityAction.POOL,
@@ -72,7 +78,7 @@ export class ClammMetadata {
                 { chainId: computeChainId, address: params.token0 },
                 { chainId: computeChainId, address: params.token1 },
             ],
-            mainProtocol: AMM[params.amm] ? camelToKebabCase(AMM[params.amm]) : undefined,
+            mainProtocol,
             depositUrl: ClammMetadata.generateUrl(computeChainId, params),
         };
     }

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

@@ -121,6 +121,10 @@ export class OpportunityRepository {
         };
     }
     static async create(newOpp, upsert = false) {
+        const opportunity = await apiDbClient.opportunity.findUnique({ where: { id: newOpp.id } });
+        if (!!opportunity && !upsert) {
+            return opportunity;
+        }
         if (!!newOpp.mainProtocol) {
             let mainProtocol = await apiDbClient.protocol.findUnique({ where: { id: newOpp.mainProtocol } });
             if (!mainProtocol) {
@@ -176,10 +180,6 @@ export class OpportunityRepository {
             });
         }
         else {
-            const opportunity = await apiDbClient.opportunity.findUnique({ where: { id: newOpp.id } });
-            if (!!opportunity) {
-                return opportunity;
-            }
             await apiDbClient.opportunity.create({ data });
         }
         return await apiDbClient.opportunity.findUnique({ where: { id: newOpp.id } });

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

@@ -9,6 +9,7 @@ export declare abstract class ProtocolRepository {
         tags: string[];
         icon: string;
     }>;
+    static changeId(oldId: string, newId: string): Promise<void>;
     static read(type: string): Promise<{
         id: string;
         name: string;

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

@@ -1,3 +1,4 @@
+import { log } from "@/utils/logger";
 import { apiDbClient } from "@db";
 // ─── Protocols Repository ────────────────────────────────────────────────────
 export class ProtocolRepository {
@@ -13,6 +14,65 @@ export class ProtocolRepository {
             },
         });
     }
+    static async changeId(oldId, newId) {
+        await apiDbClient.opportunity.updateMany({
+            where: {
+                mainProtocolId: oldId,
+            },
+            data: {
+                mainProtocolId: newId,
+            },
+        });
+        await apiDbClient.rewardBreakdown.updateMany({
+            where: {
+                protocolId: oldId,
+            },
+            data: {
+                protocolId: newId,
+            },
+        });
+        const opportunities = await apiDbClient.opportunity.findMany({
+            where: {
+                Protocols: {
+                    some: {
+                        id: oldId,
+                    },
+                },
+            },
+        });
+        for (const opportunity of opportunities) {
+            await apiDbClient.opportunity.update({
+                where: {
+                    id: opportunity.id,
+                },
+                data: {
+                    Protocols: {
+                        disconnect: [
+                            {
+                                id: oldId,
+                            },
+                        ],
+                        connect: [
+                            {
+                                id: newId,
+                            },
+                        ],
+                    },
+                },
+            });
+        }
+        try {
+            await apiDbClient.protocol.delete({
+                where: {
+                    id: oldId,
+                },
+            });
+            log.info(`protocol with id ${oldId} deleted`);
+        }
+        catch {
+            log.warn(`protocol with id ${oldId} not found`);
+        }
+    }
     static async read(type) {
         return await apiDbClient.protocol.findUnique({ where: { id: type } });
     }