@socket.tech/dl-common 1.0.6 → 1.0.7

package/dist/src/services/batcherService.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBatchDataArgs = exports.checkGasLimitAndAddToBatch = exports.calculateBatchGasLimit = void 0;
+const dl_core_1 = require("@socket.tech/dl-core");
+const constants_1 = require("../constants");
+const ethers_1 = require("ethers");
+const gasEstimation_1 = require("../constants/gasEstimation");
+const gasEstimationService_1 = require("./gasEstimationService");
+const common_1 = require("../relayers/common");
+const utils_1 = require("../utils");
+const calculateBatchGasLimit = async (dstChainSlug, currentBatch) => {
+    try {
+        const start = Date.now();
+        let totalGasLimit = 0;
+        const socketBatcher = await (0, common_1.getSocketBatcher)(dstChainSlug, {}, false);
+        const socketAddress = (0, common_1.getSocketAddress)(dstChainSlug);
+        (0, utils_1.logInfo)({
+            info: "ESTIMATING_GAS_PROPOSE_RELAY",
+            packetIds: currentBatch.proposeBatchDataArgs.map((a) => a[0]),
+            messageIds: [],
+        });
+        const proposeAttestGasEstimate = await socketBatcher.estimateGas.sendBatch(socketAddress, 
+        // switchboardAddress, // this may change if we have multiple switchboards. this works only for
+        // fast switchboard case
+        [], // for sealBatch
+        currentBatch.proposeBatchDataArgs, currentBatch.attestBatchDataArgs, [], {
+            value: currentBatch.totalMsgValue.toHexString(),
+        });
+        totalGasLimit += proposeAttestGasEstimate.toNumber();
+        for (const [executionDetails, messageDetails,] of currentBatch.executeBatchDataArgs) {
+            totalGasLimit += executionDetails[2].toNumber();
+        }
+        totalGasLimit = Math.floor(1.1 * totalGasLimit + 100000); // for safety
+        currentBatch.totalGasLimit = totalGasLimit;
+        (0, utils_1.logInfo)({
+            info: "FINAL_GAS_LIMIT",
+            totalGasLimit,
+            packetIds: currentBatch.proposeBatchDataArgs.map((a) => a[0]),
+            timeTaken: Date.now() - start,
+            messageIds: [],
+        });
+    }
+    catch (error) {
+        console.log("Error in calculateBatchGasLimit", error);
+    }
+    return currentBatch;
+};
+exports.calculateBatchGasLimit = calculateBatchGasLimit;
+const checkGasLimitAndAddToBatch = async (dstChainSlug, currentGasLimit, currentBatch, batchArgsArray) => {
+    const maxGasLimit = (0, gasEstimation_1.getMaxGasLimit)(dstChainSlug);
+    // console.log("maxGasLimit", maxGasLimit);
+    if (currentGasLimit > maxGasLimit) {
+        currentBatch = await (0, exports.calculateBatchGasLimit)(dstChainSlug, currentBatch);
+        // console.log(currentBatch.proposeRowIds, currentBatch.attestRowIds, currentBatch.messageRowIds);
+        batchArgsArray.push(currentBatch);
+        currentBatch = {
+            proposeBatchDataArgs: [],
+            attestBatchDataArgs: [],
+            executeBatchDataArgs: [],
+            totalMsgValue: ethers_1.BigNumber.from(0),
+            totalGasLimit: 0,
+            proposeRowIds: [],
+            attestRowIds: [],
+            messageRowIds: [],
+        };
+        currentGasLimit = 0;
+    }
+    return { currentGasLimit, batchArgsArray, currentBatch };
+};
+exports.checkGasLimitAndAddToBatch = checkGasLimitAndAddToBatch;
+const getBatchDataArgs = async (packets, packetAttestSignatures, packetProposalCounts) => {
+    let currentGasLimit = 0;
+    let packetGasLimit = 0;
+    let skip = false;
+    let batchArgsArray = [];
+    let currentBatch = {
+        proposeBatchDataArgs: [],
+        attestBatchDataArgs: [],
+        executeBatchDataArgs: [],
+        totalMsgValue: ethers_1.BigNumber.from(0),
+        totalGasLimit: 0,
+        proposeRowIds: [],
+        attestRowIds: [],
+        messageRowIds: [],
+    };
+    for (const packet of packets) {
+        // before start of every iteration, check if currentGasLimit is greater than
+        // maxGasLimit and reset packetGasLimit. Ignored on first iteration.
+        currentGasLimit += packetGasLimit;
+        ({ currentGasLimit, currentBatch, batchArgsArray } =
+            await (0, exports.checkGasLimitAndAddToBatch)(packet.dstChainSlug, currentGasLimit, currentBatch, batchArgsArray));
+        packetGasLimit = 0;
+        skip = false;
+        ({ currentBatch, packetGasLimit, skip } = await addProposeArgs(packet, currentBatch, packetGasLimit));
+        if (skip)
+            continue;
+        ({ currentBatch, packetGasLimit, skip } = await addAttestArgs(packet, packetAttestSignatures, packetProposalCounts, currentBatch, packetGasLimit));
+        if (skip)
+            continue;
+        if (!constants_1.executeRelayMode)
+            continue;
+        ({ currentBatch, packetGasLimit, skip } = await addExecuteArgs(packet, currentBatch, packetGasLimit, packetProposalCounts));
+        if (skip)
+            continue;
+    }
+    if (currentBatch.proposeBatchDataArgs.length > 0 ||
+        currentBatch.attestBatchDataArgs.length > 0 ||
+        currentBatch.executeBatchDataArgs.length > 0) {
+        currentBatch = await (0, exports.calculateBatchGasLimit)(packets[0].dstChainSlug, currentBatch);
+        batchArgsArray.push(currentBatch);
+    }
+    return batchArgsArray;
+};
+exports.getBatchDataArgs = getBatchDataArgs;
+const addProposeArgs = async (packet, currentBatch, packetGasLimit) => {
+    // If not proposed, and proposeRelayMode is also false, no point in continuing.
+    // If proposeRelayMode is false, but isProposed is true, we can still proceed if
+    // attest and execute is pending (and their relay mode is true)
+    if (!constants_1.proposeRelayMode && !packet.isProposed) {
+        return { currentBatch, packetGasLimit, skip: true };
+    }
+    if (!packet.isProposed) {
+        currentBatch.proposeBatchDataArgs.push([
+            packet.packetId,
+            packet.root,
+            packet.dstSwitchboard,
+            packet.sealSignature,
+        ]);
+        currentBatch.proposeRowIds.push(packet.id);
+        const proposeGasLimit = await (0, gasEstimationService_1.getProposeGasLimit)(packet.dstChainSlug);
+        packetGasLimit += proposeGasLimit;
+    }
+    return { currentBatch, packetGasLimit, skip: false };
+};
+const addAttestArgs = async (packet, packetAttestSignatures, packetProposalCounts, currentBatch, packetGasLimit) => {
+    // if fast integration type and not attested, and got enough signatures, add to attest batch.
+    // if not attested and didnt get enough signatures, continue from here.
+    // attestRelayMode check inside attestService. we get empty packetAttestSignatures
+    // and therefore no attestations, and no message execution(if attestation pending).
+    var _a;
+    if ([dl_core_1.IntegrationTypes.fast, dl_core_1.IntegrationTypes.fast2].includes(packet.integrationType) &&
+        !packet.isAttested) {
+        if ((_a = packetAttestSignatures[packet.packetId]) === null || _a === void 0 ? void 0 : _a.length) {
+            const attestGasLimit = await (0, gasEstimationService_1.getAttestGasLimit)(packet.dstChainSlug);
+            packetAttestSignatures[packet.packetId].map(async (signature) => {
+                currentBatch.attestBatchDataArgs.push([
+                    packet.dstSwitchboard,
+                    packet.packetId,
+                    packetProposalCounts[packet.packetId].count,
+                    packet.root,
+                    signature,
+                ]);
+                packetGasLimit += attestGasLimit;
+            });
+            currentBatch.attestRowIds.push(packet.id);
+        }
+        else {
+            // If not already attested, and didnt get enough signatures now as well, no point
+            // batching message execution. continue from here.
+            return { currentBatch, packetGasLimit, skip: true };
+        }
+    }
+    return { currentBatch, packetGasLimit, skip: false };
+};
+const addExecuteArgs = async (packet, currentBatch, packetGasLimit, packetProposalCounts) => {
+    // while getting isProposed false packets, we might get native packets
+    // with isVerified false, but valid message. skip their execution.
+    // wont appear in query again as soon as proposed.
+    if ([dl_core_1.IntegrationTypes.native, dl_core_1.IntegrationTypes.optimistic].includes(packet.integrationType) &&
+        !packet.isVerified)
+        return { currentBatch, packetGasLimit, skip: true };
+    const messages = packet.Messages;
+    if (messages === null || messages === void 0 ? void 0 : messages.length)
+        for (const message of messages) {
+            const { retry, messageId, executeMsgGasLimit, executeSignature, inboundSuccess, packetId, decapacitorProof, executionFee, minMsgGasLimit, executionParams, payload, id, } = message;
+            currentBatch.messageRowIds.push(id);
+            if (executionParams.slice(0, 4) !== "0x00") {
+                const msgValue = ethers_1.BigNumber.from("0x" + executionParams.slice(4));
+                currentBatch.totalMsgValue = currentBatch.totalMsgValue.add(msgValue);
+            }
+            currentBatch.executeBatchDataArgs.push([
+                // executionDetails,
+                [
+                    packetId,
+                    packetProposalCounts[packetId].count,
+                    ethers_1.BigNumber.from(executeMsgGasLimit),
+                    decapacitorProof,
+                    executeSignature,
+                ],
+                // msgDetails
+                [messageId, executionFee, minMsgGasLimit, executionParams, payload],
+            ]);
+            const executeGasLimit = ethers_1.BigNumber.from(executeMsgGasLimit).toNumber();
+            packetGasLimit += executeGasLimit;
+        }
+    return { currentBatch, packetGasLimit, skip: false };
+};

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

@@ -0,0 +1,16 @@
+import { type ChainSlug } from "@socket.tech/dl-core";
+import { type ExecuteSigResponse } from "../../dl-common/constants";
+export interface ExecuteSigRequest {
+    messageId: string;
+    destPlug: string;
+    srcPlug: string;
+    dstChainSlug: ChainSlug;
+    srcChainSlug: ChainSlug;
+    payload: string;
+    minMsgGasLimit: string;
+    executionParams: string;
+    packedMessage: string;
+}
+export declare const sendRetrySimulationRequest: () => Promise<void>;
+export declare const sendPendingSimulationRequest: () => Promise<void>;
+export declare const saveMessageSimulationResponse: (executeResponseData: ExecuteSigResponse[]) => Promise<void>;

package/dist/src/services/executeService.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveMessageSimulationResponse = exports.sendPendingSimulationRequest = exports.sendRetrySimulationRequest = void 0;
+const utils_1 = require("../../dl-common/utils");
+const utils_2 = require("../utils");
+const constants_1 = require("../constants");
+const models_1 = require("../../dl-common/models");
+const sequelize_1 = require("sequelize");
+const prometheus_config_1 = require("../constants/prometheus.config");
+const constants_2 = require("../../dl-common/constants");
+const ethers_1 = require("ethers");
+const sendRequest = async (messages) => {
+    const executeRequestData = [];
+    const start = Date.now();
+    for (const message of messages) {
+        executeRequestData.push({
+            messageId: message.messageId,
+            destPlug: message.destPlug,
+            srcPlug: message.srcPlug,
+            dstChainSlug: message.dstChainSlug,
+            srcChainSlug: message.srcChainSlug,
+            payload: message.payload,
+            minMsgGasLimit: message.minMsgGasLimit,
+            executionParams: message.executionParams,
+            packedMessage: message.packedMessage,
+        });
+    }
+    (0, utils_2.logInfo)({
+        info: "EXECUTOR_POST_API_CALLING",
+        messageIds: messages.map((m) => m.messageId),
+        start,
+        packetIds: [],
+    });
+    if (constants_1.EXECUTOR_URL) {
+        const response = await (0, utils_1.axiosPost)(constants_1.EXECUTOR_URL, { messageData: executeRequestData }, { headers: { "x-auth-token": constants_1.EXECUTOR_AUTH_TOKEN } });
+        (0, utils_2.logInfo)({
+            info: "EXECUTOR_POST_API_CALLED",
+            messageIds: messages.map((m) => m.messageId),
+            packetIds: [],
+            end: Date.now() - start,
+            response,
+        });
+    }
+    else {
+        // @review throw here?
+        console.log("Call to executor failed");
+    }
+};
+const sendRetrySimulationRequest = async () => {
+    try {
+        const messages = await getRetrySimulationMessages();
+        if (messages.length == 0)
+            return;
+        (0, utils_2.logInfo)({
+            info: "RETRY_SIMULATION_REQUEST",
+            msgCount: messages.length,
+            messageIds: messages.map((m) => m.messageId),
+            packetIds: [],
+        });
+        const messagesAsChunks = [...(0, utils_1.chunks)(messages, constants_1.executeBatchRelayLimit)];
+        for (const chunk of messagesAsChunks)
+            await sendRequest(chunk);
+    }
+    catch (error) {
+        console.log("error while sending retry simulation request: ", error);
+    }
+};
+exports.sendRetrySimulationRequest = sendRetrySimulationRequest;
+const sendPendingSimulationRequest = async () => {
+    try {
+        const messages = await getPendingSimulationMessages();
+        if (messages.length > 0) {
+            (0, utils_2.logInfo)({
+                info: "PENDING_SIMULATION_REQUEST",
+                msgCount: messages.length,
+                messageIds: messages.map((m) => m.messageId),
+                packetIds: [],
+            });
+            const messagesAsChunks = [...(0, utils_1.chunks)(messages, constants_1.executeBatchRelayLimit)];
+            for (const chunk of messagesAsChunks)
+                await sendRequest(chunk);
+            (0, utils_2.logInfo)({
+                info: "PENDING_SIMULATION_REQUEST_SENT",
+                messageIds: messages.map((m) => m.messageId),
+                packetIds: [],
+            });
+        }
+    }
+    catch (error) {
+        console.log("error while sendMessageSimulationRequest request: ", error);
+    }
+};
+exports.sendPendingSimulationRequest = sendPendingSimulationRequest;
+const saveMessageSimulationResponse = async (executeResponseData) => {
+    if (!(executeResponseData === null || executeResponseData === void 0 ? void 0 : executeResponseData.length))
+        return;
+    const messageIds = [];
+    executeResponseData.map((data) => {
+        messageIds.push(data.messageId);
+    });
+    const messages = await models_1.Message.findAll({
+        where: {
+            messageId: { [sequelize_1.Op.in]: messageIds },
+        },
+    });
+    const messageMap = new Map();
+    messages.forEach((message) => {
+        messageMap.set(message.messageId, message);
+    });
+    if (executeResponseData === null || executeResponseData === void 0 ? void 0 : executeResponseData.length) {
+        executeResponseData = executeResponseData.map((data) => {
+            var _a;
+            const firstSimulationTimestamp = Math.floor(Date.now() / 1000);
+            let executeRelayStatus = models_1.ExecutionRelayStatus.NO;
+            const MaxMsgGasLimit = (0, constants_1.getMaxMsgGasLimit)((_a = messageMap.get(data.messageId)) === null || _a === void 0 ? void 0 : _a.dstChainSlug);
+            // mark ignored if msgGasLimit mentioned is too big
+            if (ethers_1.BigNumber.from(data.executeMsgGasLimit).gt(MaxMsgGasLimit)) {
+                executeRelayStatus = models_1.ExecutionRelayStatus.IGNORED;
+            }
+            if (data.inboundRevertString === constants_2.ErrorReasons.ZERO_AMOUNT) {
+                executeRelayStatus = models_1.ExecutionRelayStatus.IGNORED;
+            }
+            return {
+                ...data,
+                firstSimulationTimestamp,
+                executeRelayStatus,
+            };
+        });
+        (0, utils_2.logInfo)({
+            info: "UPDATING_SIMULATION_STATES",
+            msgCount: executeResponseData.length,
+            messageIds: executeResponseData.map((m) => m.messageId),
+            packetIds: [],
+        });
+        await saveMessageUpdates(executeResponseData);
+        (0, utils_2.logInfo)({
+            info: "UPDATED_SIMULATION_STATES",
+            messageIds: executeResponseData.map((m) => m.messageId),
+            packetIds: [],
+        });
+    }
+    messages.forEach((message) => {
+        (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.executeRelay.signHistogram, {
+            labels: {
+                [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: message.srcChainSlug,
+                [prometheus_config_1.Labels.DST_CHAIN_SLUG]: message.dstChainSlug,
+            },
+            timeDiff: (0, utils_1.currentTimestampInSeconds)() - message.outboundTime,
+        });
+    });
+};
+exports.saveMessageSimulationResponse = saveMessageSimulationResponse;
+const saveMessageUpdates = async (dbUpdates) => {
+    try {
+        // TODO: fix this
+        // @ts-expect-error
+        await models_1.Message.bulkCreate(dbUpdates, {
+            updateOnDuplicate: [
+                "retry",
+                "inboundSuccess",
+                "inboundRevertString",
+                "firstSimulationTimestamp",
+                "executeSignature",
+                "executeMsgGasLimit",
+                "executeRelayStatus",
+            ],
+        });
+    }
+    catch (error) {
+        utils_2.logger.error("Error while saving execute signature updates", error);
+        throw new Error(`Error while saving execute signature  updates ${error === null || error === void 0 ? void 0 : error.message}`);
+    }
+};
+const getPendingSimulationMessages = async () => {
+    return await models_1.Message.findAll({
+        limit: constants_1.executeBatchQueryLimit,
+        where: {
+            isExecuted: false,
+            executeRelayStatus: {
+                [sequelize_1.Op.not]: models_1.ExecutionRelayStatus.IGNORED,
+            },
+            firstSimulationTimestamp: 0,
+        },
+        order: [["updatedAt", "ASC"]],
+    });
+};
+const getRetrySimulationMessages = async () => {
+    return await models_1.Message.findAll({
+        limit: constants_1.executeBatchQueryLimit,
+        where: {
+            isExecuted: false,
+            // already checked before, and within retry interval period
+            firstSimulationTimestamp: {
+                [sequelize_1.Op.gt]: Math.floor(Date.now() / 1000) - constants_1.retryInterval,
+            },
+            [sequelize_1.Op.or]: [
+                {
+                    inboundSuccess: false,
+                },
+                {
+                    retry: false,
+                },
+            ],
+            // ignore already executed, failed, executing, and ignored messages
+            executeRelayStatus: models_1.ExecutionRelayStatus.NO,
+        },
+        order: [["updatedAt", "ASC"]],
+    });
+};

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

@@ -0,0 +1,3 @@
+import { type ChainSlug } from "@socket.tech/dl-core";
+export declare const getProposeGasLimit: (dstChainSlug: ChainSlug) => Promise<number>;
+export declare const getAttestGasLimit: (dstChainSlug: ChainSlug) => Promise<number>;

package/dist/src/services/gasEstimationService.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAttestGasLimit = exports.getProposeGasLimit = void 0;
+// update this to fetch from redis or feeUpdater service
+const getProposeGasLimit = async (dstChainSlug) => {
+    return 100000;
+};
+exports.getProposeGasLimit = getProposeGasLimit;
+const getAttestGasLimit = async (dstChainSlug) => {
+    return 100000;
+};
+exports.getAttestGasLimit = getAttestGasLimit;

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

@@ -0,0 +1,4 @@
+export * from "./sealService";
+export * from "./attestService";
+export * from "./executeService";
+export * from "./sealService";

package/dist/src/services/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// export * from './message-service';
+// export * from './packet-service';
+// export * from './connection-service';
+__exportStar(require("./sealService"), exports);
+__exportStar(require("./attestService"), exports);
+__exportStar(require("./executeService"), exports);
+__exportStar(require("./sealService"), exports);

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

@@ -0,0 +1,15 @@
+import { SealRelayStatus, type SealIndexedParams } from "../../dl-common";
+export interface SealIndexedUpdate {
+    srcChainSlug: number;
+    sealer: string;
+    isSealed: boolean;
+    sealTime: number;
+    sealIndexTime: number;
+    sealTxHash: string;
+    rootSealed: string;
+    sealRelayStatus: SealRelayStatus;
+    dstSwitchboard: string;
+    sealSignature: string;
+    packetId: string;
+}
+export declare const indexSeal: (sealIndexedUpdates: SealIndexedParams[]) => Promise<any>;

package/dist/src/services/indexSealService.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexSeal = void 0;
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const dl_common_1 = require("../../dl-common");
+const sequelize_1 = require("sequelize");
+const indexSeal = async (sealIndexedUpdates) => {
+    var _a;
+    try {
+        const chainSlug = (_a = sealIndexedUpdates[0]) === null || _a === void 0 ? void 0 : _a.srcChainSlug;
+        (0, utils_1.logInfo)({
+            info: "INDEXING_SEAL",
+            chainSlug,
+            packetIds: sealIndexedUpdates.map((p) => p.packetId),
+            messageIds: [],
+        });
+        const indexSealRequestPacketIds = sealIndexedUpdates.map((s) => s.packetId);
+        const packets = await dl_common_1.Packet.findAll({
+            where: { packetId: { [sequelize_1.Op.in]: indexSealRequestPacketIds } },
+            attributes: ["packetId", "sealIndexTime"],
+        });
+        const packetIdToSealIndexTime = {};
+        packets.forEach((packet) => {
+            packetIdToSealIndexTime[packet.packetId] = packet.sealIndexTime;
+        });
+        const packetDbUpdates = [];
+        sealIndexedUpdates.map((sealIndexData) => {
+            const { srcChainSlug, packetId } = sealIndexData;
+            packetDbUpdates.push({
+                isSealed: true,
+                sealRelayStatus: dl_common_1.SealRelayStatus.SEALED,
+                sealIndexTime: packetIdToSealIndexTime[packetId] > 0
+                    ? packetIdToSealIndexTime[packetId]
+                    : (0, dl_common_1.currentTimestampInSeconds)(),
+                ...sealIndexData,
+            });
+        });
+        if (packetDbUpdates.length > 0)
+            await savePacketUpdates(packetDbUpdates);
+        (0, utils_1.logInfo)({
+            info: "QUEUEING_FOR_PROPOSE",
+            chainSlug,
+            packetIds: packetDbUpdates.map((p) => p.packetId),
+            messageIds: [],
+        });
+        await (0, dl_common_1.sendStandardSqsMessage)(constants_1.SQS_BASE_URL + constants_1.QueueName.BATCHER_TASK_QUEUE, {
+            type: constants_1.TaskNames.RELAY_PROPOSE,
+            data: { counter: Math.floor(Math.random() * 100) },
+        });
+        await observeMetrics(indexSealRequestPacketIds, chainSlug);
+        (0, utils_1.logInfo)({
+            info: "SEAL_INDEXED_AND_QUEUED",
+            chainSlug,
+            packetIds: sealIndexedUpdates.map((p) => p.packetId),
+            messageIds: [],
+        });
+    }
+    catch (error) {
+        utils_1.logger.error("Error", error);
+        throw error;
+    }
+};
+exports.indexSeal = indexSeal;
+const observeMetrics = async (packetIds, chainSlug) => {
+    try {
+        const packetsIndexed = await dl_common_1.Packet.findAll({
+            where: {
+                packetId: {
+                    [sequelize_1.Op.in]: packetIds,
+                },
+            },
+            attributes: ["srcChainSlug", "outboundTime", "dstChainSlug"],
+        });
+        packetsIndexed.forEach((packet) => {
+            (0, constants_1.observeHistogram)(constants_1.relayMetrics.sealRelay.statusUpdateHistogram, {
+                labels: {
+                    [constants_1.Labels.SRC_CHAIN_SLUG]: packet.srcChainSlug,
+                    [constants_1.Labels.DST_CHAIN_SLUG]: packet.dstChainSlug,
+                },
+                timeDiff: (0, dl_common_1.currentTimestampInSeconds)() - packet.outboundTime,
+            });
+        });
+    }
+    catch (error) {
+        console.log("erorr in observing metrics : ", chainSlug, " ", error);
+    }
+};
+const savePacketUpdates = async (dbUpdates) => {
+    try {
+        (0, utils_1.logInfo)({
+            info: "STORING_SEAL_IN_DB",
+            packetIds: dbUpdates.map((p) => p.packetId),
+            messageIds: [],
+        });
+        //@ts-ignore
+        await dl_common_1.Packet.bulkCreate(dbUpdates, {
+            updateOnDuplicate: [
+                "sealer",
+                "isSealed",
+                "sealTime",
+                "sealIndexTime",
+                "sealTxHash",
+                "rootSealed",
+                "dstSwitchboard",
+                "sealRelayStatus",
+                "sealSignature",
+            ],
+        });
+        (0, utils_1.logInfo)({
+            info: "STORED_SEAL_IN_DB",
+            packetIds: dbUpdates.map((p) => p.packetId),
+            messageIds: [],
+        });
+    }
+    catch (error) {
+        utils_1.logger.error("Error while saving seal index updates", error);
+        throw new Error(`Error while saving seal index updates ${error === null || error === void 0 ? void 0 : error.message}`);
+    }
+};

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

@@ -0,0 +1,9 @@
+import { Packet, Proposal } from "../../dl-common/models";
+import { type ChainSlug } from "@socket.tech/dl-core";
+interface PacketJoinResult extends Packet {
+    Proposals?: Proposal[];
+}
+export declare const getIncompletePackets: (dstChainSlug: ChainSlug) => Promise<PacketJoinResult[]>;
+export declare const updateSelectedProposalCountForPackets: (chainSlug?: ChainSlug) => Promise<void>;
+export declare const updateSelectedProposalCount: (dstChainSlug: ChainSlug) => Promise<void>;
+export {};