@merkl/api 0.21.46 → 1.0.0

package/dist/src/utils/execute.js

@@ -1,117 +0,0 @@
-// @ts-nocheck
-import { MAX_NUM_SUBCALLS } from "@/constants";
-import { withRetry } from "@sdk";
-import { constants } from "ethers";
-import { log } from "./logger";
-import { archiveMulticalls, multicalls } from "./providers";
-/**
- * Functions
- */
-export async function executeSimple(chainId, componentCall) {
-    const c = await componentCall;
-    if (c.cached === true)
-        return c.result;
-    return (await execute(chainId, [c.call]))[0];
-}
-const execute = async (chainId, callList, shouldRetry, blockNumber) => {
-    const calls = [];
-    for (const subCall of callList) {
-        calls.push(...subCall.callData);
-    }
-    try {
-        let result;
-        if (calls.length > 0) {
-            result = await batchMulticallCall(multicallContractCall, !!blockNumber ? archiveMulticalls[chainId] : multicalls[chainId], { blockNumber: blockNumber, data: calls }, shouldRetry);
-        }
-        else {
-            result = [];
-        }
-        let startIndex = 0;
-        const promises = [];
-        for (const subCall of callList) {
-            promises.push(subCall.reducer(result.slice(startIndex, startIndex + subCall.callData.length)));
-            startIndex += subCall.callData.length;
-        }
-        return await Promise.all(promises);
-    }
-    catch (e) {
-        for (const subCall of callList) {
-            log.error("execute", e);
-            subCall.handler();
-        }
-    }
-    return [];
-};
-async function multicallContractCall(contract, args) {
-    let result;
-    try {
-        // TO SIMULATE - USE CAUTIOUSLY AS IT USES CREDITS
-        // console.log(
-        //   await callTenderly(
-        //     {
-        //       chainId: (await contract.provider.getNetwork()).chainId.toString(),
-        //       data: contract.interface.encodeFunctionData('aggregate', [args.data]),
-        //       from: !!args.from ? args.from : constants.AddressZero,
-        //       saveSimulation: true,
-        //       to: contract.address,
-        //       value: '0',
-        //     },
-        //     undefined,
-        //     true
-        //   )
-        // );
-        result = await contract.provider.call({
-            data: contract.interface.encodeFunctionData("aggregate3", [
-                args.data.map(c => {
-                    return {
-                        allowFailure: !!c.allowFailure,
-                        callData: c.callData,
-                        target: c.target,
-                    };
-                }),
-            ]),
-            from: !!args.from ? args.from : constants.AddressZero,
-            to: contract.address,
-        }, !!args.blockNumber ? args.blockNumber : undefined);
-    }
-    catch (e) {
-        log.error("multicallContractCall failed", e);
-        throw new Error("❌ failed to decode multicall data");
-    }
-    return contract.interface.decodeFunctionResult("aggregate3", result)[0].map((r) => r?.returnData);
-}
-async function batchMulticallCall(func, contract, args, shouldRetry = true) {
-    let callsLeft = args.data.length;
-    let lowerIdx = 0;
-    let upperIdx = Math.min(args.data.length, MAX_NUM_SUBCALLS);
-    const multicallBatch = [];
-    while (callsLeft !== 0) {
-        multicallBatch.push(shouldRetry
-            ? withRetry(func, [
-                // TODO: fix typing
-                contract,
-                {
-                    blockNumber: args.blockNumber,
-                    data: args.data.slice(lowerIdx, upperIdx),
-                },
-            ])
-            : func(contract, args));
-        callsLeft -= upperIdx - lowerIdx;
-        lowerIdx = upperIdx;
-        upperIdx = Math.min(args.data.length, upperIdx + MAX_NUM_SUBCALLS);
-    }
-    /** Executing batched multicall */
-    const results = await Promise.allSettled(multicallBatch);
-    let fetchedData = [];
-    for (let k = 0; k < results.length; k++) {
-        const res = results[k];
-        if (res.status === "fulfilled") {
-            fetchedData = fetchedData.concat(res.value);
-        }
-        else {
-            log.error(`batchMulticallCall failed to ${args.data[k].target}, data: ${args.data[k].callData}`, res);
-            fetchedData.concat("0x");
-        }
-    }
-    return fetchedData;
-}

package/dist/src/utils/generateCardName.js

@@ -1,209 +0,0 @@
-import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
-import { capitalize } from "lodash";
-export const stakingContractToStakingSymbol = {
-    "0x18eeD20f71BEf84B605253C89A7576E3634134C0": "CyberStaking",
-    "0x68754d29f2e97B837Cb622ccfF325adAC27E9977": "Karak",
-    "0xcd28cF8f7755f03967D27E128B38022B63919836": "Llamalend",
-};
-export function generateCardName(type, typeInfo, campaign, symbols = [""], displayName) {
-    if (typeInfo.isStaking === "true") {
-        if (typeInfo.stakingName !== undefined) {
-            typeInfo.stakingSymbol = typeInfo.stakingName.includes("Deposit")
-                ? typeInfo.stakingName.replace("Deposit", "").trim()
-                : typeInfo.stakingName;
-        }
-        if (typeInfo.stakingSymbol === undefined) {
-            typeInfo.stakingSymbol = typeInfo.eip712DomainName;
-        }
-        if (typeInfo.stakingSymbol === undefined) {
-            typeInfo.stakingSymbol = typeInfo.protocol !== "Unknown" ? typeInfo.protocol : undefined;
-        }
-        if (typeInfo.stakingSymbol === undefined) {
-            typeInfo.stakingSymbol = stakingContractToStakingSymbol[typeInfo.stakingContract];
-        }
-        return `${typeInfo.lockNFT !== undefined ? "Lock" : "Stake"} ${campaign.campaignParameters.symbolTargetToken} on ${typeInfo.stakingSymbol}`;
-    }
-    switch (type) {
-        case Erc20SubType.uniswapv2:
-        case Erc20SubType.poolside:
-        case Erc20SubType.velodrome:
-        case Erc20SubType.aerodrome:
-        case Erc20SubType.dragonswap:
-        case Erc20SubType.akron:
-        case Erc20SubType.koi:
-        case Erc20SubType.baseswap:
-        case Erc20SubType.fenix:
-        case Erc20SubType.zkswap:
-        case Erc20SubType.ra:
-        case Erc20SubType.syncswap:
-        case Erc20SubType.pancakeswap:
-        case Erc20SubType.traderJoe:
-        case Erc20SubType.katana:
-        case Erc20SubType.punchswap:
-            return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
-        case Erc20SubType.hyperswap:
-            return `Provide liquidity to HyperSwap Standard AMM ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
-        case Erc20SubType.pendleYT:
-            return `Hold ${capitalize(typeInfo.protocol)} ${typeInfo.name}`;
-        case Erc20SubType.pendle:
-            return `Provide ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.balancerGauge:
-            return `${capitalize(typeInfo.protocol)} ${symbols.join("-")}`;
-        case Erc20SubType.beraborrow_gauge:
-        case Erc20SubType.beratrax_vault:
-            return `Deposit ${symbols.join("-")} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.balancerPool: {
-            return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${symbols.join("-")}`;
-        }
-        case Erc20SubType.balancerV3: {
-            return `Provide liquidity to ${capitalize(typeInfo.protocol)} Boosted ${symbols.join("-")}`;
-        }
-        case Erc20SubType.aura:
-            return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${symbols.join("-")}`;
-        case Erc20SubType.gearbox:
-            return `${capitalize(typeInfo.protocol)} ${typeInfo.symbolUnderlyingToken} Deposit`;
-        case Erc20SubType.compound:
-            return `Lend ${typeInfo.symbolBaseToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.radiant_lend: {
-            let cardToken = typeInfo.symbolUnderlyingToken;
-            if (campaign.campaignParameters.symbolTargetToken.startsWith("r")) {
-                cardToken = campaign.campaignParameters.symbolTargetToken.substring(1);
-            }
-            return `Lend ${cardToken} on ${capitalize(typeInfo.protocol)}`;
-        }
-        case Erc20SubType.rfx:
-            return `Supply ${typeInfo.symbolShortToken}-${typeInfo.symbolLongToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.radiant_borrow:
-        case Erc20SubType.aave_borrowing:
-        case Erc20SubType.sake_borrowing:
-        case Erc20SubType.vicuna_borrowing:
-        case Erc20SubType.yei_borrowing:
-        case Erc20SubType.ironclad_borrowing:
-        case Erc20SubType.zerolend_borrowing:
-        case Erc20SubType.lnd_borrowing:
-        case Erc20SubType.avalon_borrowing:
-        case Erc20SubType.superlend_borrowing:
-        case Erc20SubType.takotako_borrowing:
-        case Erc20SubType.lendle_borrowing:
-        case Erc20SubType.euler_borrow:
-            return `Borrow ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.ionic:
-        case Erc20SubType.layerbank:
-        case Erc20SubType.moonwell:
-        case Erc20SubType.splice:
-        case Erc20SubType.aave_lending:
-        case Erc20SubType.stability_lending:
-        case Erc20SubType.vicuna_lending:
-        case Erc20SubType.sake_lending:
-        case Erc20SubType.yei_lending:
-        case Erc20SubType.ironclad_lending:
-        case Erc20SubType.zerolend_lending:
-        case Erc20SubType.lnd_lending:
-        case Erc20SubType.avalon_lending:
-        case Erc20SubType.takotako_lending:
-        case Erc20SubType.superlend_lending:
-        case Erc20SubType.lendle_lending:
-        case Erc20SubType.fraxlend:
-        case Erc20SubType.venus:
-        case Erc20SubType.reactor_fusion:
-        case Erc20SubType.euler_lend:
-        case Erc20SubType.fluid:
-            return `Lend ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.xlend_lending:
-            return `Lend ${typeInfo.symbolUnderlyingToken} on Extrafi XLend`;
-        case Erc20SubType.xlend_borrowing:
-            return `Borrow ${typeInfo.symbolUnderlyingToken} on Extrafi XLend`;
-        case Erc20SubType.metamorpho:
-            return `Supply to ${typeInfo.name} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.sturdy_aggregator:
-            return `Supply ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)} ${typeInfo.name}`;
-        case Erc20SubType.sturdy_silo:
-            return `Supply ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)} ${typeInfo.symbolCollateral} Silo`;
-        case Erc20SubType.curve:
-        case Erc20SubType.curve_2:
-            return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${Object.values(typeInfo.poolTokens).join("-")}`;
-        case Erc20SubType.enzyme:
-            return `Supply to the ${typeInfo.name} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.filament:
-            return `Earn Yield on ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.silostaking:
-            return `Stake ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.beefy:
-            return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
-        case Erc20SubType.toros:
-            return `${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken}) on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.ironcladStaking:
-            return `Stake ${campaign.campaignParameters.symbolTargetToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.woofi:
-            return `Supercharge ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.maverickBoostedPosition:
-            return `Maverick Boosted Position ${campaign.campaignParameters.symbolTargetToken}`;
-        case Erc20SubType.zkSwapThreePool:
-            return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}-${typeInfo.symbolToken2}`;
-        case Erc20SubType.maha:
-            return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} LP on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.curve_gauge:
-            if (!!typeInfo.symbolToken2) {
-                return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}-${typeInfo.symbolToken2} LP on ${capitalize(typeInfo.protocol)}`;
-            }
-            return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} LP on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.tempest:
-        case Erc20SubType.tempestStaking:
-            return `Deposit into ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} vault on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.holdstation:
-            return `Hold vault token ${campaign.campaignParameters.symbolTargetToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.cpmmGamma:
-            return `Provide ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.crosscurve:
-            if (typeInfo.name.toLowerCase() === "eywa/usdt") {
-                return `Curve ${typeInfo.name}`;
-            }
-            return `${typeInfo.name}`;
-        case Erc20SubType.curveNPool:
-        case Erc20SubType.curveTricrypto:
-            return `Curve ${typeInfo.name}`;
-        case Erc20SubType.vicuna: {
-            const parsedName = typeInfo.name.split(" ");
-            parsedName.shift();
-            const parsedNameForCard = parsedName.join(" ");
-            return `Deposit liquidity on ${parsedNameForCard.replace("BALANCER", "Beets")} vault on Vicuna`;
-        }
-        case Erc20SubType.satlayer:
-            return `Restake ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case Erc20SubType.veda:
-            return `Deposit into ${typeInfo.name.replace("Ether.Fi", "Veda")}`;
-        case Erc20SubType.concrete:
-        case Erc20SubType.cian:
-            return `Deposit ${typeInfo.symbolAsset} into ${typeInfo.name.replace("Ether.Fi", "Veda")}`;
-        case Erc20SubType.rfx_slv:
-            return `Deposit ${typeInfo.symbolAsset} into ${typeInfo.name}`;
-        case Erc20SubType.equalizer_gauge:
-            return `${displayName}`;
-        case Erc20SubType.anglesLiquid:
-            return `Deposit into ${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken}) Vault`;
-        case Erc20SubType.spectra_lpt:
-            return `Provide liquidity on Spectra to ${typeInfo.name}`;
-        case Erc20SubType.spectra_yt:
-            return `Hold Spectra ${typeInfo.name}`;
-        case Erc20SubType.hourglass:
-            return `Deposit ${typeInfo.symbolUnderlyingToken} into Hourglass`;
-        case Erc20SubType.hanji_liquidity_vault_token:
-            return "Provide Liquidity on Hanji Vault";
-        case Erc20SubType.bunniV2:
-            return `Provide Liquidity on Bunni V2 ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
-        case Erc20SubType.gamma:
-            return `Provide liquidity to Gamma ${capitalize(typeInfo.protocol)} ${campaign.campaignParameters.symbolTargetToken} vault`;
-        case Erc20SubType.stability:
-            return `Hold ${typeInfo.name}`;
-        default:
-            // OVERRIDE
-            switch (typeInfo.tokenAddress) {
-                case "0x3a8099D8FE5C072bB035381003993393072D3ec7":
-                    return "Hold pufETH on DeSyn (dpufETH)";
-                case "0x1f2aa9680910aC5a4527FA72001dC249943f60b4":
-                    return "Hold pufETH on Karak";
-                default:
-                    return `Hold ${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken})`;
-            }
-    }
-}

package/dist/src/utils/generic.js

@@ -1,43 +0,0 @@
-import { withRetry } from "@sdk";
-import { BigNumber } from "ethers";
-import { MAX_NUM_SUBCALLS } from "../constants";
-import { multicalls } from "./providers";
-async function archiveContractMethodCall(contract, args) {
-    return contract.interface.decodeFunctionResult("aggregate3", !!args.blockNumber
-        ? await contract.provider.call({
-            data: contract.interface.encodeFunctionData("aggregate3", [args.calls]),
-            to: contract.address,
-        }, BigNumber.from(args.blockNumber).toNumber())
-        : await contract.provider.call({
-            data: contract.interface.encodeFunctionData("aggregate3", [args.calls]),
-            to: contract.address,
-        }))[0];
-}
-export async function batchMulticallCallWithRetry(chainId, args) {
-    let fetchedData = [];
-    let remainingCalls = args.calls.length;
-    let lowerIdx = 0;
-    let upperIdx = Math.min(args.calls.length, MAX_NUM_SUBCALLS);
-    const multicallBatch = [];
-    while (remainingCalls !== 0) {
-        multicallBatch.push(await withRetry(archiveContractMethodCall, [
-            multicalls[chainId],
-            {
-                blockNumber: args.blockNumber,
-                calls: args.calls.slice(lowerIdx, upperIdx),
-            },
-        ]));
-        remainingCalls -= upperIdx - lowerIdx;
-        lowerIdx = upperIdx;
-        upperIdx = Math.min(args.calls.length, upperIdx + MAX_NUM_SUBCALLS);
-    }
-    /** Executing batched multicall */
-    const results = await Promise.allSettled(multicallBatch);
-    for (let k = 0; k < results.length; k++) {
-        const res = results[k];
-        if (res.status === "fulfilled") {
-            fetchedData = fetchedData.concat(res.value);
-        }
-    }
-    return fetchedData;
-}

package/dist/src/utils/hashArray.js

@@ -1,7 +0,0 @@
-import crypto from "node:crypto";
-export function sha256(x) {
-    return crypto.createHash("sha256").update(x).digest("hex");
-}
-export function hashArray(...args) {
-    return args.length > 0 ? sha256(JSON.stringify(args.map(a => a.toString()))) : "";
-}

package/dist/src/utils/lastBlockBefore.js

@@ -1,78 +0,0 @@
-import { Redis } from "@/cache";
-import { hashArray } from "@/utils/hashArray";
-import { BigNumber } from "ethers";
-import moment from "moment";
-import { log } from "./logger";
-import { providers } from "./providers";
-/**
- * Fetches the timestamp of a block with up to RETRIES retries in case of failure
- */
-const RETRIES = 10;
-export const getBlockTimestamp = async (provider, blockNumber) => {
-    let res = null;
-    let trial = 0;
-    while (res === null && trial < RETRIES) {
-        try {
-            res = await provider.send("eth_getBlockByNumber", [`0x${blockNumber.toString(16)}`, false]);
-        }
-        catch { }
-        trial++;
-    }
-    if (trial > 1) {
-        console.log(`${trial - 1} calls failed fetching blocktimestamp for block ${blockNumber}.`);
-    }
-    return BigNumber.from(res?.timestamp).toNumber();
-};
-/**
- * Binary search to search the last block before a given timestamp
- */
-const getLastBlockBefore = async (timestamp, chainId) => {
-    if (moment().unix() < timestamp) {
-        log.error("getLastBlockBefore", `Timestamp ${timestamp} is in the future`);
-        return 0;
-    }
-    const provider = providers[chainId];
-    const current = await provider.getBlockNumber();
-    let upper = current;
-    let lower = 0;
-    let step = Math.floor((upper - lower) / 2);
-    let fixUpper = false;
-    let fixLower = false;
-    while (upper - lower > 1) {
-        // Reduce step size of interval has been found
-        if (upper - lower < 2 * step) {
-            step = Math.floor(step / 2);
-            fixUpper = false;
-            fixLower = false;
-        }
-        // Check reduction of upper bound
-        if (!fixUpper) {
-            const auxUpper = upper - step;
-            const auxUpperTimestamp = await getBlockTimestamp(provider, auxUpper);
-            if (auxUpperTimestamp > timestamp) {
-                upper = auxUpper;
-            }
-            else {
-                fixUpper = true;
-            }
-        }
-        // Check reduction of lower bound
-        if (!fixLower) {
-            const auxLower = lower + step;
-            const auxLowerTimestamp = await getBlockTimestamp(provider, auxLower);
-            if (auxLowerTimestamp <= timestamp) {
-                lower = auxLower;
-            }
-            else {
-                // auxLower timestamp >= timestamp
-                // We want to return the last block with a timestamp <= timestamp
-                fixLower = true;
-                if (auxLowerTimestamp === timestamp) {
-                    return auxLower;
-                }
-            }
-        }
-    }
-    return lower;
-};
-export const getLastBlockBeforeWithCache = async (timestamp, chainId) => await Redis.getOrSet(`LastBlockBefore_${hashArray([timestamp, chainId])}`, getLastBlockBefore, timestamp, chainId);

package/dist/src/utils/logger.js

@@ -1,52 +0,0 @@
-import { createPinoLogger } from "@bogeychan/elysia-logger";
-export const logger = createPinoLogger({
-    base: undefined,
-    formatters: {
-        level(level) {
-            return { level };
-        },
-    },
-    level: process.env.LOG_LEVEL || "info",
-    name: process.env.APP_NAME || "api",
-    transport: process.env.ENV !== "local"
-        ? undefined
-        : {
-            options: {
-                colorize: true,
-                ignore: "time,name,hostname,pid,baseUrl,fullUrl,requestId,chain",
-                messageFormat: "\u001b[35m{baseUrl}\u001b[39m \u001b[33m{chain}\u001b[39m {msg}",
-            },
-            target: "pino-pretty",
-        },
-});
-const logConstructor = (type, message, errorMessage, onlyDev, service, url) => {
-    if (onlyDev && process.env.ENV !== "local")
-        return;
-    if (type === "error") {
-        if (!!service && !!url) {
-            logger.child({ service, url }).error(errorMessage, message);
-        }
-        else if (!!service) {
-            logger.child({ service }).error(errorMessage, message);
-        }
-        else {
-            logger.error(errorMessage, message);
-        }
-    }
-    else if (type === "warn") {
-        logger.warn(message);
-    }
-    else if (type === "debug") {
-        logger.debug(message);
-    }
-    else {
-        logger.info(message);
-    }
-};
-export const log = {
-    debug: (message) => logConstructor("debug", message),
-    error: (message, errorMessage, service, url) => logConstructor("error", message, errorMessage, false, service, url),
-    info: (message) => logConstructor("info", message),
-    local: (message) => logConstructor("info", message, undefined, true),
-    warn: (message) => logConstructor("warn", message),
-};

package/dist/src/utils/parseDistributionType.js

@@ -1,16 +0,0 @@
-import { DistributionType } from "@db/api";
-export const parseDistributionType = (params) => {
-    if ("targetTokenPricing" in params && "rewardTokenPricing" in params && "apr" in params) {
-        if (params.targetTokenPricing && params.rewardTokenPricing) {
-            return DistributionType.FIX_REWARD_VALUE_PER_LIQUIDITY_VALUE;
-        }
-        if (params.rewardTokenPricing) {
-            return DistributionType.FIX_REWARD_VALUE_PER_LIQUIDITY_AMOUNT;
-        }
-        if (params.targetTokenPricing) {
-            return DistributionType.FIX_REWARD_AMOUNT_PER_LIQUIDITY_VALUE;
-        }
-        return DistributionType.FIX_REWARD_AMOUNT_PER_LIQUIDITY_AMOUNT;
-    }
-    return DistributionType.DUTCH_AUCTION;
-};