@merkl/api 0.10.129 → 0.10.130

package/dist/src/utils/prices/uniV2Price.js

@@ -0,0 +1,40 @@
+import { BN2Number, Stable, UniswapV2PoolInterface } from "@sdk";
+import { Contract } from "ethers";
+import { multicalls, providers } from "../providers";
+export async function getCurveV2Price(chainId, prices, pool, token) {
+    const abi = [
+        "function balances(uint256) external view returns(uint256)",
+        "function totalSupply() external view returns(uint256)",
+        "function token() external view returns(address)",
+    ];
+    const contract = new Contract(pool, abi, providers[chainId]);
+    const tokenContract = new Contract(token, abi, providers[chainId]);
+    return ((BN2Number(await contract.balances(0)) * prices["FRAX"] +
+        BN2Number(await contract.balances(1)) * prices[Stable.EUR]) /
+        BN2Number(await tokenContract.totalSupply()));
+}
+export async function getUniV2Price(chainId, priceToken0, priceToken1, poolAddress) {
+    const [, result] = await multicalls[chainId].callStatic.aggregate([
+        {
+            callData: UniswapV2PoolInterface.encodeFunctionData("getReserves"),
+            target: poolAddress,
+        },
+        {
+            callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
+            target: poolAddress,
+        },
+        {
+            callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
+            target: poolAddress,
+        },
+        {
+            callData: UniswapV2PoolInterface.encodeFunctionData("totalSupply"),
+            target: poolAddress,
+        },
+    ]);
+    const [reserve0, reserve1] = UniswapV2PoolInterface.decodeFunctionResult("getReserves", result[0]);
+    const _token0 = UniswapV2PoolInterface.decodeFunctionResult("token0", result[1])[0];
+    const _token1 = UniswapV2PoolInterface.decodeFunctionResult("token1", result[2])[0];
+    const totalSupply = UniswapV2PoolInterface.decodeFunctionResult("token1", result[3])[0];
+    return (BN2Number(reserve0) * priceToken0 + BN2Number(reserve1) * priceToken1) / BN2Number(totalSupply);
+}

package/dist/src/utils/prisma.js

@@ -0,0 +1,12 @@
+import { PrismaClient as ApiPrismaClient } from "../../database/api/.generated";
+import { PrismaClient as EnginePrismaClient } from "../../database/engine/.generated";
+export const apiDbClient = new ApiPrismaClient({
+    datasources: { db: { url: `${process.env.DATABASE_API_URL}&connection_limit=250&pool_timeout=15` } },
+});
+export const engineDbClient = new EnginePrismaClient({
+    datasources: {
+        db: {
+            url: `${process.env.DATABASE_ENGINE_URL}&connection_limit=20&pool_timeout=15`,
+        },
+    },
+});

package/dist/src/utils/providers.js

@@ -0,0 +1,30 @@
+import { ChainId, MULTICALL_ADDRESS, Multicall__factory } from "@sdk";
+import { providers as p } from "ethers";
+export const providers = Object.keys(ChainId).reduce((prev, chainId) => {
+    const url = process.env?.[`PROVIDER_${chainId}`];
+    if (!!url)
+        prev[chainId] = new p.StaticJsonRpcProvider(url);
+    return prev;
+}, {});
+export const archiveProviders = Object.keys(ChainId).reduce((prev, chainId) => {
+    const url = !!process.env?.[`PROVIDER_ARCHIVE_${chainId}`]
+        ? process.env?.[`PROVIDER_ARCHIVE_${chainId}`]
+        : process.env?.[`PROVIDER_${chainId}`];
+    if (!!url)
+        prev[chainId] = new p.StaticJsonRpcProvider(url);
+    return prev;
+}, {});
+export const multicalls = Object.keys(ChainId).reduce((prev, chainId) => {
+    if (!!providers[chainId])
+        prev[chainId] = Multicall__factory.connect(MULTICALL_ADDRESS(chainId), providers[chainId]);
+    // else {
+    // if (Number.parseInt(chainId).toString() === chainId)
+    // log.warn(`No provider found for chain ${NETWORK_LABELS[chainId as unknown as ChainId]}`);
+    // }
+    return prev;
+}, {});
+export const archiveMulticalls = Object.keys(ChainId).reduce((prev, chainId) => {
+    if (!!archiveProviders[chainId])
+        prev[chainId] = Multicall__factory.connect("0xcA11bde05977b3631167028862bE2a173976CA11", archiveProviders[chainId]);
+    return prev;
+}, {});

package/dist/src/utils/queries/activeCampaigns.js

@@ -0,0 +1,22 @@
+import { Prisma } from "../../../database/engine/.generated";
+export const ACTIVE_CAMPAIGNS_FOR_CHAIN = (chainId, now) => Prisma.sql `
+    SELECT
+        *,
+        CAST("amount" as numeric) / (10^CAST("campaignParameters"->>'decimalsRewardToken' as numeric)) as "amountWithDecimals"
+    FROM "Campaigns"
+    WHERE 
+        "chainId" = ${chainId} AND
+        "startTimestamp" <= ${now} AND
+        "endTimestamp" >= ${now} AND
+        "campaignType" != 0
+    `;
+export const ACTIVE_CAMPAIGNS = (now) => Prisma.sql `
+    SELECT
+        *,
+        CAST("amount" as numeric) / (10^CAST("campaignParameters"->>'decimalsRewardToken' as numeric)) as "amountWithDecimals"
+    FROM "Campaigns"
+    WHERE 
+        "startTimestamp" <= ${now} AND
+        "endTimestamp" >= ${now} AND
+        "campaignType" != 0
+    `;

package/dist/src/utils/queries/allCampaigns.js

@@ -0,0 +1,51 @@
+import { Prisma } from "../../../database/engine/.generated";
+export const ALL_CAMPAIGNS_FOR_CHAIN_AFTER = (chainId, after) => Prisma.sql `
+    SELECT
+        *
+    FROM "Campaigns"
+    WHERE
+        (("chainId" = ${chainId} AND "computeChainId" = 0) OR "computeChainId" = ${chainId}) AND
+        "campaignType" != 0 AND
+        "endTimestamp" >= ${after} AND
+        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
+        
+    `;
+export const ALL_CAMPAIGNS_FOR_CHAIN_BEFORE = (chainId, before) => Prisma.sql `
+    SELECT
+        *
+    FROM "Campaigns"
+    WHERE
+        (("chainId" = ${chainId} AND "computeChainId" = 0) OR "computeChainId" = ${chainId}) AND
+        "campaignType" != 0 AND
+        "endTimestamp" < ${before} AND
+        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
+    `;
+export const ALL_CAMPAIGNS_FOR_CHAIN = (chainId) => Prisma.sql `
+    SELECT
+        *
+    FROM "Campaigns"
+    WHERE
+        (("chainId" = ${chainId} AND "computeChainId" = 0) OR "computeChainId" = ${chainId}) AND
+        "campaignType" != 0 AND
+        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
+    `;
+export const ALL_CAMPAIGNS = () => Prisma.sql `
+    SELECT
+        *
+    FROM "Campaigns"
+    WHERE
+        "campaignType" != 0 AND
+        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
+    `;
+export const ALL_CAMPAIGNS_FOR_CHAINS_AND_CREATOR_TAG = (chainIds, creatorTag) => Prisma.sql `
+    SELECT
+        "chainId", "campaignId"
+    FROM "Campaigns"
+    WHERE
+        "campaignType" != 0 AND
+        (("chainId" IN (${Prisma.join(chainIds)}) AND "computeChainId" = 0) OR "computeChainId" IN (${Prisma.join(chainIds)})) AND
+        creator IN (
+            SELECT address from "CampaignCreators" WHERE tags LIKE ${`%${creatorTag}%`}
+        ) AND
+        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
+    `;

package/dist/src/utils/queries/campaignsForMainParameter.js

@@ -0,0 +1,23 @@
+import { Prisma } from "../../../database/engine/.generated";
+export const CAMPAIGNS_BY_MAIN_PARAMETER = (chainId, mainParameter) => Prisma.sql `
+    SELECT
+        campaigns."campaignId",
+        campaigns."campaignType",
+        campaigns."rewardToken",
+        tokens."symbol" as "rewardTokenSymbol",
+        CAST(campaigns."amount" as numeric) / (10^campaigns."decimalsRewardToken") as "amountDecimal",
+        campaigns."startTimestamp",
+        campaigns."endTimestamp"
+    FROM (
+        SELECT
+            "chainId", "campaignId", "campaignType", "rewardToken", "amount", "startTimestamp", "endTimestamp", CAST("campaignParameters"->>'decimalsRewardToken' as numeric) as "decimalsRewardToken"
+        FROM "Campaigns"
+        WHERE
+            "chainId" = ${chainId} AND
+            "campaignType" != 0 AND
+            LOWER("mainParameter") = LOWER(${mainParameter})
+        ORDER BY "endTimestamp" DESC
+    ) as campaigns
+    INNER JOIN "Tokens" as tokens
+    ON tokens."address"=campaigns."rewardToken" AND tokens."chainId"=campaigns."chainId"
+    `;

package/dist/src/utils/queries/claimsOverTime.js

@@ -0,0 +1,111 @@
+import { Prisma } from "../../../database/engine/.generated";
+export const CLAIMS_OVER_TIME = (chainId, campaignId) => Prisma.sql `
+    SELECT timestamp, recipient, reason, claimed
+    FROM "ClaimsOverTime"
+    WHERE
+        "chainId"=${chainId} AND
+        "campaignId"=${campaignId} 
+    ORDER BY timestamp ASC
+    `;
+export const CLAIMS_OVER_TIME_GROUPED = (chainId, campaignId) => Prisma.sql `
+    SELECT timestamp, recipient, SUM(CAST(claimed as numeric)) as claimed
+    FROM "ClaimsOverTime"
+    WHERE
+        "chainId"=${chainId} AND
+        "campaignId"=${campaignId} 
+    GROUP BY timestamp, recipient
+    ORDER BY timestamp ASC
+    `;
+export const CLAIMS_OVER_TIME_V2 = (chainId, campaignId) => Prisma.sql `
+
+    SELECT cot.timestamp, cot.recipient, cot.reason, cot.claimed, COALESCE(cc.label, 'unknown') FROM (
+        SELECT *
+        FROM "ClaimsOverTime"
+        WHERE
+            "chainId"=${chainId} AND
+            "campaignId"=${campaignId} 
+                ) as cot
+        LEFT JOIN (
+            SELECT "campaignId", "creator", "mainParameter"
+            FROM "Campaigns"
+            WHERE
+                "chainId"=${chainId} AND
+                "campaignId"=${campaignId} 
+            ) as campaigns
+        ON cot."campaignId"=campaigns."campaignId"
+        LEFT JOIN
+            "CampaignCreators" as cc
+        ON campaigns.creator=cc.address
+    `;
+export const CLAIMS_FOR_CREATOR_TAG = (chainIds, user, creatorTag) => Prisma.sql `
+    SELECT cc."chainId", cc.timestamp, cc.recipient, cc.reason, cc."rewardToken" as token, cc."campaignId", t.symbol, t.decimals, cc.claimed FROM (
+        SELECT "chainId", timestamp, recipient, reason, "campaignId", "rewardToken", CAST(claimed AS text) as claimed
+        FROM "ClaimsOverTime"
+        WHERE
+            "chainId" IN (${Prisma.join(chainIds)}) AND
+            "recipient"=${user} AND
+            "campaignId" IN (
+                SELECT
+                    "campaignId"
+                FROM "Campaigns"
+                WHERE
+                    "campaignType" != 0 AND
+                    "chainId" IN (${Prisma.join(chainIds)}) AND
+                    creator IN (
+                        SELECT address from "CampaignCreators" WHERE tags LIKE ${`%${creatorTag}%`}
+                    )
+            )
+    ) as cc
+     LEFT JOIN "Tokens" as t
+     ON cc."chainId"=t."chainId" AND cc."rewardToken"=t.address
+     ORDER BY cc.timestamp ASC
+    `;
+export const CLAIMS_FOR_CREATOR_TAG_GROUPED = (chainIds, user, creatorTag) => Prisma.sql `
+    SELECT cc."chainId", cc.timestamp, cc.recipient, cc."campaignId", cc."rewardToken" as token, t.symbol, t.decimals, cc.claimed FROM (
+        SELECT "chainId", timestamp, recipient, "rewardToken", "campaignId", CAST(SUM(CAST(claimed AS numeric)) AS text) as claimed
+        FROM "ClaimsOverTime"
+        WHERE
+            "chainId" IN (${Prisma.join(chainIds)}) AND
+            "recipient"=${user} AND
+            "campaignId" IN (
+                SELECT
+                    "campaignId"
+                FROM "Campaigns"
+                WHERE
+                    "campaignType" != 0 AND
+                    "chainId" IN (${Prisma.join(chainIds)}) AND
+                    creator IN (
+                        SELECT address from "CampaignCreators" WHERE tags LIKE ${`%${creatorTag}%`}
+                    )
+            )
+        GROUP BY timestamp, recipient, "chainId", "rewardToken", "campaignId"
+    ) as cc
+     LEFT JOIN "Tokens" as t
+     ON cc."chainId"=t."chainId" AND cc."rewardToken"=t.address
+     ORDER BY cc.timestamp ASC
+    `;
+export const CLAIMS_FOR_USER = (chainIds, user) => Prisma.sql `
+    SELECT cc."chainId", cc.timestamp, cc.recipient, cc.reason, cc."campaignId", cc."rewardToken" as token, t.symbol, t.decimals, cc.claimed FROM (
+        SELECT "chainId", timestamp, recipient, reason, "campaignId", "rewardToken", CAST(claimed AS text) as claimed
+        FROM "ClaimsOverTime"
+        WHERE
+            "chainId" IN (${Prisma.join(chainIds)}) AND
+            "recipient"=${user}
+        ) as cc
+     LEFT JOIN "Tokens" as t
+     ON cc."chainId"=t."chainId" AND cc."rewardToken"=t.address
+     ORDER BY cc.timestamp ASC
+    `;
+export const CLAIMS_FOR_USER_GROUPED = (chainIds, user) => Prisma.sql `
+    SELECT cc."chainId", cc.timestamp, cc.recipient, cc."campaignId", cc."rewardToken" as token, t.symbol, t.decimals, cc.claimed FROM (
+        SELECT "chainId", timestamp, recipient, "campaignId", "rewardToken", CAST(SUM(CAST(claimed as numeric)) as text) as claimed
+        FROM "ClaimsOverTime"
+        WHERE
+            "chainId" IN (${Prisma.join(chainIds)}) AND
+            "recipient"=${user}
+        GROUP BY timestamp, recipient, "chainId", "rewardToken", "campaignId"
+        ) as cc
+     LEFT JOIN "Tokens" as t
+     ON cc."chainId"=t."chainId" AND cc."rewardToken"=t.address
+     ORDER BY cc.timestamp ASC
+    `;

package/dist/src/utils/queries/endingCampaigns.js

@@ -0,0 +1,21 @@
+import { Prisma } from "../../../database/engine/.generated";
+export const ENDING_CAMPAIGNS = (maxEndDate, minStartDate, minEndDate) => Prisma.sql `
+    SELECT c."chainId", c.creator, t.symbol, CAST(c.amount as numeric) / 10^t.decimals as amount, c."endTimestamp" FROM (
+        SELECT * FROM "Campaigns" WHERE "endTimestamp"<=${maxEndDate}
+        AND "startTimestamp">=${minStartDate} AND "endTimestamp">=${minEndDate}
+    ) as c
+    INNER JOIN "Tokens" as t
+    ON c."chainId"=t."chainId" AND c."rewardToken"=t.address
+    `;
+export const NON_RENEWED_CAMPAIGNS = (maxEndDate, minStartDate, minEndDate) => Prisma.sql `
+    SELECT c."chainId", c.creator, t.symbol, CAST(c.amount as numeric) / 10^t.decimals as amount, c."endTimestamp", c."mainParameter", cf."campaignId" FROM (
+        SELECT * FROM "Campaigns" WHERE "endTimestamp"<=${maxEndDate}
+        AND "startTimestamp">=${minStartDate} AND "endTimestamp">=${minEndDate}
+    ) as c
+    LEFT JOIN (
+        SELECT DISTINCT ON (c."chainId", c."mainParameter", c."rewardToken") * FROM "Campaigns" as c WHERE c."endTimestamp">${maxEndDate}
+    ) as cf
+    ON c."chainId"=cf."chainId" AND c."mainParameter"=cf."mainParameter" AND c."rewardToken"=cf."rewardToken"
+    INNER JOIN "Tokens" as t
+    ON c."chainId"=t."chainId" AND c."rewardToken"=t.address
+`;

package/dist/src/utils/queries/futureCampaigns.js

@@ -0,0 +1,19 @@
+import { Prisma } from "../../../database/engine/.generated";
+export const FUTURE_CAMPAIGNS_FOR_CHAIN = (chainId, now) => Prisma.sql `
+    SELECT
+        *
+    FROM "Campaigns"
+    WHERE
+        "chainId" = ${chainId} AND
+        "startTimestamp" >= ${now} AND
+        "campaignType" != 0
+        
+    `;
+export const FUTURE_CAMPAIGNS = (now) => Prisma.sql `
+    SELECT
+        *
+    FROM "Campaigns"
+    WHERE
+        "startTimestamp" >= ${now} AND
+        "campaignType" != 0
+    `;

package/dist/src/utils/queries/mainParameterCampaigns.js

@@ -0,0 +1,11 @@
+import { Prisma } from "../../../database/engine/.generated";
+export const CAMPAIGNS_FOR_MAIN_PARAMETER = (chainId, mainParameter) => Prisma.sql `
+    SELECT
+        "campaignId"
+    FROM
+        "Campaigns"
+    WHERE
+        "chainId" = ${chainId} AND
+        "mainParameter" = ${mainParameter} AND
+        "campaignType" != 0
+    `;

package/dist/src/utils/queries/rewardsAmount.js

@@ -0,0 +1,106 @@
+import { Prisma } from "../../../database/engine/.generated";
+export const REWARDS_DELTA = (chainId, campaignIds, fromRoot, toRoot) => Prisma.sql `
+    SELECT * FROM (
+        SELECT
+            leaves_state_to.recipient,
+            leaves_state_to.reason,
+            leaves_state_to."rewardToken",
+            CAST(COALESCE(leaves_state_to.reward_sum - COALESCE(leaves_state_from.reward_sum, 0), 0) as text) as amount
+        FROM
+            (
+                SELECT
+                    "chainId",
+                    recipient,
+                    reason,
+                    "rewardToken",
+                    SUM(CAST("amount" as numeric)) as reward_sum
+                FROM "Leaves"
+                WHERE
+                    "chainId" = ${chainId} AND
+                    root = ${toRoot} AND
+                    "campaignId" IN (${Prisma.join(campaignIds)})
+                    
+                GROUP BY recipient, reason, "rewardToken", "chainId"
+            ) as leaves_state_to
+        LEFT JOIN
+            (
+                SELECT
+                    "chainId",
+                    recipient,
+                    reason,
+                    "rewardToken",
+                    SUM(CAST("amount" as numeric)) as reward_sum
+                FROM "Leaves"
+                WHERE
+                    "chainId" = ${chainId} AND
+                    root = ${fromRoot} AND
+                    "campaignId" IN (${Prisma.join(campaignIds)})
+                GROUP BY recipient, reason, "rewardToken", "chainId"
+            ) as leaves_state_from
+        ON 
+            leaves_state_to."chainId"=leaves_state_from."chainId" AND
+            leaves_state_to.reason=leaves_state_from.reason AND
+            leaves_state_to.recipient=leaves_state_from.recipient AND
+            leaves_state_to."rewardToken"=leaves_state_from."rewardToken"
+        ) as rewards_delta
+    WHERE amount != '0'
+    `;
+export const CAMPAIGN_REWARDS_DELTA = (chainId, campaignId, fromRoot, toRoot) => Prisma.sql `
+    SELECT * FROM (
+        SELECT
+            leaves_state_to.recipient,
+            leaves_state_to.reason,
+            leaves_state_to."rewardToken",
+            CAST(COALESCE(leaves_state_to.reward_sum - COALESCE(leaves_state_from.reward_sum, 0), 0) as text) as amount
+        FROM
+            (
+                SELECT
+                    "chainId",
+                    recipient,
+                    reason,
+                    "rewardToken",
+                    SUM(CAST("amount" as numeric)) as reward_sum
+                FROM "Leaves"
+                WHERE
+                    "chainId" = ${chainId} AND
+                    root = ${toRoot} AND
+                    "campaignId"=${campaignId}
+                    
+                GROUP BY recipient, reason, "rewardToken", "chainId"
+            ) as leaves_state_to
+        LEFT JOIN
+            (
+                SELECT
+                    "chainId",
+                    recipient,
+                    reason,
+                    "rewardToken",
+                    SUM(CAST("amount" as numeric)) as reward_sum
+                FROM "Leaves"
+                WHERE
+                    "chainId" = ${chainId} AND
+                    root = ${fromRoot} AND
+                    "campaignId"=${campaignId}
+                GROUP BY recipient, reason, "rewardToken", "chainId"
+            ) as leaves_state_from
+        ON 
+            leaves_state_to."chainId"=leaves_state_from."chainId" AND
+            leaves_state_to.reason=leaves_state_from.reason AND
+            leaves_state_to.recipient=leaves_state_from.recipient AND
+            leaves_state_to."rewardToken"=leaves_state_from."rewardToken"
+        ) as rewards_delta
+    WHERE amount != '0'
+    `;
+export const LATEST_CAMPAIGNS_REWARDS = (chainId, root, campaignIds) => Prisma.sql `
+    SELECT 
+        recipient,
+        reason,
+        "rewardToken",
+        CAST(SUM(CAST("amount" as numeric)) as text) as amount
+    FROM "Leaves"
+    WHERE
+        "chainId" = ${chainId} AND
+        root = ${root} AND
+        "campaignId" IN (${Prisma.join(campaignIds)})
+    GROUP BY recipient, reason, "rewardToken"
+`;

package/dist/src/utils/queries/unclaimed.js

@@ -0,0 +1,81 @@
+import { Prisma } from "../../../database/engine/.generated";
+export const UNCLAIMED_BEFORE = (timestamp) => Prisma.sql `
+    SELECT cf."chainId", cf."rewardToken", t.symbol, cf.unclaimed / 10^t.decimals as unclaimed
+    FROM (
+        SELECT  c."chainId", c."rewardToken", SUM(CAST(c.amount as numeric) - CAST(COALESCE(cl.claimed, '0') as numeric)) as unclaimed
+        FROM (
+                SELECT * FROM "Campaigns" WHERE "endTimestamp"<${timestamp}
+        ) as c
+            LEFT JOIN
+            (
+            SELECT "chainId", "campaignId", SUM(CAST(claimed as numeric)) as claimed
+            FROM "Claims"
+            GROUP BY "chainId", "campaignId"
+            ) as cl
+        ON cl."campaignId"=c."campaignId" AND cl."chainId"=c."chainId"
+        GROUP BY "rewardToken", c."chainId"
+        ) as cf
+        LEFT JOIN "Tokens" as t
+    ON cf."rewardToken"=t.address AND cf."chainId"=t."chainId"
+    `;
+export const UNCLAIMED_BY_CAMPAIGN = (currentRoot, chainId, campaignId) => Prisma.sql `
+    SELECT  l.recipient, l.total_amount - COALESCE(cl.claimed, 0) as unclaimed
+    FROM (
+        SELECT "recipient", SUM(CAST(amount as numeric)) as total_amount FROM "Leaves"
+        WHERE
+            root=${currentRoot} AND
+            "chainId"=${chainId} AND
+            "campaignId"=${campaignId}
+        GROUP BY "recipient"
+    ) as l
+    LEFT JOIN
+        (
+        SELECT "recipient", SUM(CAST(claimed as numeric)) as claimed
+        FROM "Claims"
+        WHERE
+            "chainId"=${chainId} AND
+            "campaignId"=${campaignId}
+        GROUP BY recipient
+        ) as cl
+    ON l."recipient"=cl."recipient"
+    `;
+export const UNCLAIMED_FOR_CAMPAIGNS = (chainId, campaignIds) => Prisma.sql `
+    SELECT  c."campaignId", CAST(c.total_amount - COALESCE(cl.claimed, 0) as text) as unclaimed
+    FROM (
+        SELECT "campaignId", CAST(amount as numeric) as total_amount FROM "Campaigns"
+        WHERE
+            "chainId"=${chainId} AND
+            "campaignId" IN (${Prisma.join(campaignIds)})
+    ) as c
+    LEFT JOIN
+        (
+        SELECT "campaignId", SUM(CAST(claimed as numeric)) as claimed
+        FROM "Claims"
+        WHERE
+            "chainId"=${chainId} AND
+            "campaignId" IN (${Prisma.join(campaignIds)})
+        GROUP BY "campaignId"
+        ) as cl
+    ON c."campaignId"=cl."campaignId"
+    `;
+export const UNCLAIMED_BY_TOKEN = (currentRoot, chainId, rewardToken) => Prisma.sql `
+    SELECT  l.recipient, l.total_amount - COALESCE(cl.claimed, 0) as unclaimed
+    FROM (
+        SELECT "recipient", SUM(CAST(amount as numeric)) as total_amount FROM "Leaves"
+        WHERE
+            root=${currentRoot} AND
+            "chainId"=${chainId} AND
+            "rewardToken"=${rewardToken}
+        GROUP BY "recipient"
+    ) as l
+    LEFT JOIN
+        (
+        SELECT "recipient", SUM(CAST(claimed as numeric)) as claimed
+        FROM "Claims"
+        WHERE
+            "chainId"=${chainId} AND
+            "rewardToken"=${rewardToken}
+        GROUP BY recipient
+        ) as cl
+    ON l."recipient"=cl."recipient"
+    `;

package/dist/src/utils/rateLimit.js

@@ -0,0 +1,13 @@
+import { rateLimit } from "elysia-rate-limit";
+import { app } from "..";
+//returns ip from headers if server is null to make elysia-rate-limit logs stfu
+const generator = req => {
+    return (app?.server?.requestIP?.(req)?.address ?? req.headers.get("X-Forwarded-For")?.split(",")?.[0]);
+};
+//use very permissive rates in local
+const rate = (duration, max) => rateLimit(Bun.env.NODE_ENV !== "production" ? { duration: 1, max: 100 } : { duration, max });
+export default {
+    permissive: rate(1000, 18),
+    moderate: rate(1000, 9),
+    strict: rate(1000, 3),
+};

package/dist/src/utils/stryke.js

@@ -0,0 +1,4 @@
+import { AMM } from "@sdk";
+export function isStrykeCampaign(amm) {
+    return [AMM.Stryke, AMM.StrykePCS, AMM.StrykeSushi].includes(amm);
+}

package/dist/src/utils/throw.js

@@ -0,0 +1,27 @@
+import { isSupportedChain } from "@sdk";
+import { utils } from "ethers";
+import { InvalidParameter, UnsupportedNetwork } from "./error";
+export const throwOnInvalidRequiredAddress = (address) => {
+    try {
+        if (!address)
+            throw new InvalidParameter("Address is required");
+        return utils.getAddress(address?.toLowerCase());
+    }
+    catch (_) {
+        throw new InvalidParameter(`Address ${address} is invalid`);
+    }
+};
+export const throwOnInvalidAddress = (address) => {
+    try {
+        if (!address)
+            return;
+        return utils.getAddress(address?.toLowerCase());
+    }
+    catch (_) {
+        throw new InvalidParameter(`Address ${address} is invalid`);
+    }
+};
+export const throwOnUnsupportedChainId = (chainId) => {
+    if (chainId && !isSupportedChain(chainId, "merkl"))
+        throw new UnsupportedNetwork(chainId);
+};

package/dist/src/utils/validation.js

@@ -0,0 +1,20 @@
+import chalk from "chalk";
+export const soft = (p) => chalk.gray(p);
+export const bold = (p) => chalk.bold.yellow(p);
+export const err = (p) => chalk.red(p);
+export function logValidationErrors(errors) {
+    if (errors.length) {
+        for (const error of errors.splice(0, 5)) {
+            const errorPath = [
+                error.path
+                    .split("/")
+                    .flatMap((path, index, all) => index === all.length - 1 ? [bold(path), `(${error.value})`] : [soft(path), soft(" -> ")])
+                    .join(""),
+            ].join("");
+            console.log(errorPath);
+            console.error(chalk.gray(" ->"), err(error.message), "\n");
+        }
+        return true;
+    }
+    return errors.length !== 0;
+}