@socket.tech/dl-common 1.0.7 → 1.0.8

package/dist/src/services/batcherService.js

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

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

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

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

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

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

package/dist/src/services/index.js

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

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

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

@@ -1,9 +0,0 @@
-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 {};