@merkl/api 0.21.37 → 0.21.38

package/dist/src/engine/deprecated/erc20SubTypeProcessors/helpers/factoryFinder.js

@@ -32,6 +32,7 @@ const factoryAddresses = {
     "0x29372c22459a4e373851798bFd6808e71EA34A71": Erc20SubType.punchswap, // Punchswap Flow EVM
     "0x724412C00059bf7d6ee7d4a1d0D5cd4de3ea1C48": Erc20SubType.hyperswap, // Hyperswap Factory HyperEVM
     "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6": Erc20SubType.uniswapv2, // Uniswap Factory Base
+    "0xBA51AA60B3b8d9A36cc748a62Aa56801060183f8": Erc20SubType.pinto, // Pinto Factory on Base
 };
 export function getTypeFromFactoryAddress(address) {
     if (factoryAddresses[address]) {

package/dist/src/engine/implementations/Erc20/subTypes/detect.js

@@ -5,6 +5,7 @@ import { getTypeFromTreasuryAddress } from "@/engine/deprecated/erc20SubTypeProc
 import { processNamingConditionsInOrder } from "@/engine/deprecated/erc20SubTypeProcessors/subtypesRound1";
 import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
 import { decodeReturnValue } from "@/utils/decodeCalls";
+import { log } from "@/utils/logger";
 import { BalancerPoolInterface, BalancerV3StablePoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, IonPoolInterface, LayerBankERC20Interface, MetamorphoInterface, } from "@sdk";
 /**
  * @notice Compute the subtypes of the campaigns
@@ -72,6 +73,9 @@ export const detectSubType = async (chainId, campaigns) => {
             },
         ];
     }));
+    for (const key of Object.keys(detectionCalls)) {
+        log.local(`detection call ${key}: ${detectionCalls[key]}`);
+    }
     // 2. Decode result from the multicalls and using try catch, try to interprete the result
     const res = [];
     for (const campaign of campaigns) {

package/dist/src/engine/implementations/Erc20/subTypes/factories.js

@@ -7,8 +7,12 @@ import { GearboxMetadata } from "./implementations/gearbox/metadata";
 import { GearboxTVLBuilder } from "./implementations/gearbox/tvl";
 import { LendleMetadata } from "./implementations/lendleVaults/metadata";
 import { LendleTVLBuilder } from "./implementations/lendleVaults/tvl";
+import { PinoMetadata } from "./implementations/pino/metadata";
+import { PinoTVLBuilder } from "./implementations/pino/tvl";
 import { TermMaxMetadata } from "./implementations/termmax/metadata";
 import { TermMaxTVLBuilder } from "./implementations/termmax/tvl";
+import { UniswapV2Metadata } from "./implementations/uniswapV2/metadata";
+import { UniswapV2TVLBuilder } from "./implementations/uniswapV2/tvl";
 /**
  * @dev TYPE SAFETY DISABLED FOR NOW AS WE DON'T HAVE ALL THE CAMPAIGNS IMPLEMENTED
  *
@@ -25,6 +29,8 @@ const tvlMap = {
     [Erc20SubType.termmax]: new TermMaxTVLBuilder(),
     [Erc20SubType.dlend_lending]: new AaveTVLBuilder(),
     [Erc20SubType.dlend_borrowing]: new AaveTVLBuilder(),
+    [Erc20SubType.pinto]: new PinoTVLBuilder(),
+    [Erc20SubType.katana]: new UniswapV2TVLBuilder(),
 };
 export const erc20SubTypeTVLBuilderFactory = (erc20Subtype) => {
     if (!tvlMap[erc20Subtype]) {
@@ -48,6 +54,8 @@ const metadataMap = {
     [Erc20SubType.termmax]: new TermMaxMetadata(),
     [Erc20SubType.dlend_lending]: new AaveMetadata("dlend", "dTrinity dLend", (underlyingToken) => `https://app.dtrinity.org/dlend/reserve-overview/?underlyingAsset=${underlyingToken}`),
     [Erc20SubType.dlend_borrowing]: new AaveMetadata("dlend", "dTrinity dLend", (underlyingToken) => `https://app.dtrinity.org/dlend/reserve-overview/?underlyingAsset=${underlyingToken}`),
+    [Erc20SubType.pinto]: new PinoMetadata(),
+    [Erc20SubType.katana]: new UniswapV2Metadata("katana", "Katana"),
 };
 export const erc20SubTypeMetadataBuilderFactory = (erc20Subtype) => {
     if (!metadataMap[erc20Subtype]) {

package/dist/src/engine/implementations/Erc20/subTypes/implementations/pino/metadata.d.ts

@@ -0,0 +1,17 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign/campaign.model";
+import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
+import type { Erc20LikeCampaignEnum } from "../..";
+export declare class PinoMetadata implements MetadataBuilder<Erc20LikeCampaignEnum> {
+    build(campaign: Omit<CampaignWithParams<Erc20LikeCampaignEnum>, "manualOverrides">, _opportunityIdentifier: string): Promise<{
+        action: "POOL";
+        mainProtocol: ProtocolId;
+        name: string;
+        tokens: {
+            chainId: number;
+            address: string;
+        }[];
+        depositUrl: string;
+        explorerAddress: any;
+    }>;
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/pino/metadata.js

@@ -0,0 +1,38 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { OpportunityAction } from "@db/api";
+import { ChainInteractionService } from "@sdk";
+import { defaultAbiCoder } from "ethers/lib/utils.js";
+export class PinoMetadata {
+    async build(campaign, _opportunityIdentifier) {
+        const { params, computeChainId, campaignId } = campaign;
+        const { targetToken } = params;
+        const firstRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject([
+            {
+                callData: "0x9d63848a", // tokens()
+                target: targetToken,
+                key: `${campaignId}_tokens`,
+                decoder: (data) => defaultAbiCoder.decode(["address[]"], data)[0],
+            },
+        ]);
+        const [token0Address, token1Address] = firstRound[`${campaignId}_tokens`];
+        const token0 = await TokenService.findUniqueFillOrThrow({
+            chainId: computeChainId,
+            address: token0Address,
+        });
+        const token1 = await TokenService.findUniqueFillOrThrow({
+            chainId: computeChainId,
+            address: token1Address,
+        });
+        return {
+            action: OpportunityAction.POOL,
+            mainProtocol: "pinto",
+            name: `Provide Liquidity to Pinto ${token0.symbol}-${token1.symbol}`,
+            tokens: [
+                { chainId: computeChainId, address: token0Address },
+                { chainId: computeChainId, address: token1Address },
+            ],
+            depositUrl: `https://pinto.money/silo/${targetToken}`,
+            explorerAddress: params.targetToken,
+        };
+    }
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/pino/tvl.d.ts

@@ -0,0 +1,6 @@
+import type { Erc20LikeCampaignEnum } from "@/engine/implementations/Erc20/subTypes";
+import type { TVLBuilder, TVLData } from "@/engine/tvl/interface";
+import { type CampaignParameters, type MerklChainId } from "@sdk";
+export declare class PinoTVLBuilder implements TVLBuilder<Erc20LikeCampaignEnum> {
+    build(computeChainId: MerklChainId, campaigns: CampaignParameters<Erc20LikeCampaignEnum>[]): Promise<TVLData<any>>;
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/pino/tvl.js

@@ -0,0 +1,83 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { TvlType } from "@db/api";
+import { ChainInteractionService, ERC20Interface, bigIntToNumber, } from "@sdk";
+import { defaultAbiCoder } from "ethers/lib/utils.js";
+export class PinoTVLBuilder {
+    async build(computeChainId, campaigns) {
+        const tvls = [];
+        const firstRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
+            const { campaignId, campaignParameters } = campaign;
+            const { targetToken } = campaignParameters;
+            return [
+                {
+                    callData: "0x9d63848a", // tokens()
+                    target: targetToken,
+                    key: `${campaignId}_tokens`,
+                    decoder: (data) => defaultAbiCoder.decode(["address[]"], data)[0],
+                },
+            ];
+        }));
+        const secondRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
+            const { campaignId, campaignParameters } = campaign;
+            const { targetToken } = campaignParameters;
+            const [token0Address, token1Address] = firstRound[`${campaigns[0].campaignId}_tokens`];
+            return [
+                {
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [targetToken]),
+                    target: token0Address,
+                    key: `${campaignId}_token0`,
+                    decoder: (data) => {
+                        return ERC20Interface.decodeFunctionResult("balanceOf", data)[0];
+                    },
+                },
+                {
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [targetToken]),
+                    target: token1Address,
+                    key: `${campaignId}_token1`,
+                    decoder: (data) => {
+                        return ERC20Interface.decodeFunctionResult("balanceOf", data)[0];
+                    },
+                },
+            ];
+        }));
+        for (const campaign of campaigns) {
+            const { campaignId } = campaign;
+            const [token0Address, token1Address] = firstRound[`${campaigns[0].campaignId}_tokens`];
+            const reserve0 = secondRound[`${campaignId}_token0`];
+            const reserve1 = secondRound[`${campaignId}_token1`];
+            // We don't fetch token data everytime, we use the database and the associated service
+            const token0 = await TokenService.findUniqueFillOrThrow({
+                chainId: computeChainId,
+                address: token0Address,
+            });
+            const token1 = await TokenService.findUniqueFillOrThrow({
+                chainId: computeChainId,
+                address: token1Address,
+            });
+            if (!token0.decimals || !token0.price) {
+                throw new Error(`Missing decimals or price for token ${token0.address}`);
+            }
+            if (!token1.decimals || !token1.price) {
+                throw new Error(`Missing decimals or price for token ${token1.address}`);
+            }
+            tvls.push({
+                campaign,
+                tvl: bigIntToNumber(reserve0, token0.decimals) * token0.price +
+                    bigIntToNumber(reserve1, token1.decimals) * token1.price,
+                tvlBreakdown: [
+                    {
+                        identifier: token0.id,
+                        type: TvlType.TOKEN,
+                        value: bigIntToNumber(reserve0, token0.decimals),
+                    },
+                    {
+                        identifier: token1.id,
+                        type: TvlType.TOKEN,
+                        value: bigIntToNumber(reserve1, token1.decimals),
+                    },
+                ],
+            });
+        }
+        return tvls;
+    }
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/uniswapV2/metadata.d.ts

@@ -0,0 +1,30 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign/campaign.model";
+import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
+import type { Erc20LikeCampaignEnum } from "../..";
+export declare class UniswapV2Metadata implements MetadataBuilder<Erc20LikeCampaignEnum> {
+    /**
+     *  @notice Protocol entity ID - must be defined in the corresponding file and created in DB
+     */
+    mainProtocol: ProtocolId;
+    /**
+     *  @notice Protocol name - used to create the opportunity name
+     */
+    protocolName: string;
+    /**
+     *  @notice Function to generate the deposit URL for the opportunity
+     */
+    depositUrl?: (underlyingToken: string) => string;
+    constructor(mainProtocol: ProtocolId, protocolName: string, depositUrl?: (underlyingToken: string) => string);
+    build(campaign: Omit<CampaignWithParams<Erc20LikeCampaignEnum>, "manualOverrides">, _opportunityIdentifier: string): Promise<{
+        action: "POOL";
+        mainProtocol: "splice" | "reserve" | "morpho" | "quickswap" | "euler" | "uniswap" | "ambient" | "arthswap" | "base-swap" | "camelot" | "crust" | "fenix" | "horiza" | "izumi" | "kim" | "pancake-swap" | "ramses" | "retro" | "stryke" | "sushi-swap" | "swapr" | "thruster" | "voltage" | "zero" | "koi" | "supswap" | "zk-swap" | "thirdtrade" | "swap-x" | "velodrome" | "aerodrome" | "balancer" | "curve" | "cross_curve" | "curveNPool" | "aura" | "akron" | "beefy" | "dragonswap" | "poolside" | "syncswap" | "neptune" | "zkSwapThreePool" | "rfx" | "ra" | "maverick" | "trader-joe" | "hanji" | "pinto" | "radiant" | "aave" | "fraxlend" | "ironclad" | "gearbox" | "compound" | "sturdy" | "frax" | "ionic" | "moonwell" | "fluid" | "silo" | "dolomite" | "badger" | "ajna" | "layerbank" | "ion" | "venus" | "woofi" | "reactor_fusion" | "eigenlayer" | "vest" | "zerolend" | "lnd" | "dlend" | "hyperdrive" | "gamma" | "oku" | "hourglass" | "veda" | "kyo" | "sonex" | "lendle" | "tako-tako" | "equalizer" | "spectra" | "beraborrow" | "superlend" | "avalon" | "iguana" | "xlend" | "sake" | "sonicmarket" | "stability" | "angles" | "enzyme" | "toros" | "vicuna" | "bunni" | "beratrax" | "concrete" | "cian" | "pendle" | "yei" | "termmax" | "filament" | "gammaswap" | "maha" | "tempest" | "uranium" | "holdstation" | "katana" | "punchswap" | "satlayer" | "puffer";
+        name: string;
+        tokens: {
+            chainId: number;
+            address: string;
+        }[];
+        depositUrl: string | undefined;
+        explorerAddress: any;
+    }>;
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/uniswapV2/metadata.js

@@ -0,0 +1,65 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { OpportunityAction } from "@db/api";
+import { ChainInteractionService, UniswapV2PoolInterface } from "@sdk";
+export class UniswapV2Metadata {
+    /**
+     *  @notice Protocol entity ID - must be defined in the corresponding file and created in DB
+     */
+    mainProtocol;
+    /**
+     *  @notice Protocol name - used to create the opportunity name
+     */
+    protocolName;
+    /**
+     *  @notice Function to generate the deposit URL for the opportunity
+     */
+    depositUrl;
+    constructor(mainProtocol, protocolName, depositUrl) {
+        this.mainProtocol = mainProtocol;
+        this.protocolName = protocolName;
+        this.depositUrl = depositUrl ?? undefined;
+    }
+    async build(campaign, _opportunityIdentifier) {
+        const { params, computeChainId, campaignId } = campaign;
+        const { targetToken } = params;
+        const firstRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject([
+            {
+                callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
+                target: targetToken,
+                key: `${campaignId}_token0`,
+                decoder: (data) => {
+                    return UniswapV2PoolInterface.decodeFunctionResult("token0", data)[0];
+                },
+            },
+            {
+                callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
+                target: targetToken,
+                key: `${campaignId}_token1`,
+                decoder: (data) => {
+                    return UniswapV2PoolInterface.decodeFunctionResult("token1", data)[0];
+                },
+            },
+        ]);
+        const token0Address = firstRound[`${campaignId}_token0`];
+        const token1Address = firstRound[`${campaignId}_token1`];
+        const token0 = await TokenService.findUniqueFillOrThrow({
+            chainId: computeChainId,
+            address: token0Address,
+        });
+        const token1 = await TokenService.findUniqueFillOrThrow({
+            chainId: computeChainId,
+            address: token1Address,
+        });
+        return {
+            action: OpportunityAction.POOL,
+            mainProtocol: this.mainProtocol,
+            name: `Provide Liquidity to ${this.protocolName} ${token0.symbol}-${token1.symbol}`,
+            tokens: [
+                { chainId: computeChainId, address: token0Address },
+                { chainId: computeChainId, address: token1Address },
+            ],
+            depositUrl: this.depositUrl ? this.depositUrl(targetToken) : undefined,
+            explorerAddress: params.targetToken,
+        };
+    }
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/uniswapV2/tvl.d.ts

@@ -0,0 +1,6 @@
+import type { Erc20LikeCampaignEnum } from "@/engine/implementations/Erc20/subTypes";
+import type { TVLBuilder, TVLData } from "@/engine/tvl/interface";
+import { type CampaignParameters, type MerklChainId } from "@sdk";
+export declare class UniswapV2TVLBuilder implements TVLBuilder<Erc20LikeCampaignEnum> {
+    build(computeChainId: MerklChainId, campaigns: CampaignParameters<Erc20LikeCampaignEnum>[]): Promise<TVLData<any>>;
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/uniswapV2/tvl.js

@@ -0,0 +1,94 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { TvlType } from "@db/api";
+import { ChainInteractionService, ERC20Interface, UniswapV2PoolInterface, bigIntToNumber, } from "@sdk";
+export class UniswapV2TVLBuilder {
+    async build(computeChainId, campaigns) {
+        const tvls = [];
+        const firstRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
+            const { campaignId, campaignParameters } = campaign;
+            const { targetToken } = campaignParameters;
+            return [
+                {
+                    callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
+                    target: targetToken,
+                    key: `${campaignId}_token0`,
+                    decoder: (data) => {
+                        return UniswapV2PoolInterface.decodeFunctionResult("token0", data)[0];
+                    },
+                },
+                {
+                    callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
+                    target: targetToken,
+                    key: `${campaignId}_token1`,
+                    decoder: (data) => {
+                        return UniswapV2PoolInterface.decodeFunctionResult("token1", data)[0];
+                    },
+                },
+            ];
+        }));
+        const secondRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
+            const { campaignId, campaignParameters } = campaign;
+            const { targetToken } = campaignParameters;
+            const token0Address = firstRound[`${campaignId}_token0`];
+            const token1Address = firstRound[`${campaignId}_token1`];
+            return [
+                {
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [targetToken]),
+                    target: token0Address,
+                    key: `${campaignId}_token0`,
+                    decoder: (data) => {
+                        return ERC20Interface.decodeFunctionResult("balanceOf", data)[0];
+                    },
+                },
+                {
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [targetToken]),
+                    target: token1Address,
+                    key: `${campaignId}_token1`,
+                    decoder: (data) => {
+                        return ERC20Interface.decodeFunctionResult("balanceOf", data)[0];
+                    },
+                },
+            ];
+        }));
+        for (const campaign of campaigns) {
+            const { campaignId } = campaign;
+            const token0Address = firstRound[`${campaignId}_token0`];
+            const token1Address = firstRound[`${campaignId}_token1`];
+            const reserve0 = secondRound[`${campaignId}_token0`];
+            const reserve1 = secondRound[`${campaignId}_token1`];
+            // We don't fetch token data everytime, we use the database and the associated service
+            const token0 = await TokenService.findUniqueFillOrThrow({
+                chainId: computeChainId,
+                address: token0Address,
+            });
+            const token1 = await TokenService.findUniqueFillOrThrow({
+                chainId: computeChainId,
+                address: token1Address,
+            });
+            if (!token0.decimals || !token0.price) {
+                throw new Error(`Missing decimals or price for token ${token0.address}`);
+            }
+            if (!token1.decimals || !token1.price) {
+                throw new Error(`Missing decimals or price for token ${token1.address}`);
+            }
+            tvls.push({
+                campaign,
+                tvl: bigIntToNumber(reserve0, token0.decimals) * token0.price +
+                    bigIntToNumber(reserve1, token1.decimals) * token1.price,
+                tvlBreakdown: [
+                    {
+                        identifier: token0.id,
+                        type: TvlType.TOKEN,
+                        value: bigIntToNumber(reserve0, token0.decimals),
+                    },
+                    {
+                        identifier: token1.id,
+                        type: TvlType.TOKEN,
+                        value: bigIntToNumber(reserve1, token1.decimals),
+                    },
+                ],
+            });
+        }
+        return tvls;
+    }
+}

package/dist/src/engine/implementations/Erc20/subTypes/index.d.ts

@@ -114,5 +114,6 @@ export declare enum Erc20SubType {
     lendle_vaults = "lendle_vaults",
     termmax = "termmax",
     hyperswap = "hyperswap",
-    curveTricrypto = "curveTricrypto"
+    curveTricrypto = "curveTricrypto",
+    pinto = "pinto"
 }

package/dist/src/engine/implementations/Erc20/subTypes/index.js

@@ -114,4 +114,5 @@ export var Erc20SubType;
     Erc20SubType["termmax"] = "termmax";
     Erc20SubType["hyperswap"] = "hyperswap";
     Erc20SubType["curveTricrypto"] = "curveTricrypto";
+    Erc20SubType["pinto"] = "pinto";
 })(Erc20SubType || (Erc20SubType = {}));