@socket.tech/dl-common 1.0.6 → 1.0.7

package/dist/src/handlers/cronHandler.js

@@ -0,0 +1,268 @@
+"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.setCronSpeedHandler = exports.cronHandler = exports.setCronSpeed = exports.getCronSpeed = void 0;
+const utils_1 = require("../utils");
+const common_1 = require("./common");
+const executeService_1 = require("../services/executeService");
+const cacheService = __importStar(require("../../dl-common/services/cacheService"));
+const relayers_1 = require("../relayers");
+const statusTrackers_1 = require("../statusTrackers");
+const constants_1 = require("../constants");
+const dl_common_1 = require("../../dl-common");
+const ll_common_1 = require("@socket.tech/ll-common");
+const isTimeToExecute = async (taskName, cronPeriod) => {
+    try {
+        const redisKey = "cron_" + taskName;
+        const flag = await cacheService.getKey(redisKey);
+        if (flag)
+            return false;
+        await cacheService.setKey(redisKey, "true", cronPeriod);
+        return true;
+    }
+    catch (error) {
+        console.log(error);
+        return false;
+    }
+};
+const executeTaskAtIntervals = async (taskName, data, delays) => {
+    const queueDataArray = new Array(delays.length).fill({
+        type: taskName,
+        data,
+    });
+    (0, utils_1.logInfo)({
+        info: "QUEUEING_TASKS",
+        timestamp: Date.now(),
+        queueDataArray,
+        delays,
+        messageIds: [],
+        packetIds: [],
+    });
+    await (0, dl_common_1.sendStandardBatchMessages)(constants_1.SQS_BASE_URL + constants_1.QueueName.BATCHER_TASK_QUEUE, queueDataArray, delays);
+    (0, utils_1.logInfo)({
+        info: "QUEUED_TASKS",
+        timestamp: Date.now(),
+        queueDataArray,
+        delays,
+        messageIds: [],
+        packetIds: [],
+    });
+};
+var CRON_SPEED;
+(function (CRON_SPEED) {
+    CRON_SPEED["SLOW"] = "SLOW";
+    // MEDIUM = "MEDIUM",
+    CRON_SPEED["FAST"] = "FAST";
+    // VERY_FAST = "VERY_FAST",
+})(CRON_SPEED || (CRON_SPEED = {}));
+var CRON_FUNCTIONS;
+(function (CRON_FUNCTIONS) {
+    CRON_FUNCTIONS["sendRetrySimulationRequest"] = "sendRetrySimulationRequest";
+    CRON_FUNCTIONS["sendPendingSimulationRequest"] = "sendPendingSimulationRequest";
+    CRON_FUNCTIONS["checkAndPropose"] = "checkAndPropose";
+    CRON_FUNCTIONS["checkAndSeal"] = "checkAndSeal";
+    CRON_FUNCTIONS["statusUpdate"] = "statusUpdate";
+    CRON_FUNCTIONS["checkAndUpdateFullyExecutedStatus"] = "checkAndUpdateFullyExecutedStatus";
+})(CRON_FUNCTIONS || (CRON_FUNCTIONS = {}));
+const CRON_DURATION = {
+    [CRON_SPEED.SLOW]: {
+        [CRON_FUNCTIONS.sendRetrySimulationRequest]: 10 * 60,
+        [CRON_FUNCTIONS.sendPendingSimulationRequest]: 5 * 60,
+        [CRON_FUNCTIONS.checkAndPropose]: 5 * 60,
+        [CRON_FUNCTIONS.checkAndSeal]: 5 * 60,
+        [CRON_FUNCTIONS.statusUpdate]: 5 * 60,
+        [CRON_FUNCTIONS.checkAndUpdateFullyExecutedStatus]: 10 * 60,
+    },
+    [CRON_SPEED.FAST]: {
+        [CRON_FUNCTIONS.sendRetrySimulationRequest]: 30,
+        [CRON_FUNCTIONS.sendPendingSimulationRequest]: 30,
+        [CRON_FUNCTIONS.checkAndPropose]: 30,
+        [CRON_FUNCTIONS.checkAndSeal]: 30,
+        [CRON_FUNCTIONS.statusUpdate]: 30,
+        [CRON_FUNCTIONS.checkAndUpdateFullyExecutedStatus]: 30,
+    },
+};
+const STATUS_UPDATE_INTERVALS = {
+    [CRON_SPEED.SLOW]: [0],
+    // [CRON_SPEED.MEDIUM]:[30],
+    // [CRON_SPEED.FAST]: [0],
+    [CRON_SPEED.FAST]: [0, 30],
+};
+const redisKey = "cronSpeed";
+const defaultSpeed = CRON_SPEED.FAST;
+const getCronSpeed = async () => {
+    let cronSpeed = await cacheService.getKey(redisKey);
+    if (!cronSpeed) {
+        await cacheService.setKey(redisKey, defaultSpeed);
+        cronSpeed = defaultSpeed;
+    }
+    return cronSpeed;
+};
+exports.getCronSpeed = getCronSpeed;
+const setCronSpeed = async (cronSpeed) => {
+    if (!Object.values(CRON_SPEED).includes(cronSpeed))
+        throw (0, dl_common_1.BadRequestError)("Invalid cron speed");
+    await cacheService.setKey(redisKey, cronSpeed);
+};
+exports.setCronSpeed = setCronSpeed;
+const cronHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        (0, utils_1.logInfo)({
+            info: "CRON_HANDLER_STARTED",
+            timestamp: Date.now(),
+            messageIds: [],
+            packetIds: [],
+        });
+        await (0, common_1.initServices)();
+        const cronSpeed = await (0, exports.getCronSpeed)();
+        const cronDuration = CRON_DURATION[cronSpeed];
+        // this helps to execute several tasks at different intervals without
+        // having to create a new handler every time.
+        if (await isTimeToExecute(CRON_FUNCTIONS.sendRetrySimulationRequest, cronDuration[CRON_FUNCTIONS.sendRetrySimulationRequest])) {
+            (0, utils_1.logInfo)({
+                info: `CRON_STARTED_${CRON_FUNCTIONS.sendRetrySimulationRequest}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+            await (0, executeService_1.sendRetrySimulationRequest)();
+            (0, utils_1.logInfo)({
+                info: `CRON_ENDED_${CRON_FUNCTIONS.sendRetrySimulationRequest}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+        }
+        if (await isTimeToExecute(CRON_FUNCTIONS.sendPendingSimulationRequest, cronDuration.sendPendingSimulationRequest)) {
+            (0, utils_1.logInfo)({
+                info: `CRON_STARTED_${CRON_FUNCTIONS.sendPendingSimulationRequest}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+            await (0, executeService_1.sendPendingSimulationRequest)();
+            (0, utils_1.logInfo)({
+                info: `CRON_ENDED_${CRON_FUNCTIONS.sendPendingSimulationRequest}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+        }
+        if (await isTimeToExecute(CRON_FUNCTIONS.checkAndPropose, cronDuration.checkAndPropose)) {
+            (0, utils_1.logInfo)({
+                info: `CRON_STARTED_${CRON_FUNCTIONS.checkAndPropose}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+            await (0, relayers_1.checkAndPropose)();
+            (0, utils_1.logInfo)({
+                info: `CRON_ENDED_${CRON_FUNCTIONS.checkAndPropose}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+        }
+        if (await isTimeToExecute(CRON_FUNCTIONS.checkAndSeal, cronDuration.checkAndSeal)) {
+            (0, utils_1.logInfo)({
+                info: `CRON_STARTED_${CRON_FUNCTIONS.checkAndSeal}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+            await (0, relayers_1.checkAndSeal)();
+            (0, utils_1.logInfo)({
+                info: `CRON_ENDED_${CRON_FUNCTIONS.checkAndSeal}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+        }
+        if (await isTimeToExecute(CRON_FUNCTIONS.statusUpdate, cronDuration.statusUpdate)) {
+            (0, utils_1.logInfo)({
+                info: `CRON_STARTED_${CRON_FUNCTIONS.statusUpdate}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+            await (0, statusTrackers_1.checkAndUpdateStatus)();
+            (0, utils_1.logInfo)({
+                info: `CRON_ENDED_${CRON_FUNCTIONS.statusUpdate}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+        }
+        if (await isTimeToExecute(CRON_FUNCTIONS.checkAndUpdateFullyExecutedStatus, cronDuration.checkAndUpdateFullyExecutedStatus)) {
+            (0, utils_1.logInfo)({
+                info: `CRON_STARTED_${CRON_FUNCTIONS.checkAndUpdateFullyExecutedStatus}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+            await (0, statusTrackers_1.checkAndUpdateFullyExecutedStatus)();
+            (0, utils_1.logInfo)({
+                info: `CRON_ENDED_${CRON_FUNCTIONS.checkAndUpdateFullyExecutedStatus}`,
+                timestamp: Date.now(),
+                messageIds: [],
+                packetIds: [],
+            });
+        }
+        // const start = Date.now();
+        // await pushToGateway();
+        // console.log("pushed to gateway in ", Date.now() - start, "ms");
+        // await attesterDBInst.close();
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+    }
+};
+exports.cronHandler = cronHandler;
+const setCronSpeedHandler = async (event, context) => {
+    var _a;
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        if (!event.queryStringParameters) {
+            throw (0, dl_common_1.BadRequestError)("No query string params found");
+        }
+        const speed = (_a = event.queryStringParameters) === null || _a === void 0 ? void 0 : _a.speed;
+        await (0, common_1.initServices)();
+        (0, utils_1.logInfo)({
+            info: "CRON_SPEED_SETTING",
+            speed,
+            messageIds: [],
+            packetIds: [],
+        });
+        await (0, exports.setCronSpeed)(speed);
+        (0, utils_1.logInfo)({ info: "CRON_SPEED_SET", messageIds: [], packetIds: [] });
+        return (0, ll_common_1.buildResponse)(200, { status: dl_common_1.StatusCodes.SUCCESS });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.setCronSpeedHandler = setCronSpeedHandler;

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

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

package/dist/src/handlers/executeHandler.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simulationHandler = exports.simulationResponseHandler = void 0;
+const ll_common_1 = require("@socket.tech/ll-common");
+const utils_1 = require("../utils");
+const executeService_1 = require("../services/executeService");
+const common_1 = require("./common");
+const dl_common_1 = require("../../dl-common");
+const simulationResponseHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        if (!event.body) {
+            throw (0, dl_common_1.BadRequestError)("No request data found");
+        }
+        const data = JSON.parse(event.body);
+        // console.log({ data });
+        if (!(data === null || data === void 0 ? void 0 : data.result)) {
+            throw (0, dl_common_1.BadRequestError)("No result field found");
+        }
+        await (0, common_1.initServices)();
+        sanitizeData(data === null || data === void 0 ? void 0 : data.result);
+        await (0, executeService_1.saveMessageSimulationResponse)(data === null || data === void 0 ? void 0 : data.result);
+        // const start = Date.now();
+        // await pushToGateway();
+        // console.log("pushed to gateway in ", Date.now() - start, "ms");
+        return (0, ll_common_1.buildResponse)(200, { status: dl_common_1.StatusCodes.SUCCESS });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.simulationResponseHandler = simulationResponseHandler;
+const simulationHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        await (0, common_1.initServices)();
+        await (0, executeService_1.sendPendingSimulationRequest)();
+        return (0, ll_common_1.buildResponse)(200, { status: dl_common_1.StatusCodes.SUCCESS });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.simulationHandler = simulationHandler;
+const sanitizeData = (dataArray) => {
+    dataArray.forEach((data) => {
+        const { messageId, retry, inboundSuccess, inboundRevertString, executeSignature, executeMsgGasLimit, } = data;
+        (0, dl_common_1.checkMissingFieldsAndType)({
+            messageId,
+            retry,
+            inboundSuccess,
+            inboundRevertString,
+            executeSignature,
+            executeMsgGasLimit,
+        }, {
+            messageId: "string",
+            retry: "boolean",
+            inboundSuccess: "boolean",
+            inboundRevertString: "string",
+            executeSignature: "string",
+            executeMsgGasLimit: "string",
+        });
+    });
+};

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

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

package/dist/src/handlers/handler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeHandler = void 0;
+const routes_1 = require("./routes");
+const common_1 = require("./common");
+const index_1 = require("../../dl-common/index");
+const routeHandler = async (event, context) => {
+    try {
+        // console.log("event",event);
+        console.log("event.resource", event.path, "method: ", event.httpMethod);
+        if (event.httpMethod == "GET") {
+            return await routes_1.getRequestRoutes[event.path](event, context);
+        }
+        else if (event.httpMethod == "POST") {
+            return await routes_1.postRequestRoutes[event.path](event, context);
+        }
+        // } else if (event.httpMethod == "PUT") {
+        //     return await putRequestRoutes[event.path](event);
+        // } else if (event.httpMethod == "DELETE") {
+        //     return await deleteRequestRoutes[event.path](event);
+        // }
+    }
+    catch (e) {
+        console.log("e", e);
+        const error = new index_1.ServerError(index_1.StatusCodes.NOT_FOUND, "resource not found");
+        return (0, common_1.buildErrorResponse)(error);
+    }
+};
+exports.routeHandler = routeHandler;

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

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

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