@socket.tech/dl-common 1.0.4-test.1 → 1.0.4-test.2

package/dist/src/handlers/proposeHandler.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateProposalCountHandler = exports.relayProposeHandler = void 0;
+const ll_common_1 = require("@socket.tech/ll-common");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const common_1 = require("./common");
+const prometheus_config_1 = require("../constants/prometheus.config");
+const index_1 = require("../../dl-common/index");
+const relayProposeHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        if (!event.body) {
+            throw (0, index_1.BadRequestError)("No request data found");
+        }
+        const { chainSlug } = JSON.parse(event.body);
+        await (0, common_1.initServices)();
+        await (0, index_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: "PROPOSED_RELAY_QUEUED",
+            timestamp: Date.now(),
+            messageIds: [],
+            packetIds: [],
+        });
+        const response = { message: "Relay Propose task added to queue" };
+        await (0, prometheus_config_1.pushToGateway)();
+        return (0, ll_common_1.buildResponse)(200, { status: index_1.StatusCodes.SUCCESS, response });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.relayProposeHandler = relayProposeHandler;
+const updateProposalCountHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        if (!event.body) {
+            throw (0, index_1.BadRequestError)("No request data found");
+        }
+        const { chainSlug } = JSON.parse(event.body);
+        await (0, common_1.initServices)();
+        await (0, index_1.sendStandardSqsMessage)(constants_1.SQS_BASE_URL + constants_1.QueueName.BATCHER_TASK_QUEUE, {
+            type: constants_1.TaskNames.UPDATE_SELECTED_PROPOSAL_COUNT,
+            data: {
+                chainSlug,
+            },
+        });
+        const response = {
+            message: "UPDATE_SELECTED_PROPOSAL_COUNT task added to queue",
+        };
+        (0, utils_1.logInfo)({
+            info: "PROPOSAL_COUNT_UPDATE_QUEUED",
+            timestamp: Date.now(),
+            messageIds: [],
+            packetIds: [],
+        });
+        await (0, prometheus_config_1.pushToGateway)();
+        return (0, ll_common_1.buildResponse)(200, { status: index_1.StatusCodes.SUCCESS, response });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.updateProposalCountHandler = updateProposalCountHandler;

package/dist/src/handlers/routes.d.ts

@@ -0,0 +1,2 @@
+export declare const getRequestRoutes: Record<string, (event: any, context: any) => Promise<any>>;
+export declare const postRequestRoutes: Record<string, (event: any, context: any) => Promise<any>>;

package/dist/src/handlers/routes.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postRequestRoutes = exports.getRequestRoutes = void 0;
+const sealHandler_1 = require("./sealHandler");
+const proposeHandler_1 = require("./proposeHandler");
+const executeHandler_1 = require("./executeHandler");
+const statusHandler_1 = require("./statusHandler");
+const testHandler_1 = require("./testHandler");
+const cronHandler_1 = require("./cronHandler");
+exports.getRequestRoutes = {
+    "/statusUpdate": statusHandler_1.statusUpdateHandler,
+    "/setCronSpeed": cronHandler_1.setCronSpeedHandler,
+    "/simulate": executeHandler_1.simulationHandler,
+};
+exports.postRequestRoutes = {
+    "/seal": sealHandler_1.sealHandler,
+    "/relaySeal": sealHandler_1.relaySealHandler,
+    "/indexSeal": sealHandler_1.indexSealHandler,
+    "/relayPropose": proposeHandler_1.relayProposeHandler,
+    "/simulationResponse": executeHandler_1.simulationResponseHandler,
+    "/deleteRedisKey": testHandler_1.deleteKeyHandler,
+    "/updateProposalCount": proposeHandler_1.updateProposalCountHandler,
+    "/txStatusUpdate": statusHandler_1.relayerTxStatusUpdateHandler,
+    "/isChainSupported": testHandler_1.chainSupportHandler,
+    "/failedStatusUpdate": statusHandler_1.failedStatusUpdateHandler,
+};

package/dist/src/handlers/sealHandler.d.ts

@@ -0,0 +1,4 @@
+import { type APIGatewayProxyEvent, type APIGatewayProxyResult, type Context } from "aws-lambda";
+export declare const sealHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;
+export declare const relaySealHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;
+export declare const indexSealHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;

package/dist/src/handlers/sealHandler.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexSealHandler = exports.relaySealHandler = exports.sealHandler = void 0;
+const ll_common_1 = require("@socket.tech/ll-common");
+const utils_1 = require("../utils");
+const sealService_1 = require("../services/sealService");
+const sealRelayer_1 = require("../relayers/sealRelayer");
+const indexSealService_1 = require("../services/indexSealService");
+const common_1 = require("./common");
+const index_1 = require("../../dl-common/index");
+const constants_1 = require("../constants");
+const dl_core_1 = require("@socket.tech/dl-core");
+const sealHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        if (!event.body) {
+            throw (0, index_1.BadRequestError)("No request data found");
+        }
+        const data = JSON.parse(event.body);
+        const { sealRequests } = data;
+        if (!(sealRequests === null || sealRequests === void 0 ? void 0 : sealRequests.length)) {
+            throw (0, index_1.BadRequestError)("no seal requests found");
+        }
+        await (0, common_1.initServices)();
+        sanitizeSealData(sealRequests);
+        const response = await (0, sealService_1.seal)(sealRequests);
+        return (0, ll_common_1.buildResponse)(200, { status: index_1.StatusCodes.SUCCESS, response });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.sealHandler = sealHandler;
+const relaySealHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        if (!event.body) {
+            throw (0, index_1.BadRequestError)("No request data found");
+        }
+        const { chainSlug } = JSON.parse(event.body);
+        await (0, common_1.initServices)();
+        const response = await (0, sealRelayer_1.relaySeal)(chainSlug);
+        return (0, ll_common_1.buildResponse)(200, { status: index_1.StatusCodes.SUCCESS, response });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.relaySealHandler = relaySealHandler;
+const indexSealHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        if (!event.body) {
+            throw (0, index_1.BadRequestError)("No request data found");
+        }
+        const data = JSON.parse(event.body);
+        const { sealIndexedUpdates } = data;
+        if (!(sealIndexedUpdates === null || sealIndexedUpdates === void 0 ? void 0 : sealIndexedUpdates.length)) {
+            throw (0, index_1.BadRequestError)("no seal index updates found");
+        }
+        await (0, common_1.initServices)();
+        sanitizeIndexSealData(sealIndexedUpdates);
+        const response = await (0, indexSealService_1.indexSeal)(sealIndexedUpdates);
+        return (0, ll_common_1.buildResponse)(200, { status: index_1.StatusCodes.SUCCESS, response });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.indexSealHandler = indexSealHandler;
+const sanitizeSealData = (dataArray) => {
+    dataArray.forEach((data, index) => {
+        const { srcChainSlug, dstChainSlug, integrationType } = data;
+        (0, index_1.checkObjectFieldsAndType)(data, {
+            srcChainSlug: "number",
+            dstChainSlug: "number",
+            dstSwitchboard: "string",
+            srcSwitchboard: "string",
+            integrationType: "string",
+            message: {
+                messageId: "string",
+                srcPlug: "string",
+                destPlug: "string",
+                minMsgGasLimit: "string",
+                executionParams: "string",
+                transmissionParams: "string",
+                executionFee: "string",
+                transmissionFees: "string",
+                switchboardFees: "string",
+                fees: "string",
+                decapacitorProof: "string",
+                payload: "string",
+                packedMessage: "string",
+                outboundTxHash: "string",
+                outboundTime: "number",
+                capacitorMsgCount: "string",
+            },
+            packet: {
+                capacitorPacketCount: "string",
+                packetId: "string",
+                srcCapacitor: "string",
+                root: "string",
+                sealSignature: "string",
+            },
+        }, `sealRequests.${index}`);
+        if (!data.packet.sealSignature)
+            throw (0, index_1.BadRequestError)("seal signature missing");
+        if (!constants_1.supportedChainSlugs.includes(srcChainSlug)) {
+            throw (0, index_1.BadRequestError)(`srcChainSlug ${srcChainSlug} not supported`);
+        }
+        // should not check this during seal api call, as a wrong dstChainSlug can
+        // stop transmitter sync for source chain
+        // if (!supportedChainSlugs.includes(dstChainSlug)) {
+        //   throw BadRequestError(`dstChainSlug ${dstChainSlug} not supported`);
+        // }
+        if (!Object.values(dl_core_1.IntegrationTypes).includes(integrationType)) {
+            throw (0, index_1.BadRequestError)("integrationType not supported");
+        }
+    });
+};
+// const sanitizeSealData = (dataArray: SealParams[]) => {
+// 	dataArray.forEach((data) => {
+// 		let {
+// 			message,
+// 			packet,
+// 			srcChainSlug,
+// 			dstChainSlug,
+// 			dstSwitchboard, // address
+// 			integrationType,
+// 		} = data;
+// 		checkMissingFieldsAndType({ message, packet }, { message:'object', packet:'object' });
+// 		let {
+// 			messageId,
+// 			srcPlug,
+// 			destPlug,
+// 			minMsgGasLimit,
+// 			executionParams,
+// 			transmissionParams,
+// 			executionFee,
+// 			transmissionFees,
+// 			switchboardFees,
+// 			fees,
+// 			decapacitorProof,
+// 			payload,
+// 			packedMessage,
+// 			outboundTxHash,
+// 			outboundTime,
+// 			capacitorMsgCount,
+// 		} = message;
+// 		let {
+// 			capacitorPacketCount,
+// 			rootHash,
+// 			packetId,
+// 			srcCapacitor,
+// 			root,
+// 			sealSignature,
+// 		} = packet;
+// 		checkMissingFieldsAndType(
+// 			{
+// 				srcChainSlug,
+// 				dstChainSlug,
+// 				dstSwitchboard,
+// 				messageId,
+// 				srcPlug,
+// 				destPlug,
+// 				minMsgGasLimit,
+// 				executionParams,
+// 				transmissionParams,
+// 				executionFee,
+// 				transmissionFees,
+// 				switchboardFees,
+// 				fees,
+// 				decapacitorProof,
+// 				payload,
+// 				packedMessage,
+// 				outboundTxHash,
+// 				outboundTime,
+// 				capacitorMsgCount,
+// 				capacitorPacketCount,
+// 				rootHash,
+// 				packetId,
+// 				srcCapacitor,
+// 				root,
+// 				sealSignature,
+// 			},
+// 			{
+// 				srcChainSlug: "number",
+// 				dstChainSlug: "number",
+// 				dstSwitchboard: "string",
+// 				messageId: "string",
+// 				srcPlug: "string",
+// 				destPlug: "string",
+// 				minMsgGasLimit: "string",
+// 				executionParams: "string",
+// 				transmissionParams: "string",
+// 				executionFee: "string",
+// 				transmissionFees: "string",
+// 				switchboardFees: "stri–ng",
+// 				fees: "string",
+// 				decapacitorProof: "string",
+// 				payload: "string",
+// 				packedMessage: "string",
+// 				outboundTxHash: "string",
+// 				outboundTime: "number",
+// 				capacitorMsgCount: "string",
+// 				capacitorPacketCount: "string",
+// 				rootHash: "string",
+// 				packetId: "string",
+// 				srcCapacitor: "string",
+// 				root: "string",
+// 				sealSignature: "string",
+// 			}
+// 		);
+// 		if (!supportedChainSlugs.includes(srcChainSlug)) {
+// 			throw BadRequestError("srcChainSlug not supported");
+// 		}
+//     if (!supportedChainSlugs.includes(dstChainSlug)) {
+// 			throw BadRequestError("dstChainSlug not supported");
+// 		}
+//     if (!(integrationType in IntegrationTypes)) {
+//       throw BadRequestError("integrationType not supported");
+//     }
+// 	});
+// };
+const sanitizeIndexSealData = (dataArray) => {
+    dataArray.forEach((data, index) => {
+        const { srcChainSlug } = data;
+        (0, index_1.checkObjectFieldsAndType)(data, {
+            srcChainSlug: "number",
+            sealer: "string",
+            sealTime: "number",
+            sealTxHash: "string",
+            rootSealed: "string",
+            dstSwitchboard: "string",
+            sealSignature: "string",
+            packetId: "string",
+        }, `sealIndexedUpdates.${index}`);
+        if (!constants_1.supportedChainSlugs.includes(srcChainSlug)) {
+            throw (0, index_1.BadRequestError)("srcChainSlug not supported");
+        }
+    });
+};

package/dist/src/handlers/statusHandler.d.ts

@@ -0,0 +1,5 @@
+import { type SQSEvent, type Context, type APIGatewayProxyEvent, type APIGatewayProxyResult } from "aws-lambda";
+export declare const statusHandler: (event: SQSEvent, context: Context) => Promise<void>;
+export declare const statusUpdateHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;
+export declare const failedStatusUpdateHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;
+export declare const relayerTxStatusUpdateHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;

package/dist/src/handlers/statusHandler.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayerTxStatusUpdateHandler = exports.failedStatusUpdateHandler = exports.statusUpdateHandler = exports.statusHandler = void 0;
+const utils_1 = require("../utils");
+const common_1 = require("./common");
+const packet_1 = require("../statusTrackers/packet");
+const message_1 = require("../statusTrackers/message");
+const ll_common_1 = require("@socket.tech/ll-common");
+const prometheus_config_1 = require("../constants/prometheus.config");
+const index_1 = require("../../dl-common/index");
+const constants_1 = require("../constants");
+const failedPacket_1 = require("../statusTrackers/failedPacket");
+const failedMessage_1 = require("../statusTrackers/failedMessage");
+const statusHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        await (0, common_1.initServices)();
+        await (0, packet_1.checkAndUpdatePacketRelayStatus)();
+        await (0, message_1.checkAndUpdateMessageRelayStatus)();
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+    }
+};
+exports.statusHandler = statusHandler;
+const statusUpdateHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        await (0, common_1.initServices)();
+        await (0, packet_1.checkAndUpdatePacketRelayStatus)();
+        await (0, message_1.checkAndUpdateMessageRelayStatus)();
+        const start = Date.now();
+        await (0, prometheus_config_1.pushToGateway)();
+        (0, utils_1.logInfo)({
+            info: "PUSHED_TO_GATEWAY",
+            time: Date.now() - start,
+            messageIds: [],
+            packetIds: [],
+        });
+        return (0, ll_common_1.buildResponse)(200, {
+            status: index_1.StatusCodes.SUCCESS,
+            message: "tx status updated",
+        });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.statusUpdateHandler = statusUpdateHandler;
+const failedStatusUpdateHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        if (event.body == null)
+            throw Error("body missing");
+        const { packetIds, messageIds, dryRun } = JSON.parse(event.body);
+        await (0, common_1.initServices)();
+        const packetResponse = await (0, failedPacket_1.checkFailedPackets)(packetIds, dryRun);
+        const messageResponse = await (0, failedMessage_1.checkFailedMessages)(messageIds, dryRun);
+        return (0, ll_common_1.buildResponse)(200, {
+            status: index_1.StatusCodes.SUCCESS,
+            message: "tx status updated",
+            packetResponse,
+            messageResponse,
+        });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.failedStatusUpdateHandler = failedStatusUpdateHandler;
+const relayerTxStatusUpdateHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        if (event.headers["x-api-key"] !== constants_1.relayerAPIKey) {
+            throw new index_1.ServerError(index_1.StatusCodes.UNAUTHORIZED, "invalid api key");
+        }
+        if (event.body == null) {
+            throw (0, index_1.BadRequestError)("No request data found");
+        }
+        const data = JSON.parse(event.body);
+        const { txStatusUpdates } = data;
+        if ((txStatusUpdates === null || txStatusUpdates === void 0 ? void 0 : txStatusUpdates.length) === 0) {
+            throw (0, index_1.BadRequestError)("no txStatusUpdates requests found");
+        }
+        sanitizeTxStatusUpdateData(txStatusUpdates);
+        await (0, common_1.initServices)();
+        await (0, packet_1.updatePacketTxStatus)(txStatusUpdates);
+        await (0, message_1.updateMessageTxStatus)(txStatusUpdates);
+        await (0, prometheus_config_1.pushToGateway)();
+        return (0, ll_common_1.buildResponse)(200, {
+            status: index_1.StatusCodes.SUCCESS,
+            message: "tx status updated",
+        });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.relayerTxStatusUpdateHandler = relayerTxStatusUpdateHandler;
+const sanitizeTxStatusUpdateData = (dataArray) => {
+    dataArray.forEach((data, index) => {
+        const { status } = data;
+        (0, index_1.checkObjectFieldsAndType)(data, {
+            chainId: "number",
+            txId: "string",
+            txHash: "string",
+            confirmations: "number",
+        }, `txStatusUpdates.${index}`);
+        if (!Object.values(index_1.RelayerAPIStatus).includes(status)) {
+            throw (0, index_1.BadRequestError)("relayer tx status not supported");
+        }
+    });
+};

package/dist/src/handlers/taskHandler.d.ts

@@ -0,0 +1,2 @@
+import { type SQSEvent, type Context } from "aws-lambda";
+export declare const taskHandler: (event: SQSEvent, context: Context) => Promise<void>;

package/dist/src/handlers/taskHandler.js

@@ -0,0 +1,110 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskHandler = void 0;
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const proposeRelayer_1 = require("../relayers/proposeRelayer");
+const common_1 = require("./common");
+const enums_1 = require("../constants/enums");
+const relayers_1 = require("../relayers");
+const executeService_1 = require("../services/executeService");
+const cacheService = __importStar(require("../../dl-common/services/cacheService"));
+const statusTrackers_1 = require("../statusTrackers");
+const proposalCheckService_1 = require("../services/proposalCheckService");
+const getLock = async (taskName, lockTime) => {
+    try {
+        const redisKey = "batcher_service_task_" + constants_1.deploymentMode + "_" + taskName;
+        const flag = await cacheService.lock(redisKey, lockTime);
+        return flag;
+    }
+    catch (error) {
+        console.log(error);
+        return false;
+    }
+};
+const releaseLock = async (taskName) => {
+    try {
+        const redisKey = "batcher_service_task_" + constants_1.deploymentMode + "_" + taskName;
+        const flag = await cacheService.unlock(redisKey);
+        return flag;
+    }
+    catch (error) {
+        console.log(error);
+        return false;
+    }
+};
+const checkLockAndExecute = async (taskName, lockTime, callback, args) => {
+    const success = await getLock(taskName, lockTime);
+    if (!success) {
+        (0, utils_1.logInfo)({
+            info: "TASK_ALREADY_RUNNING",
+            taskName,
+            messageIds: [],
+            packetIds: [],
+        });
+        return;
+    }
+    await callback(...args);
+    await releaseLock(taskName);
+};
+const taskHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        const { type, data } = JSON.parse(event.Records[0].body);
+        console.log("task received: ", type);
+        if (!type) {
+            console.log("type doesnt exist in task request");
+            return;
+        }
+        await (0, common_1.initServices)();
+        const { chainSlug } = data;
+        switch (type) {
+            case enums_1.TaskNames.RELAY_SEAL:
+                await checkLockAndExecute(enums_1.TaskNames.RELAY_SEAL, 5 * 60, relayers_1.relaySeal, [
+                    chainSlug,
+                ]);
+                break;
+            case enums_1.TaskNames.RELAY_PROPOSE:
+                await checkLockAndExecute(enums_1.TaskNames.RELAY_PROPOSE, 5 * 60, proposeRelayer_1.relayPropose, [chainSlug]);
+                break;
+            case enums_1.TaskNames.STATUS_UPDATE:
+                await (0, statusTrackers_1.checkAndUpdateStatus)();
+                break;
+            case enums_1.TaskNames.SIMULATE_MESSAGES:
+                await (0, executeService_1.sendPendingSimulationRequest)();
+                break;
+            case enums_1.TaskNames.UPDATE_SELECTED_PROPOSAL_COUNT:
+                await (0, proposalCheckService_1.updateSelectedProposalCountForPackets)(chainSlug);
+                break;
+            default:
+                break;
+        }
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+    }
+};
+exports.taskHandler = taskHandler;

package/dist/src/handlers/testHandler.d.ts

@@ -0,0 +1,4 @@
+import { type APIGatewayProxyEvent, type APIGatewayProxyResult, type Context } from "aws-lambda";
+export declare const main: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;
+export declare const deleteKeyHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;
+export declare const chainSupportHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;