@merkl/api 0.10.129 → 0.10.130

package/dist/src/libs/tokens/balances.js

@@ -0,0 +1,126 @@
+import { Erc20__factory } from "@sdk";
+import { log } from "../../utils/logger";
+import { getTokensListWithCache } from "../getTokensList";
+export async function getOnlyUserBalance(chainId, userAddress, tokenAddresses) {
+    const calls = [];
+    const ERC20_Interface = Erc20__factory.createInterface();
+    for (const tokenAddress of tokenAddresses) {
+        calls.push({
+            allowFailure: true,
+            callData: ERC20_Interface.encodeFunctionData("balanceOf", [userAddress]),
+            target: tokenAddress,
+        });
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const res = {};
+                for (let j = 0; j < tokenAddresses.length; j++) {
+                    const tokenAddress = tokenAddresses[j];
+                    let balance = "0";
+                    try {
+                        balance = ERC20_Interface.decodeFunctionResult("balanceOf", result[j])[0]?.toString();
+                    }
+                    catch (_error) {
+                        log.local(`❌ Failed to call balanceOf for ${tokenAddress} on ${chainId}`);
+                    }
+                    res[tokenAddress] = {
+                        balance: balance,
+                        decimals: 0,
+                        symbol: "",
+                    };
+                }
+                return res;
+            },
+        },
+    };
+}
+export async function getUserBalances(user, chainId, tokenAddresses) {
+    const tokens = (await getTokensListWithCache())?.[chainId];
+    if (!tokens) {
+        log.debug("❌ Chain not supported");
+        return {
+            cached: false,
+            call: {
+                callData: [],
+                handler: () => { },
+                reducer: async () => {
+                    return {};
+                },
+            },
+        };
+    }
+    const tokenListAddresses = Object.keys(tokens).filter(t => t !== "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE");
+    const ERC20_Interface = Erc20__factory.createInterface();
+    const calls = [];
+    for (const tokenAddress of tokenListAddresses) {
+        calls.push({
+            allowFailure: true,
+            callData: ERC20_Interface.encodeFunctionData("balanceOf", [user]),
+            target: tokenAddress,
+        });
+    }
+    /** Only if the route is called from mainnet */
+    if (!!tokenAddresses && tokenAddresses?.length > 0) {
+        for (const externalTokenAddress of tokenAddresses) {
+            calls.push({
+                allowFailure: true,
+                callData: ERC20_Interface.encodeFunctionData("balanceOf", [user]),
+                target: externalTokenAddress,
+            }, {
+                allowFailure: true,
+                callData: ERC20_Interface.encodeFunctionData("decimals"),
+                target: externalTokenAddress,
+            }, {
+                allowFailure: true,
+                callData: ERC20_Interface.encodeFunctionData("symbol"),
+                target: externalTokenAddress,
+            });
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const res = {};
+                for (let j = 0; j < tokenListAddresses.length; j++) {
+                    const tokenAddress = tokenListAddresses[j];
+                    let balance = "0";
+                    try {
+                        balance = ERC20_Interface.decodeFunctionResult("balanceOf", result[j])[0]?.toString();
+                    }
+                    catch (_error) {
+                        log.local(`❌ Failed to call balanceOf for ${tokenAddress} on ${chainId}`);
+                    }
+                    res[tokenAddress] = {
+                        balance: balance,
+                        decimals: tokens[tokenAddress]?.decimals,
+                        symbol: tokens[tokenAddress]?.symbol,
+                    };
+                }
+                if (!!tokenAddresses && tokenAddresses?.length > 0) {
+                    for (let j = 0; j < tokenAddresses.length; j++) {
+                        const externalTokenAddress = tokenAddresses[j];
+                        try {
+                            res[externalTokenAddress] = {
+                                balance: ERC20_Interface.decodeFunctionResult("balanceOf", result[Object.keys(tokens)?.length + 3 * j])[0]?.toString(),
+                                decimals: ERC20_Interface.decodeFunctionResult("decimals", result[Object.keys(tokens)?.length + 3 * j + 1])[0]?.toString(),
+                                symbol: ERC20_Interface.decodeFunctionResult("symbol", result[Object.keys(tokens)?.length + 3 * j + 2])[0]?.toString(),
+                            };
+                        }
+                        catch (error) {
+                            // If it fails we don't return the token info
+                            log.local(`❌ Failed to call balanceOf, decimals or symbol for ${externalTokenAddress} on ${chainId}`);
+                        }
+                    }
+                }
+                return res;
+            },
+        },
+    };
+}

package/dist/src/libs/tokens/tokenInfo.js

@@ -0,0 +1,22 @@
+import { Erc20__factory } from "@sdk";
+export async function getTokenInfo(address) {
+    const ERC20_Interface = Erc20__factory.createInterface();
+    const read = ["symbol", "name", "decimals"];
+    const calls = read.map(fn => ({
+        allowFailure: false,
+        callData: ERC20_Interface.encodeFunctionData(fn),
+        target: address,
+    }));
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                return read.reduce((res, fn, index) => Object.assign(res, {
+                    [fn]: ERC20_Interface.decodeFunctionResult(fn, result[index])[0],
+                }), {});
+            },
+        },
+    };
+}

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

@@ -0,0 +1,66 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
+import { AccountingService, ChainDto, DateDto, GetTransactionsQueryModel, RevenuesDto, TokensDateDto, TokensDto, } from "./";
+import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../../utils/throw";
+import Elysia from "elysia";
+export const AccountingController = new Elysia({ prefix: "/accounting", detail: { tags: ["Accounting"] } })
+    .get("/", async ({ query }) => await AccountingService.getMany(query), {
+    query: GetTransactionsQueryModel,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: async ({ headers }) => {
+        await BackOfficeGuard({ headers });
+    },
+})
+    .group("/revenues", app => {
+    return app
+        .get("", async () => await AccountingService.getRevenue(), {
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ headers }) => {
+            await BackOfficeGuard({ headers });
+        },
+    })
+        .get("/per-month/:year/:month", async ({ params }) => await AccountingService.getMonthlyRevenue(params.year, params.month), {
+        params: DateDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ headers }) => {
+            await BackOfficeGuard({ headers });
+        },
+    })
+        .get("/chains/:chainId", async ({ params }) => await AccountingService.getRevenueByChain(params.chainId), {
+        params: ChainDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ params, headers }) => {
+            await BackOfficeGuard({ headers });
+            throwOnUnsupportedChainId(params.chainId);
+        },
+    })
+        .get("/chains/:chainId/per-month/:year/:month", async ({ params }) => await AccountingService.getMonthlyRevenueByChain(params.chainId, params.year, params.month), {
+        params: RevenuesDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ params, headers }) => {
+            await BackOfficeGuard({ headers });
+            throwOnUnsupportedChainId(params.chainId);
+        },
+    });
+})
+    // ─── Tokens Group ────────────────────────────────────────────────────
+    .group("/tokens", app => {
+    return app
+        .get("/:chainId/:tokenAddress", async ({ params }) => await AccountingService.getTokenTransaction(params.tokenAddress, params.chainId), {
+        params: TokensDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ params, headers }) => {
+            await BackOfficeGuard({ headers });
+            params.tokenAddress = throwOnInvalidRequiredAddress(params.tokenAddress);
+            throwOnUnsupportedChainId(params.chainId);
+        },
+    })
+        .get("/:chainId/:tokenAddress/per-month/:year/:month", async ({ params }) => await AccountingService.getTokenMonthlyTransaction(params.tokenAddress, params.chainId, params.year, params.month), {
+        params: TokensDateDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ params, headers }) => {
+            await BackOfficeGuard({ headers });
+            params.tokenAddress = throwOnInvalidRequiredAddress(params.tokenAddress);
+            throwOnUnsupportedChainId(params.chainId);
+        },
+    });
+});

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

@@ -0,0 +1,32 @@
+import { t } from "elysia";
+export const TokensDto = t.Object({
+    chainId: t.Numeric(),
+    tokenAddress: t.String(),
+});
+export const GetTransactionsQueryModel = t.Object({
+    page: t.Optional(t.Numeric()),
+    items: t.Optional(t.Numeric()),
+});
+export const TokensDateDto = t.Object({
+    chainId: t.Numeric(),
+    tokenAddress: t.String(),
+    month: t.Numeric(),
+    year: t.Numeric(),
+});
+export const DateDto = t.Object({
+    month: t.Numeric(),
+    year: t.Numeric(),
+});
+export const ChainDto = t.Object({
+    chainId: t.Numeric(),
+});
+export const RevenuesDto = t.Object({
+    chainId: t.Numeric(),
+    month: t.Numeric(),
+    year: t.Numeric(),
+});
+export const GetRevenuesDto = t.Object({
+    chainId: t.Numeric(),
+    month: t.Numeric(),
+    year: t.Numeric(),
+});

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

@@ -0,0 +1,100 @@
+import { apiDbClient } from "../../../utils/prisma";
+export class AccountingRepository {
+    static async findMany(query) {
+        const { page: _page, items: _items } = query;
+        const page = _page ? _page : 0;
+        const items = _items ? _items : 20;
+        return await apiDbClient.dump.findMany({
+            take: items,
+            skip: page * items,
+        });
+    }
+    static async getByTokenForDumper(fromTokenId) {
+        return await apiDbClient.dump.findMany({
+            where: {
+                fromTokenId,
+                NOT: {
+                    recipient: {
+                        equals: apiDbClient.dump.fields.multisig,
+                    },
+                },
+            },
+        });
+    }
+    static async getForMonthForRecipient(recipient, toTokenId, month, year) {
+        const startDate = new Date(year, month, 0);
+        const endDate = new Date(year, month + 1, 0);
+        return await apiDbClient.dump.findMany({
+            where: {
+                toTokenId,
+                recipient,
+                datetime: {
+                    gte: startDate,
+                    lt: endDate,
+                },
+            },
+        });
+    }
+    static async getForMultisigBetweenDates(startDate, endDate) {
+        return await apiDbClient.dump.findMany({
+            where: {
+                recipient: {
+                    equals: apiDbClient.dump.fields.multisig,
+                },
+                datetime: {
+                    gte: startDate,
+                    lt: endDate,
+                },
+            },
+        });
+    }
+    static async getForMultisig() {
+        return await apiDbClient.dump.findMany({
+            where: {
+                recipient: {
+                    equals: apiDbClient.dump.fields.multisig,
+                },
+            },
+        });
+    }
+    static async getForMultisigByChain(chainId) {
+        return await apiDbClient.dump.findMany({
+            where: {
+                chainId,
+                recipient: {
+                    equals: apiDbClient.dump.fields.multisig,
+                },
+            },
+        });
+    }
+    static async getForMultisigByChainBetweenDates(chainId, startDate, endDate) {
+        return await apiDbClient.dump.findMany({
+            where: {
+                chainId,
+                datetime: {
+                    gte: startDate,
+                    lte: endDate,
+                },
+                recipient: {
+                    equals: apiDbClient.dump.fields.multisig,
+                },
+            },
+        });
+    }
+    static async getForDumperBetweenDates(fromTokenId, startDate, endDate) {
+        return await apiDbClient.dump.findMany({
+            where: {
+                fromTokenId,
+                datetime: {
+                    gte: startDate,
+                    lte: endDate,
+                },
+                NOT: {
+                    recipient: {
+                        equals: apiDbClient.dump.fields.multisig,
+                    },
+                },
+            },
+        });
+    }
+}

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

@@ -0,0 +1,78 @@
+import { AccountingRepository } from "./accounting.repository";
+import { TokenService } from "../token";
+export class AccountingService {
+    static hashId(chainId, fromTokenId, toTokenId, timestamp) {
+        return Bun.hash(`${chainId}${fromTokenId}${toTokenId}${timestamp}`).toString();
+    }
+    static getTokenId(chainId, address) {
+        return TokenService.hashId({ chainId, address });
+    }
+    static async getMany(query) {
+        return await AccountingRepository.findMany(query);
+    }
+    static async getRevenue() {
+        const data = await AccountingRepository.getForMultisig();
+        let totalAmount = 0;
+        for (const tx of data) {
+            totalAmount += Number(tx.amountIn);
+        }
+        return { totalAmount };
+    }
+    static async getRevenueByChain(chainId) {
+        const data = await AccountingRepository.getForMultisigByChain(chainId);
+        let totalAmount = 0;
+        for (const tx of data) {
+            totalAmount += Number(tx.amountIn);
+        }
+        return { totalAmount };
+    }
+    static async getMonthlyRevenue(year, month) {
+        const startDate = new Date(year, month - 1, 1);
+        const endDate = new Date(year, month, 0, 23, 59, 59);
+        const monthlyData = await AccountingRepository.getForMultisigBetweenDates(startDate, endDate);
+        let totalAmount = 0;
+        for (const tx of monthlyData) {
+            totalAmount += Number(tx.amountIn);
+        }
+        return { totalAmount, from: startDate.toDateString(), to: endDate.toDateString() };
+    }
+    static async getMonthlyRevenueByChain(chainId, year, month) {
+        const startDate = new Date(year, month - 1, 1);
+        const endDate = new Date(year, month, 0, 23, 59, 59);
+        const monthlyData = await AccountingRepository.getForMultisigByChainBetweenDates(chainId, startDate, endDate);
+        let totalAmount = 0;
+        for (const tx of monthlyData) {
+            totalAmount += Number(tx.amountIn);
+        }
+        return { totalAmount, from: startDate.toDateString(), to: endDate.toDateString() };
+    }
+    static async getTokenTransaction(tokenAddress, chainId) {
+        const tokenId = AccountingService.getTokenId(chainId, tokenAddress);
+        const data = await AccountingRepository.getByTokenForDumper(tokenId);
+        let totalAmount = 0;
+        let totalAmountUSD = 0;
+        for (const tx of data) {
+            totalAmount += Number(tx.amountIn);
+            totalAmountUSD += Number(tx.amountOut);
+        }
+        return { totalAmount: totalAmount, totalAmountUSD: totalAmountUSD };
+    }
+    static async getTokenMonthlyTransaction(tokenAddress, chainId, year, month) {
+        const startDate = new Date(year, month - 1, 1);
+        const endDate = new Date(year, month, 0, 23, 59, 59);
+        const tokenId = AccountingService.getTokenId(chainId, tokenAddress);
+        const monthlyData = await AccountingRepository.getForDumperBetweenDates(tokenId, startDate, endDate);
+        let totalAmount = 0;
+        let totalAmountUSD = 0;
+        for (const tx of monthlyData) {
+            totalAmount += Number(tx.amountIn);
+            totalAmountUSD += Number(tx.amountOut);
+        }
+        return {
+            totalAmount: totalAmount,
+            totalAmountUSD: totalAmountUSD,
+            from: startDate.toDateString(),
+            to: endDate.toDateString(),
+        };
+    }
+}

package/dist/src/modules/v4/accounting/index.js

@@ -0,0 +1,3 @@
+export * from "./accounting.model";
+export * from "./accounting.controller";
+export * from "./accounting.service";

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,40 @@
+import { AprType } from "../../../../database/api/.generated";
+import { Campaign as CampaignTypeV3 } from "@sdk";
+import moment from "moment";
+export class AprService {
+    static hashId(opportunityId, timestamp) {
+        return Bun.hash(`${opportunityId}${timestamp}`).toString();
+    }
+    static extractFromDynamicData(type, campaignsDynamicData, timestamp = BigInt(moment().unix())) {
+        const typesWithoutApr = [CampaignTypeV3.INVALID, CampaignTypeV3.JSON_AIRDROP, CampaignTypeV3.ERC20_SNAPSHOT];
+        if (typesWithoutApr.includes(type))
+            return { timestamp, cumulated: 0, breakdowns: [] };
+        let cumulated = campaignsDynamicData.reduce((sum, campaign) => sum + (Number.isNaN(Number(campaign.apr)) ? 0 : Number(campaign.apr)), 0) ?? 0;
+        cumulated = Number.isNaN(Number(cumulated)) || !Number.isFinite(cumulated) ? 0 : cumulated;
+        const breakdowns = campaignsDynamicData.map(campaign => {
+            return {
+                identifier: campaign.campaignId,
+                type: AprType.CAMPAIGN,
+                value: Number.isNaN(campaign.apr) || !Number.isFinite(campaign.apr) ? 0 : Number(campaign.apr),
+            };
+        });
+        if (type === CampaignTypeV3.CLAMM) {
+            for (const campaign of campaignsDynamicData) {
+                if (campaign.forwarders) {
+                    for (const forwarder of campaign.forwarders) {
+                        breakdowns.push({
+                            identifier: forwarder.label,
+                            type: AprType.PROTOCOL,
+                            value: Number.isNaN(forwarder.almAPR) || !Number.isFinite(forwarder.almAPR) ? 0 : Number(forwarder.almAPR),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            timestamp,
+            cumulated,
+            breakdowns,
+        };
+    }
+}

package/dist/src/modules/v4/apr/index.js

@@ -0,0 +1,2 @@
+export * from "./apr.model";
+export * from "./apr.service";

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

@@ -0,0 +1,45 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
+import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../../utils/throw";
+import { NULL_ADDRESS } from "@sdk";
+import Elysia from "elysia";
+import { AddBlacklistDto, CheckBlacklistDto, RemoveBlacklistDto } from "./blacklist.model";
+import { BlacklistService } from "./blacklist.service";
+export const BlacklistController = new Elysia({ prefix: "/blacklists", detail: { tags: ["Blacklists"] } })
+    // ─── Get Entire Blacklist ────────────────────────────────────────────
+    .get("/", async () => {
+    return await BlacklistService.findMany();
+})
+    // ─── Get Blacklist From Cache ────────────────────────────────────────
+    .get("/all", async () => {
+    return await BlacklistService.getMany();
+})
+    // ─── Check If An Address Is Blacklisted ──────────────────────────────
+    .get("/check/:address", async ({ params }) => await BlacklistService.isBlacklisted(params.address), {
+    params: CheckBlacklistDto,
+    beforeHandle: ({ params }) => {
+        params.address = throwOnInvalidRequiredAddress(params.address);
+    },
+})
+    // ─── Add User To Blacklist ───────────────────────────────────────────
+    .post("/", async ({ body }) => await BlacklistService.add({
+    ...body,
+    id: BlacklistService.hashId(body.chainId, body.userAddress, body.poolAddress),
+}), {
+    body: AddBlacklistDto,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: async ({ body, headers }) => {
+        await BackOfficeGuard({ headers });
+        body.userAddress = throwOnInvalidRequiredAddress(body.userAddress);
+        body.poolAddress = throwOnInvalidRequiredAddress(body.poolAddress ?? NULL_ADDRESS);
+        throwOnUnsupportedChainId(body.chainId);
+    },
+})
+    // ─── Remove A User From Blacklist ────────────────────────────────────
+    .delete("/user/:address", async ({ params }) => await BlacklistService.remove(params.address), {
+    params: RemoveBlacklistDto,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: async ({ headers, params }) => {
+        await BackOfficeGuard({ headers });
+        params.address = throwOnInvalidRequiredAddress(params.address);
+    },
+});

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

@@ -0,0 +1,13 @@
+import { t } from "elysia";
+export const AddBlacklistDto = t.Object({
+    chainId: t.Numeric(),
+    userAddress: t.String(),
+    poolAddress: t.String(),
+    reason: t.Optional(t.String()),
+});
+export const CheckBlacklistDto = t.Object({
+    address: t.String(),
+});
+export const RemoveBlacklistDto = t.Object({
+    address: t.String(),
+});

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

@@ -0,0 +1,56 @@
+import { apiDbClient } from "../../../utils/prisma";
+import { NULL_ADDRESS } from "@sdk";
+import { utils } from "ethers";
+export class BlacklistRepository {
+    static async findMany() {
+        return await apiDbClient.blacklist.findMany();
+    }
+    static async getMany() {
+        return (await BlacklistRepository.findMany()).reduce((prev, { userAddress, arrestTimestamp }) => {
+            if (!!arrestTimestamp) {
+                prev[utils.getAddress(userAddress)] = true;
+            }
+            return prev;
+        }, {});
+    }
+    static async check(address) {
+        return ((await apiDbClient.blacklist.findMany({
+            where: {
+                userAddress: address,
+            },
+        })).findIndex(x => !!x.arrestTimestamp) !== -1);
+    }
+    static async remove(address) {
+        const points = await apiDbClient.blacklist.findMany({ where: { userAddress: address } });
+        if (points?.filter(x => !!x.arrestTimestamp).length === 0) {
+            throw new Error(`Address ${address} is not blacklisted`);
+        }
+        for (const point of points) {
+            await apiDbClient.blacklist.update({
+                data: {
+                    arrestTimestamp: 0,
+                },
+                where: {
+                    chainId_userAddress_poolAddress: {
+                        chainId: point.chainId,
+                        userAddress: point.userAddress,
+                        poolAddress: point.poolAddress,
+                    },
+                },
+            });
+        }
+        return true;
+    }
+    static async add(x) {
+        return await apiDbClient.blacklist.create({
+            data: {
+                id: x.id,
+                User: { connectOrCreate: { where: { address: x.userAddress }, create: { address: x.userAddress } } },
+                Chain: { connect: { id: x.chainId } },
+                poolAddress: x.poolAddress ?? NULL_ADDRESS,
+                arrestTimestamp: Date.now(),
+                arrestDetails: !x.reason ? {} : { reason: x.reason },
+            },
+        });
+    }
+}

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

@@ -0,0 +1,24 @@
+import { utils } from "ethers";
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
+import { BlacklistRepository } from "./blacklist.repository";
+export class BlacklistService {
+    static hashId(chainId, userAddress, poolAddress) {
+        return Bun.hash(`${chainId}${userAddress}${poolAddress}`).toString();
+    }
+    static async getMany() {
+        return await CacheService.wrap(TTLPresets.MIN_5, BlacklistRepository.getMany);
+    }
+    static async findMany() {
+        return await BlacklistRepository.findMany();
+    }
+    static async isBlacklisted(address) {
+        return BlacklistRepository.check(utils.getAddress(address));
+    }
+    static async remove(address) {
+        return await BlacklistRepository.remove(address);
+    }
+    static async add(x) {
+        return await BlacklistRepository.add(x);
+    }
+}

package/dist/src/modules/v4/blacklist/index.js

@@ -0,0 +1,3 @@
+export * from "./blacklist.model";
+export * from "./blacklist.controller";
+export * from "./blacklist.service";

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

@@ -0,0 +1,14 @@
+export var TTLPresets;
+(function (TTLPresets) {
+    TTLPresets[TTLPresets["MIN_1"] = 60] = "MIN_1";
+    TTLPresets[TTLPresets["MIN_5"] = 300] = "MIN_5";
+    TTLPresets[TTLPresets["MIN_10"] = 600] = "MIN_10";
+    TTLPresets[TTLPresets["MIN_30"] = 1800] = "MIN_30";
+    TTLPresets[TTLPresets["HOUR_1"] = 3600] = "HOUR_1";
+    TTLPresets[TTLPresets["HOUR_4"] = 14400] = "HOUR_4";
+    TTLPresets[TTLPresets["HOUR_8"] = 28800] = "HOUR_8";
+    TTLPresets[TTLPresets["HOUR_12"] = 43200] = "HOUR_12";
+    TTLPresets[TTLPresets["DAY_1"] = 86400] = "DAY_1";
+    TTLPresets[TTLPresets["WEEK_1"] = 604800] = "WEEK_1";
+    TTLPresets[TTLPresets["MONTH_1"] = 2592000] = "MONTH_1";
+})(TTLPresets || (TTLPresets = {}));

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

@@ -0,0 +1,10 @@
+import { REDIS_READ_TIMEOUT, REDIS_RETRIES, redisClient } from "../../../cache/redis";
+import { withRetry, withTimeout } from "@sdk";
+export class CacheRepository {
+    static async set(ttl, key, value) {
+        await redisClient.set(key, value, { EX: ttl });
+    }
+    static async get(key) {
+        return await withRetry(withTimeout, [redisClient.get(key), REDIS_READ_TIMEOUT], REDIS_RETRIES);
+    }
+}