@merkl/api 0.21.46 → 1.0.0

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

@@ -1,100 +0,0 @@
-import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { UnsupportedNetwork } from "@/utils/error";
-import { throwOnInvalidAddress, throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
-import Elysia, { t } from "elysia";
-import { TTLPresets } from "../cache/cache.model";
-import { ChainUniqueDto } from "../chain/chain.model";
-import { Bytes32Dto, RewardsPerPositionDto, UniV4ChainIdArray, UniswapV4PoolDto, } from "./uniswap.model";
-import { UniswapService } from "./uniswap.service";
-export const UniswapController = new Elysia({
-    prefix: "uniswap",
-    detail: { tags: ["Uniswap"] },
-})
-    .group("/reward", app => {
-    return app
-        .get("/3", async ({ query }) => {
-        return await UniswapService.findRewardsPerPosition("v3", query);
-    }, {
-        query: RewardsPerPositionDto,
-        beforeHandle: ({ query }) => {
-            query.address = throwOnInvalidRequiredAddress(query.address);
-            if (!!query.chainId)
-                throwOnUnsupportedChainId(query.chainId);
-            query.pool = throwOnInvalidAddress(query.pool);
-        },
-        detail: {
-            description: "Get rewards earned grouped by pool and Uniswap V3 position. Warning: this endpoint is still in beta.",
-        },
-    })
-        .get("/4", async ({ query }) => {
-        return await UniswapService.findRewardsPerPosition("v4", query);
-    }, {
-        query: RewardsPerPositionDto,
-        beforeHandle: ({ query }) => {
-            query.address = throwOnInvalidRequiredAddress(query.address);
-            if (!!query.chainId)
-                throwOnUnsupportedChainId(query.chainId);
-        },
-        detail: {
-            description: "Get rewards earned grouped by pool and Uniswap V4 position. Warning: this endpoint is still in beta.",
-        },
-    });
-})
-    .group("/v4", app => {
-    return app
-        .get(
-    // TODO: add pagination
-    "/pools", async () => {
-        return await CacheService.wrap(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools);
-    }, {
-        detail: {
-            description: "Get Uniswap V4 pools by chain",
-            hide: true,
-        },
-    })
-        .get("pools/:chainId", async ({ params }) => {
-        return ((await CacheService.wrap(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools))[params.chainId] ?? {});
-    }, {
-        params: ChainUniqueDto,
-        beforeHandle: ({ params }) => {
-            if (!UniV4ChainIdArray.includes(params.chainId))
-                throw new UnsupportedNetwork(params.chainId);
-        },
-        response: t.Record(t.String(), // poolId
-        UniswapV4PoolDto),
-        detail: {
-            hide: true,
-        },
-    })
-        .get("/:poolId", async ({ params }) => {
-        return Object.values(await CacheService.wrap(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools))
-            .flatMap(x => (x ? Object.values(x) : []))
-            .filter(p => p.poolId === params.poolId);
-    }, {
-        params: Bytes32Dto,
-        response: t.Array(UniswapV4PoolDto),
-        detail: {
-            hide: true,
-        },
-    })
-        .post("/update", async () => {
-        await CacheService.set(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools);
-    }, {
-        headers: AuthorizationHeadersDto,
-        beforeHandle: BackOfficeGuard,
-        detail: { hide: true },
-    })
-        .post("/update/:chainId", async ({ params }) => {
-        await CacheService.set(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools, params.chainId);
-    }, {
-        params: ChainUniqueDto,
-        headers: AuthorizationHeadersDto,
-        beforeHandle: async ({ params, headers }) => {
-            BackOfficeGuard({ headers });
-            if (!UniV4ChainIdArray.includes(params.chainId))
-                throw new UnsupportedNetwork(params.chainId);
-        },
-        detail: { hide: true },
-    });
-});

package/dist/src/modules/v4/uniswap/uniswap.model.js

@@ -1,46 +0,0 @@
-import { UniswapV4Addresses } from "@sdk";
-import { t } from "elysia";
-export const UniV4ChainIdArray = Object.keys(UniswapV4Addresses).map((x) => Number(x));
-export var LoggedEntityType;
-(function (LoggedEntityType) {
-    LoggedEntityType["EULER"] = "EULER_VAULT";
-    LoggedEntityType["UNISWAP_V4"] = "UNISWAP_V4";
-})(LoggedEntityType || (LoggedEntityType = {}));
-// DTOs
-// const UniswapV4PoolKeyDto = t.Object({
-//   currency0: t.String(),
-//   currency1: t.String(),
-//   fee: t.Numeric(),
-//   tickSpacing: t.Numeric(),
-//   hooks: t.String(),
-// });
-export const UniswapV4PoolDto = t.Object({
-    chainId: t.Numeric(), // Assuming MerklChainId is a numeric type
-    currency0: t.String(),
-    currency1: t.String(),
-    decimalsCurrency0: t.Numeric(),
-    decimalsCurrency1: t.Numeric(),
-    hooks: t.String(),
-    fetchedAtBlock: t.Numeric(),
-    lpFee: t.Numeric(),
-    poolId: t.String(),
-    symbolCurrency0: t.String(),
-    symbolCurrency1: t.String(),
-    tickSpacing: t.Numeric(),
-});
-export const Bytes32Dto = t.Object({
-    poolId: t.RegExp(/^0x[a-fA-F0-9]{64}$/, {
-        description: "A 32-byte hexadecimal string (bytes32)",
-    }),
-});
-export const RewardsPerPositionDto = t.Object({
-    address: t.String({ description: "Address of the rewarded user" }),
-    chainId: t.Optional(t.Numeric({ description: "Filter on Uniswap pool on a given chain. Default: returns rewards for all chains." })),
-    pool: t.Optional(t.String({
-        description: "Address Or Id of the Uniswap pool. Default: returns rewards for all pools.",
-    })),
-    positionId: t.Optional(t.String({
-        description: "PositionId of the Uniswap position. Can be a tokenId if the position is an NFT or a bytes32 id if held directly on the pool. Default: returns rewards for all positions on the pools.",
-    })),
-});
-export const UniswapV4PoolsDto = t.Record(t.String(), UniswapV4PoolDto);

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

@@ -1,12 +0,0 @@
-import { apiDbClient } from "@db";
-import { LoggedEntityType } from "@db/api";
-export class UniswapRepository {
-    static async getStoredUniswapV4Pools(chainId) {
-        return await apiDbClient.logged.findMany({
-            where: { type: LoggedEntityType.UNISWAP_V4, ...(!!chainId && { chainId: chainId }) },
-        });
-    }
-    static async createMany(data) {
-        return await apiDbClient.logged.createMany({ data });
-    }
-}

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

@@ -1,245 +0,0 @@
-import { safeFetchLogs } from "@/engine/deprecated/dynamicData/utils/fetchLogs";
-import { BlacklistService } from "@/modules/v4/blacklist/blacklist.service";
-import { ChainService } from "@/modules/v4/chain/chain.service";
-import { MerklRootService } from "@/modules/v4/merklRoot/merklRoot.service";
-import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
-import { RewardService } from "@/modules/v4/reward/reward.service";
-import { log } from "@/utils/logger";
-import { providers } from "@/utils/providers";
-import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, getContractCreationBlock, } from "@sdk";
-import { getAddress } from "viem";
-import { LoggedEntityType, UniV4ChainIdArray, } from "./uniswap.model";
-import { UniswapRepository } from "./uniswap.repository";
-export class UniswapService {
-    static async findRewardsPerPosition(version, query) {
-        /** Check if the user is blacklisted */
-        const isBlacklisted = !!(await BlacklistService.isBlacklisted(query.address));
-        // chainId => pool => NFT or Position ID => [rewards]
-        const res = {};
-        if (isBlacklisted)
-            return res;
-        const chains = await ChainService.findMany({});
-        const chainIds = chains.map(({ id }) => id);
-        /** Fetch current Merkle Roots */
-        const merkleRootsPromises = await Promise.allSettled(chainIds.map(chainId => MerklRootService.fetchFromCache(chainId)));
-        const merkleRoots = merkleRootsPromises
-            .filter(({ status }) => status === "fulfilled")
-            .map(x => x.value);
-        /** Get breakdowns of rewards containing the correct version */
-        const rewards = RewardService.format(await RewardService.getByRecipient(query.address, merkleRoots.map(({ live }) => live), true, false, null, version === "v3" ? "UniswapV3" : "UniswapV4"));
-        for (const reward of rewards) {
-            const rewardToken = reward.token;
-            for (const breakdown of reward.breakdowns) {
-                if (version === "v3" && !breakdown.opportunity.explorerAddress)
-                    continue;
-                const pool = version === "v3" ? getAddress(breakdown.opportunity.explorerAddress) : breakdown.reason.split("_")[1];
-                const { opportunity: rawOpportunity, ...props } = breakdown;
-                const opportunity = OpportunityService.formatResponseBase(rawOpportunity);
-                const chainId = opportunity.chainId;
-                const positionId = breakdown.reason.split("_")[version === "v3" ? 1 : 2];
-                // There can be chain, pool and position Id filter in the request
-                if (!!chainId && (!query.chainId || chainId === query.chainId)) {
-                    if (!!pool && (!query.pool || pool === query.pool)) {
-                        if (!!positionId && (!query.positionId || positionId === query.positionId)) {
-                            try {
-                                res[chainId] = res[chainId] ?? {};
-                                res[chainId][pool] = res[chainId][pool] ?? {};
-                                res[chainId][pool][positionId] = res[chainId][pool][positionId] ?? [];
-                                res[chainId][pool][positionId].push({
-                                    ...props,
-                                    opportunity,
-                                    rewardToken,
-                                });
-                            }
-                            catch {
-                                log.warn(`failed to parse positionId for reason for pool ${pool} and version ${version}`);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return res;
-    }
-    static async getUniswapV4Pools(chainId) {
-        let chainIdArray;
-        if (!!chainId) {
-            chainIdArray = [chainId];
-        }
-        else {
-            chainIdArray = UniV4ChainIdArray;
-        }
-        const pools = {};
-        // 0_ Fetch all univ4 pools from API database
-        const storedPools = await UniswapRepository.getStoredUniswapV4Pools(chainId);
-        const res = await Promise.all(chainIdArray.map(async (chainId) => {
-            chainId = chainId;
-            const perChainIdRes = {};
-            const poolManagerAddress = UniswapV4Addresses[chainId]?.PoolManager ?? NULL_ADDRESS;
-            const jsonRPCprovider = providers[chainId];
-            try {
-                // 1_ Get latest uniswapV4 pools for `chainId`
-                const storedPoolsPerChain = storedPools.filter(pool => pool.chainId === chainId);
-                log.info(`found ${storedPoolsPerChain.length} already stored pools on ${NETWORK_LABELS[chainId]}`);
-                let fromBlock;
-                if (storedPoolsPerChain.length > 0) {
-                    fromBlock = Math.max(...storedPoolsPerChain.map(x => x.fetchAtBlock)) + 1;
-                }
-                else {
-                    fromBlock = await getContractCreationBlock(poolManagerAddress, jsonRPCprovider);
-                }
-                if (fromBlock < 0) {
-                    fromBlock = 1;
-                }
-                const toBlock = await jsonRPCprovider.getBlockNumber();
-                const logs = await safeFetchLogs(chainId, // TODO: rm type enforcing
-                [UniswapV4PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock);
-                const decodedPools = await Promise.all(logs.map(async (log) => {
-                    const [id, currency0, currency1, fee, tickSpacing, hooks] = UniswapV4PoolManagerInterface.decodeEventLog("Initialize", log.data, log.topics);
-                    // Match typing
-                    return {
-                        poolId: id,
-                        chainId: chainId,
-                        currency0: currency0,
-                        currency1: currency1,
-                        tickSpacing: tickSpacing,
-                        lpFee: fee,
-                        hooks: hooks,
-                        fetchedAtBlock: Number(log.blockNumber),
-                    };
-                }));
-                log.local(`fetched ${decodedPools.length} pool(s) on ${NETWORK_LABELS[chainId] ?? "Sepolia"} between blocks ${fromBlock} and ${toBlock}`);
-                /** Extra calls batch to get the collateral addresses */
-                const resCurrencies = await ChainInteractionService(chainId).fetchState(decodedPools.flatMap(pool => {
-                    return [
-                        {
-                            allowFailure: true,
-                            callData: ERC20Interface.encodeFunctionData("symbol"),
-                            target: pool.currency0,
-                        },
-                        {
-                            allowFailure: true,
-                            callData: ERC20Interface.encodeFunctionData("decimals"),
-                            target: pool.currency0,
-                        },
-                        {
-                            allowFailure: true,
-                            callData: ERC20Interface.encodeFunctionData("symbol"),
-                            target: pool.currency1,
-                        },
-                        {
-                            allowFailure: true,
-                            callData: ERC20Interface.encodeFunctionData("decimals"),
-                            target: pool.currency1,
-                        },
-                    ].filter(x => x.target !== NULL_ADDRESS);
-                }));
-                let index = 0;
-                for (const pool of decodedPools) {
-                    let symbolCurrency0 = "UNKNOWN";
-                    let decimalsCurrency0 = 18;
-                    if (pool.currency0 !== NULL_ADDRESS) {
-                        try {
-                            symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index].returnData)[0];
-                            if (symbolCurrency0.includes("/") || symbolCurrency0.includes("\u0000")) {
-                                symbolCurrency0 = "INVALID";
-                            }
-                            decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 1].returnData)[0];
-                        }
-                        catch {
-                            log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency0 ${pool.currency0} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
-                        }
-                    }
-                    else {
-                        symbolCurrency0 = "ETH";
-                        decimalsCurrency0 = 18;
-                        index -= 2;
-                    }
-                    let symbolCurrency1 = "UNKNOWN";
-                    let decimalsCurrency1 = 18;
-                    if (pool.currency1 !== NULL_ADDRESS) {
-                        try {
-                            symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index + 2].returnData)[0];
-                            if (symbolCurrency1.includes("/") || symbolCurrency1.includes("\u0000")) {
-                                symbolCurrency1 = "INVALID";
-                            }
-                            decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 3].returnData)[0];
-                        }
-                        catch {
-                            log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency1 ${pool.currency1} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
-                        }
-                    }
-                    else {
-                        symbolCurrency1 = "ETH";
-                        decimalsCurrency1 = 18;
-                        index -= 2;
-                    }
-                    const id = pool.poolId;
-                    perChainIdRes[id ?? "unknownKey"] = {
-                        chainId: pool.chainId,
-                        currency0: pool.currency0,
-                        currency1: pool.currency1,
-                        decimalsCurrency0,
-                        decimalsCurrency1,
-                        hooks: pool.hooks,
-                        fetchedAtBlock: pool.fetchedAtBlock,
-                        lpFee: pool.lpFee,
-                        poolId: id,
-                        symbolCurrency0,
-                        symbolCurrency1,
-                        tickSpacing: pool.tickSpacing,
-                    };
-                    index += 4;
-                }
-            }
-            catch (e) {
-                log.error(`issue when fetching UniswapV4 pools on ${NETWORK_LABELS[chainId]}`, e);
-            }
-            return perChainIdRes;
-        }));
-        chainIdArray.forEach((chainId, i) => {
-            if (!!res[i])
-                pools[chainId] = res[i];
-        });
-        // Update the API database
-        const tableData = Object.values(pools).flatMap(pools => Object.values(pools));
-        for (const chainId of chainIdArray) {
-            if (tableData.filter(p => p.chainId === chainId).length > 0) {
-                try {
-                    await UniswapRepository.createMany(tableData
-                        .filter(point => point.chainId === chainId)
-                        .map(pool => ({
-                        fetchAtBlock: pool.fetchedAtBlock,
-                        caughtFromAddress: UniswapV4Addresses[pool.chainId]?.PoolManager ?? NULL_ADDRESS,
-                        chainId: pool.chainId,
-                        entityData: pool,
-                        id: Bun.hash(`${pool.poolId}-${pool.chainId}`).toString(),
-                        type: LoggedEntityType.UNISWAP_V4,
-                    })));
-                    log.info(`✅ successfully saved vaults to API database ('Logged' table) on ${NETWORK_LABELS[chainId]}`);
-                }
-                catch (e) {
-                    log.error("getUniswapV4Pools/LoggedTableUpdate", e);
-                    throw new Error(`Error while saving UniV4 pools to API database ('Logged' table) on ${NETWORK_LABELS[chainId]}`);
-                }
-            }
-        }
-        log.info(`✅ successfully fetched ${tableData.length} new pool(s) on UniswapV4`);
-        // _ Merge previoulsy stored pools with newly fetched ones
-        // TODO optimize this part
-        if (storedPools.length > 0) {
-            for (const pool of storedPools) {
-                const chainId = pool.chainId;
-                if (!pools[chainId])
-                    pools[chainId] = {};
-                pools[chainId][pool.entityData.poolId] = pool.entityData;
-            }
-        }
-        log.info("👋 exiting getUniswapV4Pools");
-        return pools;
-    }
-    /** @deprecated */
-    static async getUniswapV4PoolsForChain(chainId) {
-        return await UniswapService.getUniswapV4Pools(chainId);
-    }
-}

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

@@ -1,77 +0,0 @@
-import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { RewardService } from "@/modules/v4/reward/reward.service";
-import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
-import { Elysia, t } from "elysia";
-import { CheckTerms, GetManyUserQuery, OptionalChainIdDto, UserDto, UserRewardRouteDto, UserRewardsResourceDto, UserTagsDto, UserUniqueDto, } from "./user.model";
-import { UserService } from "./user.service";
-export const UserController = new Elysia({ prefix: "/users", detail: { tags: ["Users"] } })
-    // ─── Get User's Rewards With Breakdown ──────────────────────────────
-    .get("/:address/rewards", async ({ params, query }) => {
-    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, false, query.chainId.map(Number), !!query.reloadChainId ? query.reloadChainId : null, !!query.test ? query.test : false, !!query.claimableOnly);
-    return RewardService.removeOpportunityFromRewardBreakdown(rewardsByChain);
-}, {
-    params: UserUniqueDto,
-    query: UserRewardRouteDto,
-    beforeHandle: ({ query, params }) => {
-        params.address = throwOnInvalidRequiredAddress(params.address);
-        query.chainId = query.chainId.flatMap(x => x.split(","));
-        for (const chainId of query.chainId) {
-            throwOnUnsupportedChainId(Number(chainId));
-        }
-        if (!!query.reloadChainId)
-            throwOnUnsupportedChainId(query.reloadChainId);
-    },
-    response: t.Array(UserRewardsResourceDto),
-    detail: { description: "Get the rewards associated to a user on a given chain." },
-})
-    // ─── Check if user has signed terms ─────────────────────────────────
-    .get("/:address/terms", async ({ query, params }) => await UserService.checkTerms(params?.address, query?.chainId), {
-    query: CheckTerms,
-    detail: {
-        description: "Check if a user address has signed Merkl's terms.",
-    },
-})
-    .guard({ detail: { hide: true } })
-    // ─── Get Many Users ──────────────────────────────────────────────────
-    .get("/", async ({ query }) => await UserService.findMany(query), { query: GetManyUserQuery })
-    // ─── Get A User By Address ───────────────────────────────────────────
-    .get("/:address", async ({ params }) => await UserService.findUniqueOrThrow(params.address))
-    // ─── Get User's Rewards With Breakdown And Details for our FE ────────
-    .get("/:address/rewards/breakdowns", async ({ params, query }) => {
-    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, true, query?.chainIds?.map(Number), query.reloadChainId ?? null, !!query.test ? query.test : false, !!query.claimableOnly);
-    return RewardService.splitRewardsBreakdownByOpportunity(rewardsByChain);
-}, {
-    params: UserUniqueDto,
-    query: OptionalChainIdDto,
-    beforeHandle: ({ params, query }) => {
-        params.address = throwOnInvalidRequiredAddress(params.address);
-        if (!!query.reloadChainId)
-            throwOnUnsupportedChainId(query.reloadChainId);
-        query.chainIds = query?.chainIds?.flatMap(x => x.split(","));
-        if (!!query.chainIds?.length) {
-            for (const chainId of query.chainIds) {
-                throwOnUnsupportedChainId(Number(chainId));
-            }
-        }
-    },
-})
-    .guard({
-    headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
-})
-    // ─── Create A User ───────────────────────────────────────────────────
-    .post("/", async ({ body }) => await UserService.create(body), {
-    body: UserDto,
-})
-    // ─── Get All Tagged Users ─────────────────────────────────────────────
-    .get("/tags", async () => await UserService.findManyWithTags())
-    // ─── Update User's Tags ──────────────────────────────────────────────
-    .patch("/:address/tags", async ({ params, body }) => UserService.updateTags(params.address, body.tags), {
-    params: UserUniqueDto,
-    body: UserTagsDto,
-})
-    // ─── Sync Creator Tags With Engine Db ────────────────────────────────
-    .post("/sync", async () => {
-    await UserService.syncTags();
-    await UserService.syncOpportunityTags();
-});

package/dist/src/modules/v4/user/user.model.js

@@ -1,66 +0,0 @@
-import { ChainResourceDto } from "@/modules/v4/chain/chain.model";
-import { t } from "elysia";
-// ─── Dtos ────────────────────────────────────────────────────────────────────
-export const UserRewardRouteDto = t.Object({
-    chainId: t.Array(t.String()),
-    reloadChainId: t.Optional(t.Numeric({
-        description: "An optional chainId to bypass the cache and check if there was very recently a claim on this chain",
-    })),
-    test: t.Optional(t.Boolean({ description: "Include test token rewards" })),
-    claimableOnly: t.Optional(t.Boolean({ description: "Include only claimable rewards (to avoid transferring zero amounts)" })),
-}, {
-    description: "A required comma separated list of chain ids.<br>You can get the list of all supported chains by calling [GET /v4/chains](#tag/chains/GET/v4/chains/)",
-});
-export const UserRewardsResourceDto = t.Object({
-    chain: ChainResourceDto,
-    rewards: t.Array(t.Object({
-        root: t.String(),
-        recipient: t.String(),
-        proofs: t.Array(t.String()),
-        token: t.Object({
-            address: t.String(),
-            chainId: t.Number(),
-            symbol: t.String(),
-            decimals: t.Number(),
-        }),
-        breakdowns: t.Array(t.Object({
-            reason: t.String(),
-            amount: t.String(),
-            claimed: t.String(),
-            pending: t.String(),
-            campaignId: t.String(),
-        })),
-        claimed: t.Union([t.BigInt(), t.String()]),
-        amount: t.Union([t.BigInt(), t.String()]),
-        pending: t.Union([t.BigInt(), t.String()]),
-    })),
-});
-export const UserUniqueDto = t.Object({
-    address: t.String(),
-});
-export const OptionalChainIdDto = t.Object({
-    chainIds: t.Optional(t.Array(t.String())),
-    reloadChainId: t.Optional(t.Numeric()),
-    test: t.Optional(t.Boolean({ description: "Include test token rewards" })),
-    claimableOnly: t.Optional(t.Boolean({ description: "Include only claimable rewards (to avoid transferring zero amounts)" })),
-});
-export const UserDto = t.Object({
-    address: t.String(),
-    tags: t.Array(t.String()),
-});
-export const CreatorDto = t.Object({
-    address: t.String(),
-    tags: t.Array(t.String()),
-});
-export const GetManyUserQuery = t.Object({
-    address: t.Optional(t.String()),
-    tags: t.Optional(t.Array(t.String())),
-    page: t.Optional(t.Number()),
-    items: t.Optional(t.Number()),
-});
-export const CheckTerms = t.Object({
-    chainId: t.Numeric(),
-});
-export const UserTagsDto = t.Object({
-    tags: t.Array(t.String()),
-});

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

@@ -1,41 +0,0 @@
-import { apiDbClient } from "@db";
-// ─── Users Repository ────────────────────────────────────────────────────────
-export class UserRepository {
-    static async findUnique(address) {
-        return await apiDbClient.user.findUnique({ where: { address } });
-    }
-    static async findUniqueOrThrow(address) {
-        return await apiDbClient.user.findUniqueOrThrow({ where: { address } });
-    }
-    static async findMany(query) {
-        const { page: _page, items: _items, ...filters } = query;
-        const page = _page ? _page : 0;
-        const items = _items ? _items : 20;
-        return await apiDbClient.user.findMany({
-            take: items,
-            skip: page * items,
-            where: {
-                address: filters.address ? filters.address : undefined,
-                tags: filters.tags ? { hasEvery: filters.tags } : undefined,
-            },
-        });
-    }
-    static async findManyWithTags() {
-        return await apiDbClient.user.findMany({
-            where: {
-                tags: {
-                    isEmpty: false,
-                },
-            },
-        });
-    }
-    static async create(user) {
-        return await apiDbClient.user.create({ data: user });
-    }
-    static async createMany(users) {
-        return await apiDbClient.user.createMany({ data: users, skipDuplicates: true });
-    }
-    static async updateTags(address, tags) {
-        return await apiDbClient.user.update({ where: { address }, data: { tags } });
-    }
-}