@merkl/api 0.21.47 → 1.0.0

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

@@ -1,14 +0,0 @@
-import { t } from "elysia";
-export const getEulerBoostBody = t.Union([
-    t.Object({
-        addresses: t.Array(t.String()),
-    }),
-    t.Array(t.Object({
-        address: t.String(),
-        score: t.String(),
-    })),
-]);
-export const getZksyncBoost = t.Object({
-    protocol: t.String(),
-    target: t.String(),
-});

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

@@ -1,20 +0,0 @@
-import axios from "axios";
-export class BoostService {
-    static async getEulerBoost() {
-        return (await axios.get("https://points.euler.finance/integrations/merkl/usd0multipliers")).data.map(({ address, score }) => ({ address, boost: score }));
-    }
-    static async getOpenBlockBoost(query, body) {
-        const protocol = query.protocol;
-        const target = query.target;
-        const url = `https://www.data-openblocklabs.com/zksync/boosts/${protocol}/${target}`;
-        const response = await axios.post(url, body, {
-            headers: {
-                "Content-Type": "application/json",
-            },
-        });
-        if (response.data.length === 0) {
-            throw new Error("No data found");
-        }
-        return response.data.map(({ address, boost }) => ({ address, boost: boost.toString() }));
-    }
-}

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

@@ -1,85 +0,0 @@
-export const mimeTypes = [
-    "audio/aac",
-    "application/x-abiword",
-    "image/apng",
-    "application/x-freearc",
-    "image/avif",
-    "video/x-msvideo",
-    "application/vnd.amazon.ebook",
-    "application/octet-stream",
-    "image/bmp",
-    "application/x-bzip",
-    "application/x-bzip2",
-    "application/x-cdf",
-    "application/x-csh",
-    "text/css",
-    "text/csv",
-    "application/msword",
-    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    "application/vnd.ms-fontobject",
-    "application/epub+zip",
-    "application/gzip",
-    "application/x-gzip",
-    "image/gif",
-    "text/html",
-    "image/vnd.microsoft.icon",
-    "text/calendar",
-    "application/java-archive",
-    "image/jpeg",
-    "text/javascript",
-    "application/json",
-    "application/ld+json",
-    "audio/midi",
-    "audio/x-midi",
-    "text/javascript",
-    "audio/mpeg",
-    "video/mp4",
-    "video/mpeg",
-    "application/vnd.apple.installer+xml",
-    "application/vnd.oasis.opendocument.presentation",
-    "application/vnd.oasis.opendocument.spreadsheet",
-    "application/vnd.oasis.opendocument.text",
-    "audio/ogg",
-    "video/ogg",
-    "application/ogg",
-    "audio/ogg",
-    "font/otf",
-    "image/png",
-    "application/pdf",
-    "application/x-httpd-php",
-    "application/vnd.ms-powerpoint",
-    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    "application/vnd.rar",
-    "application/rtf",
-    "application/x-sh",
-    "image/svg+xml",
-    "application/x-tar",
-    "image/tiff",
-    "video/mp2t",
-    "font/ttf",
-    "text/plain",
-    "application/vnd.visio",
-    "audio/wav",
-    "audio/webm",
-    "video/webm",
-    "image/webp",
-    "font/woff",
-    "font/woff2",
-    "application/xhtml+xml",
-    "application/vnd.ms-excel",
-    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    "application/xml",
-    "text/xml",
-    "application/atom+xml",
-    "application/xml",
-    "application/vnd.mozilla.xul+xml",
-    "application/zip",
-    "application/x-zip-compressed",
-    "audio/video",
-    "video/3gpp",
-    "audio/3gpp",
-    "audio/video",
-    "video/3gpp2",
-    "audio/3gpp2",
-    "application/x-7z-compressed",
-];

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

@@ -1,178 +0,0 @@
-import { Storage } from "@google-cloud/storage";
-import { S3Client, gzipSync } from "bun";
-// ─── BucketService Class ─────────────────────────────────────────────────────
-export class BucketService {
-    // ─── Private Properties ──────────────────────────────────────────────
-    #s3Client;
-    #gcsBucket;
-    #encoder;
-    #decoder;
-    #bucketName;
-    // ─── Default Options ─────────────────────────────────────────────────────────
-    defaultUploadOptions = {
-        type: "text/plain",
-        compression: true,
-        overwrite: true,
-        isPublic: false,
-        transform: obj => `${JSON.stringify(obj)}`,
-        separator: "\n",
-    };
-    // ─── Constructor ─────────────────────────────────────────────────────
-    constructor(bucket, projectId) {
-        this.#s3Client = new S3Client({
-            accessKeyId: process.env.GCS_ACCESS_ID,
-            secretAccessKey: process.env.GCS_SECRET,
-            endpoint: process.env.GCS_ENDPOINT,
-            bucket,
-        });
-        this.#gcsBucket = new Storage({ projectId }).bucket(bucket);
-        this.#encoder = new TextEncoder();
-        this.#decoder = new TextDecoder();
-        this.#bucketName = bucket;
-    }
-    getBucketName() {
-        return this.#bucketName;
-    }
-    // ─── Process And Upload Chunks Of Data ───────────────────────────────
-    async pushArray(filename, arr, options) {
-        // const start = performance.now();
-        // ─── Initialization ──────────────────────────────────────────
-        options = { ...this.defaultUploadOptions, ...options };
-        const file = this.#s3Client.file(filename);
-        const writer = file.writer({
-            retry: 2,
-            queueSize: 10,
-            partSize: 5 * 1024 * 1024,
-            type: options.type,
-        });
-        // ─── Objects Array To Uint8Array ─────────────────────────────
-        const sink = new Bun.ArrayBufferSink();
-        sink.start({
-            asUint8Array: true,
-        });
-        for (let i = 0; i < arr.length; i++)
-            sink.write(this.#encoder.encode(`${options.transform(arr[i])}${options.separator}`));
-        let data = sink.end();
-        if (options.compression)
-            data = gzipSync(data);
-        // ─── ReadableStream Initialization From Blob ─────────────────
-        const blob = new Blob([data]);
-        const stream = blob.stream();
-        const reader = stream.getReader();
-        // ─── Start Writing Data To Bucket ────────────────────────────
-        if (options.overwrite && (await file.exists()))
-            await file.delete();
-        let bytes = 0;
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                bytes += await writer.write(value);
-            }
-            await writer.end();
-        }
-        finally {
-            reader.releaseLock();
-        }
-        // ─── Setting Proper Metadata ─────────────────────────────────
-        if (options.compression)
-            await this.#gcsBucket.file(filename).setMetadata({ contentEncoding: "gzip" });
-        if (options.isPublic)
-            await this.#gcsBucket.file(filename).makePublic();
-        // ─── Return The Number Of Bytes Written ──────────────────────
-        return bytes;
-    }
-    // ─── Upload Data To Bucket ───────────────────────────────────────────
-    async push(filename, text, options) {
-        // const start = performance.now();
-        // ─── Initialization ──────────────────────────────────────────
-        options = { ...this.defaultUploadOptions, ...options };
-        const file = this.#s3Client.file(filename);
-        const data = options.compression ? gzipSync(this.#encoder.encode(text)) : this.#encoder.encode(text);
-        const writer = file.writer({
-            retry: 2,
-            queueSize: 10,
-            partSize: 5 * 1024 * 1024,
-            type: options.type,
-        });
-        const blob = new Blob([data]);
-        const stream = blob.stream();
-        const reader = stream.getReader();
-        if (options.overwrite && (await file.exists()))
-            await file.delete();
-        // ─── Start Writing Data To Bucket ────────────────────────────
-        let bytes = 0;
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                bytes += await writer.write(value);
-            }
-            await writer.end();
-        }
-        finally {
-            reader.releaseLock();
-        }
-        // ─── Setting Proper Metadata ─────────────────────────────────
-        if (options.compression)
-            await this.#gcsBucket.file(filename).setMetadata({ contentEncoding: "gzip" });
-        if (options.isPublic)
-            await this.#gcsBucket.file(filename).makePublic();
-        // ─── Return The Number Of Bytes Written ──────────────────────
-        return bytes;
-    }
-    async pushRaw(filename, data, options) {
-        options = { ...this.defaultUploadOptions, ...options };
-        const file = this.#s3Client.file(filename);
-        data = options?.compression ? gzipSync(data) : data;
-        const bytes = await file.write(data);
-        if (options.compression)
-            await this.#gcsBucket.file(filename).setMetadata({ contentEncoding: "gzip" });
-        if (options.isPublic)
-            await this.#gcsBucket.file(filename).makePublic();
-        return bytes;
-    }
-    // ─── Download And Process Chunks Of Data ─────────────────────────────
-    async pullArray(filename, callback, separator = "\n") {
-        const file = this.#s3Client.file(filename);
-        if (!(await file.exists))
-            throw new Error("File does not exists.");
-        const stream = file.stream();
-        const data = [];
-        let buffer = "";
-        for await (const chunk of stream) {
-            buffer += this.#decoder.decode(chunk);
-            const lines = buffer.split(separator);
-            buffer = lines.pop() || "";
-            for (const line of lines) {
-                try {
-                    data.push(callback(line));
-                }
-                catch (err) {
-                    if (err instanceof Error && err.message === "JSON Parse error: Unexpected EOF")
-                        break;
-                }
-            }
-        }
-        if (buffer.trim())
-            data.push(callback(buffer));
-        return data;
-    }
-    // ─── Download Data From Bucket ───────────────────────────────────────
-    async pull(filename) {
-        const file = this.#s3Client.file(filename);
-        if (!(await file.exists))
-            throw new Error("File does not exists.");
-        const stream = file.stream();
-        let buffer = "";
-        for await (const chunk of stream)
-            buffer += this.#decoder.decode(chunk);
-        buffer = buffer.trim();
-        return buffer;
-    }
-    async list(input) {
-        return await this.#s3Client.list(input);
-    }
-}

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

@@ -1,14 +0,0 @@
-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

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

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

@@ -1,59 +0,0 @@
-import bigintToString from "@/utils/bigintToString";
-import { CacheRepository } from "./cache.repository";
-export class CacheService {
-    static encoder = new TextEncoder();
-    static decoder = new TextDecoder();
-    static #hashKey(fn, args) {
-        const prototype = [Bun.hash(fn.toString()).toString()];
-        return Bun.hash(JSON.stringify(prototype.concat(args?.map(a => JSON.stringify(a))))).toString();
-    }
-    static #compress(result) {
-        const encoded = CacheService.encoder.encode(JSON.stringify(result));
-        return Buffer.from(Bun.gzipSync(encoded)).toString("base64");
-    }
-    static #uncompress(compressedData) {
-        const encoded = Buffer.from(compressedData, "base64");
-        const uncompressed = Bun.gunzipSync(encoded);
-        const decoded = CacheService.decoder.decode(uncompressed);
-        return JSON.parse(decoded);
-    }
-    static async wrap(ttl, fn, ...args) {
-        if (Bun.env.NODE_ENV === "local")
-            return (await fn(...args));
-        const key = CacheService.#hashKey(fn, args);
-        const cached = await CacheRepository.get(key);
-        if (cached !== null)
-            return CacheService.#uncompress(cached);
-        const result = await fn(...args);
-        const compressed = CacheService.#compress(bigintToString(result));
-        await CacheRepository.set(ttl, key, compressed);
-        return result;
-    }
-    static async keyAndTTL(fn, ...args) {
-        const key = CacheService.#hashKey(fn, args);
-        return [key, await CacheRepository.ttl(key)];
-    }
-    static async set(ttl, fn, ...args) {
-        const key = CacheService.#hashKey(fn, args);
-        const result = await fn(...args);
-        const compressed = CacheService.#compress(bigintToString(result));
-        await CacheRepository.set(ttl, key, compressed);
-        return result;
-    }
-    static async get(fn, args) {
-        const key = CacheService.#hashKey(fn, args);
-        const cached = await CacheRepository.get(key);
-        if (cached === null)
-            return null;
-        return CacheService.#uncompress(cached);
-    }
-    static async sAdd(sName, sValue) {
-        return CacheRepository.sAdd(sName, sValue);
-    }
-    static async sRem(sName, sValue) {
-        return CacheRepository.sRem(sName, sValue);
-    }
-    static async sIsMember(sName, sValue) {
-        return await CacheRepository.sIsMember(sName, sValue);
-    }
-}

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

@@ -1,174 +0,0 @@
-import { HttpError, NotFoundError } from "@/errors";
-import { BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { AuthorizationHeadersDto, EngineGuard } from "@/guards/Engine.guard";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { ChainUniqueDto } from "@/modules/v4/chain/chain.model";
-import { log } from "@/utils/logger";
-import { Campaign } from "@sdk";
-import Elysia, { t } from "elysia";
-import { throwOnUnsupportedChainId } from "src/utils/throw";
-import { TTLPresets } from "../cache/cache.model";
-import { DynamicDataService } from "../dynamicData/dynamicData.service";
-import { OpportunityConvertorService } from "../opportunity/opportunity.converter";
-import { CampaignResourceDto, CreateCampaignDto, GetCampaignQueryDto, RemoveManualOverrideDto, UpdateCampaignCreatorDto, UpdateCampaignDto, UpdateMetaDataCampaignDto, } from "./campaign.model";
-import { CampaignService } from "./campaign.service";
-// ─── Campaigns Controller ────────────────────────────────────────────────────
-export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { tags: ["Campaigns"] } })
-    // ─── Create A Campaign ───────────────────────────────────────────────
-    .group("/engine", {
-    headers: AuthorizationHeadersDto,
-    beforeHandle: EngineGuard,
-    detail: { hide: true },
-}, app => {
-    return app.post("/", async ({ body }) => await CampaignService.create(body), {
-        body: CreateCampaignDto,
-    });
-})
-    // ─── Backoffice Routes ─────────────────────────────────────────────────────
-    .patch("/opportunity", async ({ body }) => await CampaignService.moveToOpportunity(body), {
-    beforeHandle: BackOfficeGuard,
-    headers: AuthorizationHeadersDto,
-    body: UpdateCampaignDto,
-    detail: { hide: true },
-})
-    .patch("/creator", async ({ body }) => await CampaignService.updateCreator(body), {
-    beforeHandle: BackOfficeGuard,
-    headers: AuthorizationHeadersDto,
-    body: UpdateCampaignCreatorDto,
-    detail: { hide: true },
-})
-    .patch("/remove-override", async ({ body }) => await CampaignService.removeManualOverride({
-    distributionChain: body.distributionChain,
-    campaignId: body.campaignId,
-}, body.field), {
-    beforeHandle: BackOfficeGuard,
-    headers: AuthorizationHeadersDto,
-    body: RemoveManualOverrideDto,
-    detail: { hide: true },
-})
-    .patch("/metadata", async ({ body }) => await CampaignService.updateMetaData(body), {
-    beforeHandle: BackOfficeGuard,
-    headers: AuthorizationHeadersDto,
-    body: UpdateMetaDataCampaignDto,
-    detail: { hide: true },
-})
-    .put("/tvls/:opportunityId", async ({ params }) => {
-    const campaigns = (await CampaignService.findMany({
-        opportunityId: params.opportunityId,
-        test: true,
-        withOpportunity: true,
-        items: 10_000,
-    })).map(campaign => OpportunityConvertorService.convertV4CampaignToV3(Campaign[campaign.type], campaign, campaign.Opportunity.identifier));
-    if (!campaigns.length)
-        throw new NotFoundError("Opportunity not found");
-    return await DynamicDataService.update(campaigns[0]?.computeChainId, campaigns[0].campaignType, campaigns);
-}, {
-    beforeHandle: BackOfficeGuard,
-    headers: AuthorizationHeadersDto,
-    detail: { hide: true },
-})
-    // ─── Get Many Campaigns ──────────────────────────────────────────────
-    .get("/", async ({ query }) => {
-    if (query.items === 0)
-        throw new HttpError("Bad Request: Cannot retrieve 0 items", 400);
-    return await CampaignService.findMany(query);
-}, {
-    query: GetCampaignQueryDto,
-    response: t.Array(CampaignResourceDto),
-    detail: {
-        description: `**Retrieve Multiple Campaigns**
-      <p>This endpoint enables you to search for campaigns by providing specific criteria through query parameters.</p>`,
-    },
-})
-    // ─── Get One Campaign ────────────────────────────────────────────────
-    .get("/:id", async ({ params }) => {
-    try {
-        if (!params.id.includes("-"))
-            return CampaignService.format(await CampaignService.findUniqueOrThrow(params.id));
-        const [distributionChain, campaignId] = params.id.split("-");
-        return CampaignService.format(await CampaignService.findUniqueOrThrow({ distributionChain: +distributionChain, campaignId }));
-    }
-    catch (err) {
-        log.error(`Error getting campaign: ${params.id}`, err);
-        throw new NotFoundError("Campaign not found.");
-    }
-}, {
-    params: t.Object({ id: t.String() }),
-    response: CampaignResourceDto,
-    detail: {
-        description: `**Retrieve A Campaign**
-      <p>This endpoint enables you to retrieve a campaign by providing its unique identifier.</p>`,
-    },
-})
-    .get("/:id/metrics", async ({ params }) => {
-    if (!params.id.includes("-"))
-        return await CampaignService.getMetrics(params.id);
-    const [distributionChain, campaignId] = params.id.split("-");
-    return await CampaignService.getMetrics({ distributionChain: +distributionChain, campaignId });
-})
-    .group("/campaigns-to-process", app => {
-    return (app
-        // ─── Get The List Of Campaigns To Process ────
-        .get("/", async ({ query }) => await CampaignService.findCampaignsToProcess(query.chainId), {
-        query: ChainUniqueDto,
-        beforeHandle: ({ query }) => {
-            throwOnUnsupportedChainId(query.chainId);
-        },
-        detail: { hide: true },
-    })
-        // ─── Get Count Of CampaignsToProcess ─────────
-        .get("/count", async ({ query }) => (await CampaignService.findCampaignsToProcess(query.chainId)).length, {
-        query: ChainUniqueDto,
-        beforeHandle: ({ query }) => {
-            throwOnUnsupportedChainId(query.chainId);
-        },
-        detail: { hide: true },
-    })
-        .get("/next", async ({ query }) => await CampaignService.findNextCampaignToProcess(query.chainId), {
-        query: ChainUniqueDto,
-        beforeHandle: ({ query }) => {
-            throwOnUnsupportedChainId(query.chainId);
-        },
-        detail: { hide: true },
-    })
-        // ─── Marks A Campaignid As Processing ────────
-        .post("/engine", async ({ query }) => await CampaignService.pickCampaignToProcess(query.chainId), {
-        query: ChainUniqueDto,
-        beforeHandle: async ({ query, headers }) => {
-            await EngineGuard({ headers });
-            throwOnUnsupportedChainId(query.chainId);
-        },
-        headers: AuthorizationHeadersDto,
-        detail: { hide: true },
-    }));
-})
-    // ─── Get Many Campaigns ──────────────────────────────────────────────
-    .guard({ query: GetCampaignQueryDto })
-    .get("/", async ({ query }) => {
-    if (query.items === 0)
-        throw new HttpError("Bad Request: Cannot retrieve 0 items", 400);
-    return await CampaignService.findMany(query);
-}, {
-    response: t.Array(CampaignResourceDto),
-    detail: {
-        description: `**Retrieve Multiple Campaigns**
-      <p>This endpoint enables you to search for campaigns by providing specific criteria through query parameters.</p>`,
-    },
-})
-    // ─── Get Total Campaigns Count ───────────────────────────────────────
-    .get("/count", async ({ query }) => await CampaignService.countMany(query), {
-    response: t.Number(),
-    detail: {
-        description: `**Count Campaigns**
-    <p>This endpoint enables you to count campaigns corresponding to filters specified in the query params.</p>`,
-    },
-})
-    .guard({
-    response: t.Record(t.String(), t.Number()),
-    headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
-    detail: { hide: true },
-})
-    .get("count/by-chains", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByChains, query))
-    .get("/count/by-types", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByTypes, query))
-    .get("/count/by-protocols", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByProtocols, query));