@socket.tech/dl-common 1.0.12 → 1.0.13

package/dist/src/relayers/proposeRelayer.js

@@ -1,587 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAndPropose = exports.getPendingProposePackets = exports.relayPropose = 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 dl_core_1 = require("@socket.tech/dl-core");
-const sequelize_1 = require("sequelize");
-const common_1 = require("./common");
-const attestService_1 = require("../services/attestService");
-const services_1 = require("../../dl-common/services");
-const batcherService_1 = require("../services/batcherService");
-const prometheus_config_1 = require("../constants/prometheus.config");
-const relayPropose = async (chainSlug) => {
-    if (!constants_1.proposeRelayMode) {
-        (0, utils_1.logInfo)({
-            info: "PROPOSE_RELAY_MODE_DISABLED",
-            messageIds: [],
-            packetIds: [],
-        });
-        return;
-    }
-    const chainSlugs = constants_1.supportedChainSlugs;
-    const allPacketsPerChain = await (0, exports.getPendingProposePackets)(chainSlugs);
-    await Promise.all(chainSlugs.map(async (chainSlug) => {
-        var _a;
-        try {
-            if (((_a = allPacketsPerChain[chainSlug]) === null || _a === void 0 ? void 0 : _a.length) === 0)
-                return;
-            (0, utils_1.logInfo)({
-                chainSlug,
-                info: "PROPOSE_RELAYING",
-                packetIds: allPacketsPerChain[chainSlug].map((p) => p.packetId),
-                total: allPacketsPerChain[chainSlug].length,
-                messageIds: []
-            });
-            const socketBatcher = await (0, common_1.getSocketBatcher)(chainSlug, { type: "proposeBatch" }, false);
-            await sendProposeBatch(chainSlug, (0, common_1.getSocketAddress)(chainSlug), socketBatcher, allPacketsPerChain[chainSlug]);
-            (0, utils_1.logInfo)({
-                chainSlug,
-                info: "PROPOSE_RELAYED",
-                packetIds: allPacketsPerChain[chainSlug].map((p) => p.packetId),
-                messageIds: []
-            });
-            (0, utils_1.logInfo)({
-                info: "PROPOSE_RELAYED",
-                packetIds: allPacketsPerChain[chainSlug].map((p) => p.packetId),
-                messageIds: [],
-            });
-        }
-        catch (error) {
-            console.log(chainSlug, " error in propose relayer: ", error);
-        }
-    }));
-};
-exports.relayPropose = relayPropose;
-const sendProposeBatch = async (chainSlug, socketAddress, socketBatcher, allPackets) => {
-    const packetsAsChunks = [...(0, utils_2.chunks)(allPackets, constants_1.proposeBatchRelayLimit)];
-    for (const packets of packetsAsChunks) {
-        if (packets.length === 0) {
-            console.log("no packets to propose ", chainSlug);
-            continue;
-        }
-        const { packetIds, messageIds, packetMap, packetRowIdDetailsMap, messageRowIdDetailsMap, } = createMaps(packets);
-        const packetProposalCounts = await getPacketProposalCounts(packets, socketAddress, socketBatcher);
-        const packetProposalCountDbUpdates = getPacketProposalCountDbUpdates(packetProposalCounts, packetMap);
-        const packetAttestSignatures = await (0, attestService_1.getAndSaveAttestSignatures)(packets, packetProposalCounts);
-        let isSuccessful = true;
-        let txHash = "";
-        let txId = "";
-        const batches = await (0, batcherService_1.getBatchDataArgs)(packets, packetAttestSignatures, packetProposalCounts);
-        for (const batch of batches) {
-            (0, utils_1.logInfo)({
-                info: "BATCH_PROPOSE_RELAYING",
-                packetIds: batch.proposeBatchDataArgs.map((p) => p[0]),
-                messageTableIds: batch.messageRowIds,
-                messageIds: [],
-            });
-            const { proposeRowIds, attestRowIds, messageRowIds } = batch;
-            ({ txHash, txId, isSuccessful } = await sendBatch(batch, socketAddress, socketBatcher, chainSlug));
-            // no point in observing metrics, updating status if the batch transaction is not sent
-            if (!isSuccessful)
-                continue;
-            try {
-                observeMetrics(proposeRowIds, attestRowIds, messageRowIds, packetRowIdDetailsMap, messageRowIdDetailsMap);
-            }
-            catch (error) {
-                console.log("error in observing metrics: ", error);
-            }
-            await updateRelayStatus(proposeRowIds, attestRowIds, messageRowIds, isSuccessful, txId, txHash);
-            // only update selectedProposalCount if the proposeBatch transaction is sent
-            // ideal
-            await savePacketUpdates(packetProposalCountDbUpdates);
-            (0, utils_1.logInfo)({
-                info: "BATCH_PROPOSE_RELAYED",
-                packetIds: batch.proposeBatchDataArgs.map((p) => p[0]),
-                messageTableIds: batch.messageRowIds,
-                messageIds: [],
-            });
-        }
-    }
-};
-const getPendingProposePackets = async (dstChainSlugs) => {
-    const { commonPacketQuery, commonMessageQuery } = getCommonPacketMessageQueries(dstChainSlugs);
-    const notProposedPackets = await getNotProposedPackets(commonPacketQuery, commonMessageQuery);
-    const notAttestedFastPackets = await getNotAttestedFastPackets(commonPacketQuery, commonMessageQuery);
-    const executionPendingPackets = await getExecutionPendingPackets(commonPacketQuery, commonMessageQuery);
-    const packets = [
-        ...notProposedPackets,
-        ...notAttestedFastPackets,
-        ...executionPendingPackets,
-    ];
-    const packetsPerChain = {};
-    packets.map((packet) => {
-        if (!packetsPerChain[packet.dstChainSlug])
-            packetsPerChain[packet.dstChainSlug] = [];
-        packetsPerChain[packet.dstChainSlug].push(packet);
-    });
-    if (packets.length > 0) {
-        (0, utils_1.logInfo)({
-            info: "PENDING_DST_TXS",
-            nonProposedIds: notProposedPackets.map((p) => p.packetId),
-            notProposedPackets: notProposedPackets.length,
-            nonAttestedIds: notAttestedFastPackets.map((p) => p.packetId),
-            notAttestedFastPackets: notAttestedFastPackets.length,
-            executionPendingIds: executionPendingPackets.map((p) => p.packetId),
-            executionPendingPackets: executionPendingPackets.length,
-            messageIds: [],
-            packetIds: [],
-        });
-    }
-    return packetsPerChain;
-};
-exports.getPendingProposePackets = getPendingProposePackets;
-const getCommonPacketMessageQueries = (dstChainSlugs) => {
-    const commonPacketQuery = {
-        srcChainSlug: {
-            [sequelize_1.Op.in]: constants_1.supportedChainSlugs,
-        },
-        dstChainSlug: {
-            [sequelize_1.Op.in]: dstChainSlugs,
-        },
-        isSealed: true,
-        isFullyExecuted: false,
-        tripReason: models_1.TripReason.NO,
-        proposeRelayStatus: {
-            [sequelize_1.Op.notIn]: [
-                models_1.ProposeRelayStatus.PROPOSING,
-                models_1.ProposeRelayStatus.PROPOSE_FAILED,
-            ],
-        },
-        attestRelayStatus: {
-            [sequelize_1.Op.notIn]: [
-                models_1.AttestRelayStatus.ATTESTING,
-                models_1.AttestRelayStatus.ATTEST_FAILED,
-            ],
-        },
-    };
-    const commonMessageQuery = {
-        isExecuted: false,
-        inboundSuccess: true,
-        retry: true,
-        executeRelayStatus: models_1.ExecutionRelayStatus.NO,
-        executeSignature: {
-            [sequelize_1.Op.ne]: null,
-            [sequelize_1.Op.not]: "",
-        },
-    };
-    return { commonPacketQuery, commonMessageQuery };
-};
-const getNotProposedPackets = async (commonPacketQuery, commonMessageQuery) => {
-    // this will fetch all integration type packets for proposal. we will batch fast ones, propose optimistic and
-    // native ones and then wait for their allowPacket to turn true
-    return (await models_1.Packet.findAll({
-        limit: constants_1.proposeBatchQueryLimit,
-        where: {
-            isProposed: false,
-            ...commonPacketQuery,
-        },
-        include: [
-            {
-                model: models_1.Message,
-                where: {
-                    // as: 'Messages',
-                    ...commonMessageQuery,
-                },
-                // to get packets even though there are no messages. This is required
-                // as we need to propose, attest the packet even if the message have inboundSuccess
-                // as false
-                required: false,
-            },
-            {
-                model: models_1.AttestSignature,
-            },
-        ],
-        order: [[sequelize_1.Sequelize.col("Packet.updatedAt"), "ASC"]],
-    }));
-};
-const getNotAttestedFastPackets = async (commonPacketQuery, commonMessageQuery) => {
-    // for fast integration packets whose attestation couldnt be batched before. try again.
-    // no point in taking native or optimistic packets as they dont need to be attested.
-    return (await models_1.Packet.findAll({
-        limit: constants_1.proposeBatchQueryLimit,
-        where: {
-            isProposed: true,
-            isAttested: false,
-            ...commonPacketQuery,
-            integrationType: {
-                [sequelize_1.Op.in]: [dl_core_1.IntegrationTypes.fast, dl_core_1.IntegrationTypes.fast2],
-            },
-        },
-        include: [
-            {
-                model: models_1.Message,
-                where: {
-                    ...commonMessageQuery,
-                },
-                // to get packets even though there are no messages. This is required
-                // as we need to propose, attest the packet even if the message have inboundSuccess
-                // as false
-                required: false,
-            },
-            {
-                model: models_1.AttestSignature,
-            },
-        ],
-        order: [[sequelize_1.Sequelize.col("Packet.updatedAt"), "ASC"]],
-    }));
-};
-const getExecutionPendingPackets = async (commonPacketQuery, commonMessageQuery) => {
-    // this contains packets where isAttested/isVerified is true, but message is not executed yet.
-    // this will include packets only if there is a valid message that is ready to be executed (required:true)
-    return (await models_1.Packet.findAll({
-        limit: constants_1.proposeBatchQueryLimit,
-        where: {
-            isProposed: true,
-            ...commonPacketQuery,
-            [sequelize_1.Op.or]: [
-                {
-                    integrationType: {
-                        [sequelize_1.Op.in]: [dl_core_1.IntegrationTypes.fast, dl_core_1.IntegrationTypes.fast2],
-                    },
-                    isAttested: true,
-                },
-                {
-                    integrationType: {
-                        [sequelize_1.Op.in]: [dl_core_1.IntegrationTypes.optimistic, dl_core_1.IntegrationTypes.native],
-                    },
-                    isVerified: true,
-                },
-            ],
-        },
-        include: [
-            {
-                model: models_1.Message,
-                where: {
-                    ...commonMessageQuery,
-                },
-                // to get packets only if there are messages with inboundSuccess true
-                required: true,
-            },
-            {
-                model: models_1.AttestSignature,
-            },
-        ],
-        order: [[sequelize_1.Sequelize.col("Packet.updatedAt"), "ASC"]],
-    }));
-};
-const getPacketProposalCounts = async (packets, socketAddress, socketBatcher) => {
-    const packetProposalCounts = {};
-    const getProposalCountFromContractPacketIds = [];
-    await Promise.all(packets.map(async (packet) => {
-        const { packetId, selectedProposalCount } = packet;
-        if (selectedProposalCount !== undefined &&
-            selectedProposalCount !== null) {
-            packetProposalCounts[packetId] = {
-                count: selectedProposalCount,
-                receivedFromContract: false,
-            };
-        }
-        else {
-            getProposalCountFromContractPacketIds.push(packet.packetId);
-        }
-    }));
-    const proposalCountsFromContract = await socketBatcher.getProposalCountBatch(socketAddress, getProposalCountFromContractPacketIds);
-    getProposalCountFromContractPacketIds.forEach((packetId, index) => {
-        packetProposalCounts[packetId] = {
-            count: proposalCountsFromContract[index].toNumber(),
-            receivedFromContract: true,
-        };
-    });
-    return packetProposalCounts;
-};
-const updateRelayStatus = async (proposeRowIds, attestRowIds, messageRowIds, isSuccessful, txId, txHash) => {
-    // if the batch transaction is successful, then retain the existing status
-    // if the transactionHash exists then it will be updated else it will be empty
-    try {
-        const proposeRelayStatus = isSuccessful
-            ? models_1.ProposeRelayStatus.PROPOSING
-            : models_1.ProposeRelayStatus.NO;
-        const attestRelayStatus = isSuccessful
-            ? models_1.AttestRelayStatus.ATTESTING
-            : models_1.AttestRelayStatus.NO;
-        const executeRelayStatus = isSuccessful
-            ? models_1.ExecutionRelayStatus.EXECUTING
-            : models_1.ExecutionRelayStatus.NO;
-        (0, utils_1.logInfo)({
-            info: "PROPOSE_TX_DB_UPDATE",
-            proposeRowIds,
-            txId,
-            txHash,
-            messageIds: [],
-            packetIds: [],
-        });
-        // update propose status
-        if (proposeRowIds.length > 0)
-            await models_1.Packet.update({
-                proposeTxId: txId,
-                proposeTxHash: txHash,
-                proposeRelayStatus,
-            }, {
-                where: {
-                    id: {
-                        [sequelize_1.Op.in]: proposeRowIds,
-                    },
-                },
-            });
-        (0, utils_1.logInfo)({
-            info: "ATTEST_TX_DB_UPDATE",
-            attestRowIds,
-            txId,
-            txHash,
-            messageIds: [],
-            packetIds: [],
-        });
-        // update attest status
-        if (attestRowIds.length > 0)
-            await models_1.Packet.update({
-                attestTxId: txId,
-                attestTxHash: txHash,
-                attestRelayStatus,
-            }, {
-                where: {
-                    id: {
-                        [sequelize_1.Op.in]: attestRowIds,
-                    },
-                },
-            });
-        (0, utils_1.logInfo)({
-            info: "EXECUTE_TX_DB_UPDATE",
-            messageRowIds,
-            txId,
-            txHash,
-            messageIds: [],
-            packetIds: [],
-        });
-        // update execute status
-        if (messageRowIds.length > 0)
-            await models_1.Message.update({
-                executeTxId: txId,
-                executeTxHash: txHash,
-                executeRelayStatus,
-            }, {
-                where: {
-                    id: {
-                        [sequelize_1.Op.in]: messageRowIds,
-                    },
-                },
-            });
-    }
-    catch (err) {
-        utils_1.logger.error(`Failed to update the transactionHash and isRelaying Status after proposeBatch call`, err);
-    }
-};
-const observeMetrics = (proposeRowIds, attestRowIds, messageRowIds, packetRowIdDetailsMap, messageRowIdDetailsMap) => {
-    proposeRowIds.map((rowId) => {
-        (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.proposeRelay.txDiffHistogram, {
-            labels: {
-                [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: packetRowIdDetailsMap[rowId].srcChainSlug,
-                [prometheus_config_1.Labels.DST_CHAIN_SLUG]: packetRowIdDetailsMap[rowId].dstChainSlug,
-                [prometheus_config_1.Labels.INTEGRATION_TYPE]: packetRowIdDetailsMap[rowId].integrationType,
-            },
-            timeDiff: (0, utils_2.currentTimestampInSeconds)() - packetRowIdDetailsMap[rowId].outboundTime,
-        });
-        const sealIndexTime = packetRowIdDetailsMap[rowId].sealIndexTime;
-        // in case of arbitrum, sometimes we end up relaying propose before we get sealIndex request.
-        // to avoid adding such metrics, check for sealIndex value
-        if (sealIndexTime) {
-            (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.proposeRelay.relayerHistogram, {
-                labels: {
-                    [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: packetRowIdDetailsMap[rowId].srcChainSlug,
-                    [prometheus_config_1.Labels.DST_CHAIN_SLUG]: packetRowIdDetailsMap[rowId].dstChainSlug,
-                    [prometheus_config_1.Labels.INTEGRATION_TYPE]: packetRowIdDetailsMap[rowId].integrationType,
-                },
-                timeDiff: (0, utils_2.currentTimestampInSeconds)() - sealIndexTime,
-            });
-        }
-    });
-    attestRowIds.map((rowId) => {
-        (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.attestRelay.txDiffHistogram, {
-            labels: {
-                [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: packetRowIdDetailsMap[rowId].srcChainSlug,
-                [prometheus_config_1.Labels.DST_CHAIN_SLUG]: packetRowIdDetailsMap[rowId].dstChainSlug,
-                [prometheus_config_1.Labels.INTEGRATION_TYPE]: packetRowIdDetailsMap[rowId].integrationType,
-            },
-            timeDiff: (0, utils_2.currentTimestampInSeconds)() - packetRowIdDetailsMap[rowId].outboundTime,
-        });
-    });
-    messageRowIds.map((rowId) => {
-        (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.executeRelay.txDiffHistogram, {
-            labels: {
-                [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: messageRowIdDetailsMap[rowId].srcChainSlug,
-                [prometheus_config_1.Labels.DST_CHAIN_SLUG]: messageRowIdDetailsMap[rowId].dstChainSlug,
-                [prometheus_config_1.Labels.INTEGRATION_TYPE]: messageRowIdDetailsMap[rowId].integrationType,
-            },
-            timeDiff: (0, utils_2.currentTimestampInSeconds)() -
-                messageRowIdDetailsMap[rowId].outboundTime,
-        });
-    });
-};
-const getPacketProposalCountDbUpdates = (packetProposalCounts, packetMap) => {
-    const packetProposalCountDbUpdates = [];
-    for (const packetId in packetProposalCounts) {
-        if (packetMap[packetId].selectedProposalCount)
-            continue;
-        packetProposalCountDbUpdates.push({
-            packetId,
-            selectedProposalCount: packetProposalCounts[packetId].count,
-        });
-    }
-    return packetProposalCountDbUpdates;
-};
-const createMaps = (packets) => {
-    const packetIds = [];
-    const messageIds = [];
-    const packetMap = {};
-    const packetRowIdDetailsMap = {};
-    const messageRowIdDetailsMap = {};
-    packets.map((packet) => {
-        var _a, _b;
-        packetIds.push(packet.packetId);
-        const { integrationType, srcChainSlug, dstChainSlug, outboundTime, sealIndexTime, } = packet;
-        packetRowIdDetailsMap[packet.id] = {
-            outboundTime,
-            sealIndexTime,
-            srcChainSlug,
-            dstChainSlug,
-            integrationType,
-        };
-        packetMap[packet.packetId] = packet;
-        if ((_a = packet.Messages) === null || _a === void 0 ? void 0 : _a.length)
-            (_b = packet.Messages) === null || _b === void 0 ? void 0 : _b.map((message) => {
-                messageIds.push(message.messageId);
-                messageRowIdDetailsMap[message.id] = {
-                    outboundTime: message.outboundTime,
-                    srcChainSlug,
-                    dstChainSlug,
-                    integrationType,
-                };
-            });
-    });
-    return {
-        packetIds,
-        messageIds,
-        packetMap,
-        packetRowIdDetailsMap,
-        messageRowIdDetailsMap,
-    };
-};
-const sendBatch = async (batch, socketAddress, socketBatcher, chainSlug) => {
-    let isSuccessful = true;
-    let txHash = "";
-    let txId = "";
-    const { proposeBatchDataArgs, attestBatchDataArgs, executeBatchDataArgs, totalMsgValue, totalGasLimit, proposeRowIds, attestRowIds, messageRowIds, } = batch;
-    (0, utils_1.logInfo)({
-        info: "PROPOSE_RELAYING",
-        packetIds: proposeBatchDataArgs.map((p) => p[0]),
-        proposeBatchDataArgs,
-        attestBatchDataArgs,
-        executeBatchDataArgs,
-        proposeRowIds,
-        attestRowIds,
-        messageRowIds,
-        messageIds: [],
-    });
-    try {
-        if (proposeBatchDataArgs.length === 0 &&
-            attestBatchDataArgs.length === 0 &&
-            executeBatchDataArgs.length === 0) {
-            return { txId, txHash, isSuccessful: false };
-        }
-        const txn = await socketBatcher.sendBatch(socketAddress, 
-        // switchboardAddress, // this may change if we have multiple switchboards. this works only for
-        // fast switchboard case
-        [], // for sealBatch
-        proposeBatchDataArgs, attestBatchDataArgs, executeBatchDataArgs, {
-            gasLimit: totalGasLimit,
-            value: totalMsgValue.toHexString(),
-        });
-        txHash = txn.hash;
-        // @ts-expect-error
-        txId = txn.txId;
-        (0, utils_1.logInfo)({
-            info: "PROPOSE_RELAYED",
-            packetIds: proposeBatchDataArgs.map((p) => p[0]),
-            txHash,
-            txId,
-            messageIds: [],
-        });
-        //   metrics.map((m) => observeHistogram(metric.txDiffHistogram, m));
-        prometheus_config_1.relayMetrics.proposeRelay.counter.inc(proposeRowIds.length);
-        prometheus_config_1.relayMetrics.attestRelay.counter.inc(attestRowIds.length);
-        prometheus_config_1.relayMetrics.executeRelay.counter.inc(messageRowIds.length);
-    }
-    catch (err) {
-        (0, utils_1.logError)({
-            info: "PROPOSE_RELAY_FAILED",
-            packetIds: proposeBatchDataArgs.map((p) => p[0]),
-            reason: err,
-            messageIds: [],
-        });
-        isSuccessful = false;
-    }
-    return { txHash, txId, isSuccessful };
-};
-const savePacketUpdates = async (dbUpdates) => {
-    try {
-        (0, utils_1.logInfo)({
-            info: "SAVING_PROPOSAL_COUNT",
-            packetIds: dbUpdates.map((p) => p.packetId),
-            messageIds: [],
-        });
-        // TODO: fix this
-        // @ts-expect-error
-        await models_1.Packet.bulkCreate(dbUpdates, {
-            updateOnDuplicate: ["selectedProposalCount"],
-        });
-        (0, utils_1.logInfo)({
-            info: "SAVED_PROPOSAL_COUNT",
-            packetIds: dbUpdates.map((p) => p.packetId),
-            messageIds: [],
-        });
-    }
-    catch (error) {
-        utils_1.logger.error("Error while saving selectedProposalCount updates", error);
-        throw new Error(`Error while saving selectedProposalCount updates ${error === null || error === void 0 ? void 0 : error.message}`);
-    }
-};
-const checkAndPropose = async () => {
-    var _a, _b;
-    try {
-        // check if any pending message on any chain. If found, add message to queue
-        // and return.
-        const packetsPerChain = await (0, exports.getPendingProposePackets)(constants_1.supportedChainSlugs);
-        for (const chainSlug of constants_1.supportedChainSlugs) {
-            if (!((_a = packetsPerChain[chainSlug]) === null || _a === void 0 ? void 0 : _a.length))
-                continue;
-            // const messageIds = packetsPerChain[chainSlug].map((p) => {
-            //   if (!p.Messages) throw new Error("Message id not found!");
-            //   return p.Messages[0].messageId;
-            // });
-            (0, utils_1.logInfo)({
-                info: "QUEUING_PROPOSALS",
-                chainSlug,
-                packets: (_b = packetsPerChain[chainSlug]) === null || _b === void 0 ? void 0 : _b.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_PROPOSE,
-                data: { counter: Math.floor(Math.random() * 100) },
-            });
-            (0, utils_1.logInfo)({
-                info: "QUEUED_PROPOSALS",
-                packetIds: packetsPerChain[chainSlug].map((p) => p.packetId),
-                messageIds: [],
-            });
-            // @review why break?
-            break;
-        }
-    }
-    catch (error) {
-        console.log("error in checkAndPropose: ", error);
-    }
-};
-exports.checkAndPropose = checkAndPropose;

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[]>;