@socket.tech/dl-common 1.0.7 → 1.0.9

package/dist/src/relayers/sealRelayer.js

@@ -1,276 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.markSealRecentError = exports.isRecentSealError = exports.checkAndSeal = exports.relaySealBatch = exports.relaySeal = void 0;
-const utils_1 = require("../utils");
-const utils_2 = require("../../dl-common/utils");
-const constants_1 = require("../constants");
-const models_1 = require("../../dl-common/models");
-const sequelize_1 = require("sequelize");
-const db_1 = require("../db");
-const prometheus_config_1 = require("../constants/prometheus.config");
-const services_1 = require("../../dl-common/services");
-const common_1 = require("./common");
-const recentSealErrorRedisKey = "recentSealError";
-const relaySeal = async (chainSlug) => {
-    if (!constants_1.sealRelayMode) {
-        (0, utils_1.logInfo)({ info: "SEAL_MODE_DISABLED", messageIds: [], packetIds: [] });
-        return;
-    }
-    const chainSlugs = chainSlug != null ? [chainSlug] : constants_1.supportedChainSlugs;
-    const packetsPerChain = await getPendingSealPackets(chainSlugs);
-    await Promise.all(chainSlugs.map(async (chainSlug) => {
-        var _a;
-        try {
-            if (!constants_1.supportedChainSlugs.includes(chainSlug))
-                return;
-            if (!((_a = packetsPerChain[chainSlug]) === null || _a === void 0 ? void 0 : _a.length))
-                return;
-            (0, utils_1.logInfo)({
-                info: "SEAL_RELAYING",
-                chainSlug,
-                packetIds: packetsPerChain[chainSlug].map((p) => p.packetId),
-                messageIds: [],
-            });
-            const socketAddress = (0, common_1.getSocketAddress)(chainSlug);
-            const socketBatcher = await (0, common_1.getSocketBatcher)(chainSlug, { type: "sealBatch" }, true);
-            const recentSealError = await (0, exports.isRecentSealError)();
-            const packets = packetsPerChain[chainSlug];
-            // If we faced a recent seal error, send seal txns in separate batches based on dstChainSlug, so 1 dst chain doesnt lead to stuck sealing for all chains
-            if (recentSealError || constants_1.separateSealRelayMode) {
-                (0, utils_1.logInfo)({
-                    info: "RELAYING_SEAL_FOR_INDIVIDUAL_SIBLINGS",
-                    reason: recentSealError
-                        ? "recentSealError"
-                        : "separateSealRelayMode",
-                    messageIds: [],
-                    packetIds: [],
-                });
-                const dstChainPackets = {};
-                packets.map((packet) => {
-                    if (!dstChainPackets[packet.dstChainSlug])
-                        dstChainPackets[packet.dstChainSlug] = [];
-                    dstChainPackets[packet.dstChainSlug].push(packet);
-                });
-                for (const dstChainSlug in dstChainPackets) {
-                    await (0, exports.relaySealBatch)(chainSlug, socketAddress, socketBatcher, dstChainPackets[dstChainSlug]);
-                    // this is temp solution to avoid nonce issue at relayer. should be solved at relayer.
-                    (0, utils_1.logInfo)({
-                        info: "SEAL_RELAYED",
-                        chainSlug,
-                        packetIds: dstChainPackets[dstChainSlug].map((p) => p.packetId),
-                        messageIds: [],
-                    });
-                    await (0, utils_2.sleep)(1000);
-                }
-            }
-            else {
-                (0, utils_1.logInfo)({
-                    info: "RELAYING_SEAL_FOR_ALL_SIBLINGS",
-                    messageIds: [],
-                    packetIds: [],
-                });
-                await (0, exports.relaySealBatch)(chainSlug, socketAddress, socketBatcher, packets);
-                (0, utils_1.logInfo)({
-                    info: "SEAL_RELAYED",
-                    chainSlug,
-                    packetIds: packets.map((p) => p.packetId),
-                    messageIds: [],
-                });
-            }
-        }
-        catch (error) {
-            console.log(chainSlug, " error in relaySeal: ", error);
-        }
-    }));
-};
-exports.relaySeal = relaySeal;
-const relaySealBatch = async (chainSlug, socketAddress, socketBatcher, packets) => {
-    if (packets && packets.length > 0) {
-        const packetsAsChunks = [...(0, utils_2.chunks)(packets, constants_1.sealBatchRelayLimit)];
-        for (const chunk of packetsAsChunks) {
-            await sendSealBatch(chainSlug, chunk, socketAddress, socketBatcher);
-        }
-    }
-};
-exports.relaySealBatch = relaySealBatch;
-const getPendingSealPackets = async (srcChainSlugs) => {
-    const packets = await models_1.Packet.findAll({
-        limit: constants_1.sealBatchQueryLimit,
-        where: {
-            srcChainSlug: {
-                [sequelize_1.Op.in]: srcChainSlugs,
-            },
-            dstChainSlug: {
-                [sequelize_1.Op.in]: constants_1.supportedChainSlugs,
-            },
-            isFilled: true,
-            isSealed: false,
-            sealRelayStatus: {
-                [sequelize_1.Op.notIn]: [
-                    models_1.SealRelayStatus.SEALED,
-                    models_1.SealRelayStatus.SEALING,
-                    models_1.SealRelayStatus.SEAL_FAILED,
-                ],
-            },
-        },
-        attributes: [
-            "id",
-            "srcChainSlug",
-            "dstChainSlug",
-            "packetId",
-            "root",
-            "capacitorPacketCount",
-            "srcCapacitor",
-            "outboundTime",
-            "sealSignature",
-        ],
-        order: [
-            [
-                db_1.attesterDBInst.cast(db_1.attesterDBInst.col("capacitorPacketCount"), "BIGINT"),
-                "ASC",
-            ],
-        ],
-    });
-    const packetsPerChain = {};
-    packets.map((packet) => {
-        if (!packetsPerChain[packet.srcChainSlug])
-            packetsPerChain[packet.srcChainSlug] = [];
-        packetsPerChain[packet.srcChainSlug].push(packet);
-    });
-    if (packets.length > 0)
-        console.log("pending seal packets count: ", packets.length);
-    return packetsPerChain;
-};
-const sendSealBatch = async (chainSlug, packets, socketAddress, socketBatcher
-// metric: SocketMetric
-) => {
-    const sealBatchDataArgs = [];
-    let packetRowIds = [];
-    let isSuccessful = true;
-    let txHash = "";
-    let txId = "";
-    try {
-        const metrics = [];
-        packetRowIds = packets.map((packet) => packet.id);
-        const packetIds = packets.map((p) => p.packetId);
-        console.log({ action: "seal", chainSlug, packetIds });
-        for (const packet of packets) {
-            if (packet.sealSignature === undefined ||
-                packet.sealSignature === null ||
-                packet.sealSignature.length == 0) {
-                throw {
-                    message: "packet.sealSignature is empty for packet " +
-                        packet.packetId +
-                        " on chain " +
-                        chainSlug +
-                        "!",
-                };
-            }
-            sealBatchDataArgs.push([0, packet.srcCapacitor, packet.sealSignature]);
-            metrics.push({
-                labels: {
-                    [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: packet.srcChainSlug,
-                },
-                timeDiff: (0, utils_2.currentTimestampInSeconds)() - packet.outboundTime,
-            });
-        }
-        const srcChainSlug = packets[0].srcChainSlug;
-        if (sealBatchDataArgs.length === 0)
-            return;
-        console.log("sending seal batch transaction");
-        const txn = await socketBatcher.sealBatch(socketAddress, sealBatchDataArgs);
-        console.log("sent seal batch transaction", txHash);
-        txHash = txn.hash;
-        // @ts-expect-error
-        txId = txn.txId;
-        metrics.map((m) => {
-            (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.sealRelay.txDiffHistogram, m);
-        });
-        utils_1.logger.info(`seal-batch-relayer completed batch transaction: ${txHash} while sealing on chain: ${srcChainSlug} for ${packets.length} packets`);
-    }
-    catch (err) {
-        utils_1.logger.error("sealBatch: Failed to relay sealBatch for packets", err);
-        isSuccessful = false;
-        await (0, exports.markSealRecentError)();
-    }
-    // if the seal-batch transaction is successful, then retain the existing status which is `SEALING`
-    // if the transactionHash exists then it will be updated as `sealTxHash` else it will be empty
-    try {
-        const sealRelayStatus = isSuccessful
-            ? models_1.SealRelayStatus.SEALING
-            : models_1.SealRelayStatus.NO;
-        await models_1.Packet.update({
-            sealTxId: txId,
-            sealTxHash: txHash,
-            sealRelayStatus,
-        }, {
-            where: {
-                id: {
-                    [sequelize_1.Op.in]: packetRowIds,
-                },
-            },
-        });
-    }
-    catch (err) {
-        utils_1.logger.error(`Failed to update the transactionHash and isRelaying Status after sealBatch call for srcChainSlug: ${chainSlug}`, err);
-    }
-    return txHash;
-};
-const checkAndSeal = async () => {
-    var _a, _b, _c;
-    try {
-        // check if any pending message on any chain. If found, add message to queue
-        // and return.
-        const packetsPerChain = await getPendingSealPackets(constants_1.supportedChainSlugs);
-        const packetCountPerChain = {};
-        for (const chainSlug in packetsPerChain) {
-            if (!((_a = packetsPerChain[chainSlug]) === null || _a === void 0 ? void 0 : _a.length))
-                continue;
-            packetCountPerChain[chainSlug] = packetsPerChain[chainSlug].length;
-        }
-        for (const chainSlug of constants_1.supportedChainSlugs) {
-            if (!((_b = packetsPerChain[chainSlug]) === null || _b === void 0 ? void 0 : _b.length))
-                continue;
-            (0, utils_1.logInfo)({
-                info: "QUEUING_SEAL",
-                chainSlug,
-                packetCount: (_c = packetsPerChain[chainSlug]) === null || _c === void 0 ? void 0 : _c.length,
-                packetIds: packetsPerChain[chainSlug].map((p) => p.packetId),
-                messageIds: [],
-            });
-            await (0, services_1.sendStandardSqsMessage)(constants_1.SQS_BASE_URL + constants_1.QueueName.BATCHER_TASK_QUEUE, {
-                type: constants_1.TaskNames.RELAY_SEAL,
-                data: {
-                    chainSlug,
-                    counter: Math.floor(Math.random() * 100),
-                },
-            });
-            (0, utils_1.logInfo)({
-                info: "QUEUED_SEAL",
-                chainSlug,
-                packetCountPerChain,
-                packetIds: packetsPerChain[chainSlug].map((p) => p.packetId),
-                messageIds: [],
-            });
-            // @review why break?
-            break;
-        }
-    }
-    catch (error) {
-        console.log("error in checkAndPropose: ", error);
-    }
-};
-exports.checkAndSeal = checkAndSeal;
-const isRecentSealError = async () => {
-    // seal can get blocked due to following reasons - seal tx pending, seal tx failed, seal tx reverting. try to cover all the cases here.
-    const isRecentError = await (0, services_1.getKey)(recentSealErrorRedisKey);
-    if (isRecentError)
-        return true;
-    return false;
-};
-exports.isRecentSealError = isRecentSealError;
-const markSealRecentError = async () => {
-    console.log("marking recent seal error");
-    await (0, services_1.setKey)(recentSealErrorRedisKey, Date.now(), 30 * 60);
-};
-exports.markSealRecentError = markSealRecentError;

package/dist/src/services/attestService.d.ts

@@ -1,45 +0,0 @@
-import { type TripReason, AttestSignature, type AttestRequest, type AttestResponse } from "../../dl-common";
-import { type PacketProposalCounts, type PacketAttestSignatures, type PacketMessageAttestJoin } from "../constants";
-export interface AttestSignatureDbUpdate {
-    signature: string;
-    packetId: string;
-    watcherId: string;
-    root: string;
-    proposalCount: number;
-}
-interface PacketDbUpdates {
-    packetId: string;
-    tripReason: TripReason;
-}
-type PacketRequestData = Record<string, AttestRequest>;
-type SignaturesRequiredCount = Record<string, number>;
-export declare const getAndSaveAttestSignatures: (packets: PacketMessageAttestJoin[], packetProposalCounts: PacketProposalCounts) => Promise<PacketAttestSignatures>;
-export declare const processWatcherSignatures: (watcherId: string, attestSignaturesResponse: AttestResponse[], packetAttestSignatures: PacketAttestSignatures, packetRequestData: PacketRequestData) => Promise<{
-    watcherAttestSignatureDbUpdates: AttestSignatureDbUpdate[];
-    watcherPacketDbUpdates: PacketDbUpdates[];
-    packetAttestSignatures: PacketAttestSignatures;
-}>;
-export declare const savePacketUpdates: (dbUpdates: PacketDbUpdates[]) => Promise<void>;
-export declare const saveAttestSignatureUpdates: (dbUpdates: AttestSignatureDbUpdate[]) => Promise<void>;
-export declare const getWatcherRequestData: (packets: PacketMessageAttestJoin[], packetProposalCounts: PacketProposalCounts) => Promise<{
-    watcherRequestData: Record<string, AttestRequest[]>;
-    packetRequestData: PacketRequestData;
-    signaturesRequiredCount: SignaturesRequiredCount;
-    packetAttestSignatures: PacketAttestSignatures;
-}>;
-export declare const removePacketsWithIncompleteSignatures: (packetAttestSignatures: PacketAttestSignatures, signaturesRequiredCount: SignaturesRequiredCount) => Promise<PacketAttestSignatures>;
-export declare const getWatcherSignatures: (watcherId: string, attestRequests: AttestRequest[]) => Promise<{
-    success: boolean;
-    attestSignaturesResponse?: undefined;
-} | {
-    success: boolean;
-    attestSignaturesResponse: AttestResponse[];
-}>;
-export declare const findWatcherSignatureInDb: (packetId: string, proposalCount: number, root: string, watcherId: string, currentDBAttestSignatures?: AttestSignature[]) => {
-    isSignaturePresent: boolean;
-    signature: string;
-} | {
-    isSignaturePresent: boolean;
-    signature: null;
-};
-export {};

package/dist/src/services/attestService.js

@@ -1,269 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findWatcherSignatureInDb = exports.getWatcherSignatures = exports.removePacketsWithIncompleteSignatures = exports.getWatcherRequestData = exports.saveAttestSignatureUpdates = exports.savePacketUpdates = exports.processWatcherSignatures = exports.getAndSaveAttestSignatures = void 0;
-const utils_1 = require("../utils");
-const dl_common_1 = require("../../dl-common");
-const constants_1 = require("../constants");
-const dl_core_1 = require("@socket.tech/dl-core");
-const watchers_1 = require("../constants/watchers");
-const getAndSaveAttestSignatures = async (packets, packetProposalCounts) => {
-    const attestSignatureDbUpdates = [];
-    const packetDbUpdates = [];
-    let watcherAttestSignatureDbUpdates = [];
-    let watcherPacketDbUpdates = [];
-    // If attestRelayMode is false, return empty packetAttestSignatures
-    if (!constants_1.attestRelayMode) {
-        (0, utils_1.logInfo)({
-            info: "ATTEST_RELAY_MODE_DISABLED",
-            messageIds: [],
-            packetIds: [],
-        });
-        return {};
-    }
-    const end = constants_1.relayMetrics.attestRelay.signHistogram.startTimer({
-        [constants_1.Labels.DST_CHAIN_SLUG]: packets[0].dstChainSlug,
-    });
-    (0, utils_1.logInfo)({
-        info: "ATTEST_SIGNATURE_FETCH",
-        packetIds: packets.map((a) => a.packetId),
-        messageIds: [],
-    });
-    let { watcherRequestData, packetRequestData, signaturesRequiredCount, packetAttestSignatures, } = await (0, exports.getWatcherRequestData)(packets, packetProposalCounts);
-    await Promise.all(Object.keys(watcherRequestData).map(async (watcherId) => {
-        const attestRequests = watcherRequestData[watcherId];
-        const { success, attestSignaturesResponse } = await (0, exports.getWatcherSignatures)(watcherId, attestRequests);
-        if (!success || !attestSignaturesResponse)
-            return;
-        ({
-            watcherPacketDbUpdates,
-            watcherAttestSignatureDbUpdates,
-            packetAttestSignatures,
-        } = await (0, exports.processWatcherSignatures)(watcherId, attestSignaturesResponse, packetAttestSignatures, packetRequestData));
-        attestSignatureDbUpdates.push(...watcherAttestSignatureDbUpdates);
-        packetDbUpdates.push(...watcherPacketDbUpdates);
-    }));
-    packetAttestSignatures = await (0, exports.removePacketsWithIncompleteSignatures)(packetAttestSignatures, signaturesRequiredCount);
-    // console.log({ packetAttestSignatures });
-    // store attest signatures
-    await (0, exports.saveAttestSignatureUpdates)(attestSignatureDbUpdates);
-    await (0, exports.savePacketUpdates)(packetDbUpdates);
-    end();
-    (0, utils_1.logInfo)({
-        info: "ATTEST_SIGNATURE_FETCHED",
-        packetIds: packets.map((a) => a.packetId),
-        messageIds: [],
-    });
-    // console.log("fetching attest signatures time taken: ", Date.now() - start);
-    return packetAttestSignatures;
-};
-exports.getAndSaveAttestSignatures = getAndSaveAttestSignatures;
-const processWatcherSignatures = async (watcherId, attestSignaturesResponse, packetAttestSignatures, packetRequestData) => {
-    const watcherAttestSignatureDbUpdates = [];
-    const watcherPacketDbUpdates = [];
-    for (const attestSignature of attestSignaturesResponse) {
-        const { proposalValid } = attestSignature;
-        if (proposalValid) {
-            const { packetId, signature } = attestSignature;
-            packetAttestSignatures[packetId].push(signature);
-            const { root, proposalCount } = packetRequestData[packetId];
-            watcherAttestSignatureDbUpdates.push({
-                packetId,
-                signature,
-                watcherId,
-                root,
-                proposalCount,
-            });
-        }
-        else {
-            const { packetId, reason } = attestSignature;
-            watcherPacketDbUpdates.push({ packetId, tripReason: reason });
-        }
-    }
-    return {
-        watcherAttestSignatureDbUpdates,
-        watcherPacketDbUpdates,
-        packetAttestSignatures,
-    };
-};
-exports.processWatcherSignatures = processWatcherSignatures;
-const savePacketUpdates = async (dbUpdates) => {
-    try {
-        (0, utils_1.logInfo)({
-            info: "STORED_TRIP_REASON",
-            packetIds: dbUpdates.map((a) => a.packetId),
-            messageIds: [],
-        });
-        if (dbUpdates.length === 0)
-            return;
-        // TODO: fix this
-        // @ts-expect-error
-        await dl_common_1.Packet.bulkCreate(dbUpdates, {
-            updateOnDuplicate: ["tripReason"],
-        });
-        (0, utils_1.logInfo)({
-            info: "STORED_TRIP_REASON",
-            packetIds: dbUpdates.map((a) => a.packetId),
-            messageIds: [],
-        });
-    }
-    catch (error) {
-        utils_1.logger.error("Error while saving packet trip reason updates", error);
-        throw new Error(`Error while saving packet trip reason updates ${error === null || error === void 0 ? void 0 : error.message}`);
-    }
-};
-exports.savePacketUpdates = savePacketUpdates;
-const saveAttestSignatureUpdates = async (dbUpdates) => {
-    try {
-        (0, utils_1.logInfo)({
-            info: "STORING_ATTEST_SIG",
-            packetIds: dbUpdates.map((a) => a.packetId),
-            messageIds: [],
-        });
-        if (dbUpdates.length === 0)
-            return;
-        // TODO: fix this
-        // @ts-expect-error
-        await dl_common_1.AttestSignature.bulkCreate(dbUpdates, {
-            updateOnDuplicate: ["signature", "root"],
-        });
-        (0, utils_1.logInfo)({
-            info: "STORED_ATTEST_SIG",
-            packetIds: dbUpdates.map((a) => a.packetId),
-            messageIds: [],
-        });
-    }
-    catch (error) {
-        utils_1.logger.error("Error while saving new attest signature updates", error);
-        throw new Error(`Error while saving new  attest signature  updates ${error === null || error === void 0 ? void 0 : error.message}`);
-    }
-};
-exports.saveAttestSignatureUpdates = saveAttestSignatureUpdates;
-const getWatcherRequestData = async (packets, packetProposalCounts) => {
-    const watcherRequestData = {};
-    const packetRequestData = {};
-    const signaturesRequiredCount = {};
-    const packetAttestSignatures = {};
-    packets.map((packet) => {
-        if (packet.isAttested) {
-            return;
-        }
-        // If integration type is not fast or fast2, no point in sending request to watcher.
-        // This might be updated when adding new switchboard types.
-        if (![dl_core_1.IntegrationTypes.fast, dl_core_1.IntegrationTypes.fast2].includes(packet.integrationType))
-            return;
-        if (!packetAttestSignatures[packet.packetId])
-            packetAttestSignatures[packet.packetId] = [];
-        const currentDBAttestSignatures = packet.AttestSignatures;
-        const watcherIds = (0, watchers_1.getWatchers)(packet.srcChainSlug, packet.dstChainSlug, packet.dstSwitchboard);
-        if (watcherIds.length === 0)
-            return;
-        signaturesRequiredCount[packet.packetId] = watcherIds.length;
-        for (const watcherId of watcherIds) {
-            if (!watcherRequestData[watcherId])
-                watcherRequestData[watcherId] = [];
-            const { dstChainSlug, dstSwitchboard, packetId, root } = packet;
-            const proposalCount = packetProposalCounts[packetId].count;
-            const { isSignaturePresent, signature } = (0, exports.findWatcherSignatureInDb)(packetId, proposalCount, root, watcherId, currentDBAttestSignatures);
-            if (isSignaturePresent && signature) {
-                packetAttestSignatures[packetId].push(signature);
-                continue;
-            }
-            const requestData = {
-                packetId,
-                root,
-                switchboardAddress: dstSwitchboard,
-                dstChainSlug,
-                proposalCount: packetProposalCounts[packetId].count,
-            };
-            watcherRequestData[watcherId].push(requestData);
-            // this might get overwritten, but as same data for all watchers for a packetId, no issues
-            packetRequestData[packetId] = requestData;
-        }
-    });
-    return {
-        watcherRequestData,
-        packetRequestData,
-        signaturesRequiredCount,
-        packetAttestSignatures,
-    };
-};
-exports.getWatcherRequestData = getWatcherRequestData;
-const removePacketsWithIncompleteSignatures = async (packetAttestSignatures, signaturesRequiredCount) => {
-    const packetIds = Object.keys(packetAttestSignatures);
-    packetIds.forEach((packetId) => {
-        const signaturesCount = packetAttestSignatures[packetId].length;
-        const isEnoughSignatures = signaturesCount === signaturesRequiredCount[packetId];
-        // remove the packets having incomplete signatures from packetAttestSignatures object
-        if (!isEnoughSignatures)
-            delete packetAttestSignatures[packetId];
-    });
-    return packetAttestSignatures;
-};
-exports.removePacketsWithIncompleteSignatures = removePacketsWithIncompleteSignatures;
-const getWatcherSignatures = async (watcherId, attestRequests) => {
-    if (attestRequests.length === 0) {
-        return { success: false };
-    }
-    const { baseUrl, authToken } = watchers_1.watchers[watcherId];
-    if (!baseUrl) {
-        console.log("baseUrl not present for watcher: ", watcherId);
-        return { success: false };
-    }
-    const url = baseUrl + "/attest";
-    (0, utils_1.logInfo)({
-        info: "FETCH_ATTEST_SIG",
-        packetIds: attestRequests.map((a) => a.packetId),
-        url,
-        watcherId,
-        messageIds: [],
-    });
-    const response = await (0, dl_common_1.axiosPost)(url, attestRequests, {
-        headers: {
-            "x-api-key": authToken,
-        },
-    });
-    if (!response.success || !(response === null || response === void 0 ? void 0 : response.result)) {
-        (0, utils_1.logError)({
-            info: "ERROR_IN_FETCH_ATTEST_SIG",
-            packetIds: attestRequests.map((a) => a.packetId),
-            url,
-            watcherId,
-            response,
-            messageIds: [],
-        });
-        return { success: false };
-    }
-    (0, utils_1.logInfo)({
-        info: "FETCHED_ATTEST_SIG",
-        packetIds: attestRequests.map((a) => a.packetId),
-        messageIds: [],
-    });
-    const attestSignaturesResponse = response === null || response === void 0 ? void 0 : response.result;
-    return { success: true, attestSignaturesResponse };
-};
-exports.getWatcherSignatures = getWatcherSignatures;
-const findWatcherSignatureInDb = (packetId, proposalCount, root, watcherId, currentDBAttestSignatures) => {
-    if (currentDBAttestSignatures === null || currentDBAttestSignatures === void 0 ? void 0 : currentDBAttestSignatures.length) {
-        // number of signatures per packet are going to be small, so this should not affect performance
-        const watcherSignatures = currentDBAttestSignatures.filter((obj) => obj.watcherId === watcherId &&
-            obj.proposalCount === proposalCount &&
-            obj.root === root &&
-            obj.packetId === packetId);
-        if (watcherSignatures.length > 0) {
-            if (watcherSignatures.length === 1)
-                return {
-                    isSignaturePresent: true,
-                    signature: watcherSignatures[0].signature,
-                };
-            const signature = watcherSignatures[0].signature;
-            for (let i = 1; i < watcherSignatures.length; i++) {
-                if (watcherSignatures[i].signature !== signature) {
-                    throw new Error("multiple watcher signatures: " + packetId);
-                }
-            }
-            return { isSignaturePresent: true, signature };
-        }
-    }
-    return { isSignaturePresent: false, signature: null };
-};
-exports.findWatcherSignatureInDb = findWatcherSignatureInDb;

package/dist/src/services/batcherService.d.ts

@@ -1,9 +0,0 @@
-import { type ChainSlug } from "@socket.tech/dl-core";
-import { type PacketAttestSignatures, type PacketProposalCounts, type PacketMessageAttestJoin, type BatchData } from "../constants";
-export declare const calculateBatchGasLimit: (dstChainSlug: ChainSlug, currentBatch: BatchData) => Promise<BatchData>;
-export declare const checkGasLimitAndAddToBatch: (dstChainSlug: ChainSlug, currentGasLimit: number, currentBatch: BatchData, batchArgsArray: BatchData[]) => Promise<{
-    currentGasLimit: number;
-    batchArgsArray: BatchData[];
-    currentBatch: BatchData;
-}>;
-export declare const getBatchDataArgs: (packets: PacketMessageAttestJoin[], packetAttestSignatures: PacketAttestSignatures, packetProposalCounts: PacketProposalCounts) => Promise<BatchData[]>;