@socket.tech/dl-common 1.0.6 → 1.0.7

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

package/dist/src/handlers/testHandler.js

@@ -0,0 +1,99 @@
+"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.chainSupportHandler = exports.deleteKeyHandler = exports.main = void 0;
+/* eslint-disable @typescript-eslint/no-throw-literal */
+const ll_common_1 = require("@socket.tech/ll-common");
+const utils_1 = require("../utils");
+const common_1 = require("./common");
+const cacheService = __importStar(require("../../dl-common/services/cacheService"));
+const dl_common_1 = require("../../dl-common");
+const constants_1 = require("../constants");
+const main = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        await (0, common_1.initServices)();
+        console.log("services initialized");
+        const gasPrice = await (0, utils_1.getRPCGasPrice)(647);
+        const packet = await dl_common_1.Packet.findOne({
+            attributes: ["packetId", "srcChainSlug"],
+        });
+        console.log("db working");
+        await cacheService.setKey("test", "testValue", 60);
+        const cacheRespose = await cacheService.getKey("test");
+        console.log("cache working");
+        // relayMetrics.proposeRelay.counter.inc();
+        // await sendToDiscordWebhook("Test Message", {
+        //   chain: ChainSlug.OPTIMISM,
+        //   currentBalance: 90,
+        //   threshold: 100,
+        // });
+        // console.log("discord working");
+        const response = { message: "API working", packet, cacheRespose, gasPrice };
+        // const response = { message: "API working" };
+        // await pushToGateway();
+        return (0, ll_common_1.buildResponse)(200, { status: dl_common_1.StatusCodes.SUCCESS, response });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.main = main;
+const deleteKeyHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        await (0, common_1.initServices)();
+        if (!(event === null || event === void 0 ? void 0 : event.body))
+            throw (0, dl_common_1.BadRequestError)("No request data found");
+        const { key } = JSON.parse(event === null || event === void 0 ? void 0 : event.body);
+        await cacheService.deleteKey(key);
+        const response = { message: "key deleted" };
+        return (0, ll_common_1.buildResponse)(200, { status: dl_common_1.StatusCodes.SUCCESS, response });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.deleteKeyHandler = deleteKeyHandler;
+const chainSupportHandler = async (event, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    try {
+        await (0, common_1.initServices)();
+        if (!(event === null || event === void 0 ? void 0 : event.body))
+            throw (0, dl_common_1.BadRequestError)("No request data found");
+        const { chainSlug } = JSON.parse(event === null || event === void 0 ? void 0 : event.body);
+        if (constants_1.supportedChainSlugs.includes(Number(chainSlug)))
+            return (0, ll_common_1.buildResponse)(200, { status: "supported" });
+        else
+            return (0, ll_common_1.buildResponse)(200, { status: "not supported" });
+    }
+    catch (e) {
+        utils_1.logger.error("Error", e);
+        return (0, common_1.buildErrorResponse)(e);
+    }
+};
+exports.chainSupportHandler = chainSupportHandler;

package/dist/src/main.js

@@ -0,0 +1,12 @@
+"use strict";
+// #!/usr/bin/env node
+// import express from 'express';
+// import { estimateFees, getMessageDetails, getMessagesFromSrcTx } from './controllers';
+// const app = express();
+// const port = 3000;
+// app.get('/message', getMessageDetails);
+// app.get('/messages-from-tx', getMessagesFromSrcTx);
+// app.get('/estimate-fees', estimateFees);
+// app.listen(port, () => {
+//   console.log(`Example app listening on port ${port}`);
+// });

package/dist/src/relayers/common.d.ts

@@ -0,0 +1,7 @@
+import { type ChainSlug } from "@socket.tech/dl-core";
+import { Contract } from "ethers";
+export declare const getSocketBatcher: (chainSlug: ChainSlug, metadata: object, sequential?: boolean) => Promise<Contract>;
+export declare const getSocket: (chainSlug: ChainSlug, metadata: object, sequential?: boolean) => Promise<Contract>;
+export declare const getFastSwitchboard: (chainSlug: ChainSlug, metadata: object, sequential?: boolean) => Promise<Contract>;
+export declare const getSocketAddress: (chainSlug: ChainSlug) => string;
+export declare const getFastSwitchboardAddress: (chainSlug: ChainSlug) => string;

package/dist/src/relayers/common.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFastSwitchboardAddress = exports.getSocketAddress = exports.getFastSwitchboard = exports.getSocket = exports.getSocketBatcher = void 0;
+const constants_1 = require("../constants");
+const SocketBatcher_json_1 = __importDefault(require("@socket.tech/dl-core/artifacts/abi/SocketBatcher.json"));
+const Socket_json_1 = __importDefault(require("@socket.tech/dl-core/artifacts/abi/Socket.json"));
+const FastSwitchboard_json_1 = __importDefault(require("@socket.tech/dl-core/artifacts/abi/FastSwitchboard.json"));
+const ethers_1 = require("ethers");
+const utils_1 = require("../../dl-common/utils");
+const getSocketBatcher = async (chainSlug, metadata, sequential = false) => {
+    var _a;
+    const relaySigner = new utils_1.SocketRelaySigner((0, constants_1.getProvider)(chainSlug), constants_1.ChainSlugToId[chainSlug], (0, constants_1.relayUrl)(), constants_1.relayerAPIKey, sequential, false, metadata);
+    const socketBatcherAddress = (_a = constants_1.addresses[chainSlug]) === null || _a === void 0 ? void 0 : _a.SocketBatcher;
+    if (!socketBatcherAddress) {
+        throw new Error("Socket batcher Address not present for chain: " + chainSlug);
+    }
+    const socketBatcher = new ethers_1.Contract(socketBatcherAddress, SocketBatcher_json_1.default, relaySigner);
+    return socketBatcher;
+};
+exports.getSocketBatcher = getSocketBatcher;
+const getSocket = async (chainSlug, metadata, sequential = false) => {
+    const relaySigner = new utils_1.SocketRelaySigner((0, constants_1.getProvider)(chainSlug), constants_1.ChainSlugToId[chainSlug], (0, constants_1.relayUrl)(), constants_1.relayerAPIKey, sequential, false, metadata);
+    const socketAddress = (0, exports.getSocketAddress)(chainSlug);
+    const socket = new ethers_1.Contract(socketAddress, Socket_json_1.default, relaySigner);
+    return socket;
+};
+exports.getSocket = getSocket;
+const getFastSwitchboard = async (chainSlug, metadata, sequential = false) => {
+    const relaySigner = new utils_1.SocketRelaySigner((0, constants_1.getProvider)(chainSlug), constants_1.ChainSlugToId[chainSlug], (0, constants_1.relayUrl)(), constants_1.relayerAPIKey, sequential, false, metadata);
+    const fastSwitchboardAddress = (0, exports.getFastSwitchboardAddress)(chainSlug);
+    const fastSwitchboard = new ethers_1.Contract(fastSwitchboardAddress, FastSwitchboard_json_1.default, relaySigner);
+    return fastSwitchboard;
+};
+exports.getFastSwitchboard = getFastSwitchboard;
+const getSocketAddress = (chainSlug) => {
+    var _a;
+    const socketAddress = (_a = constants_1.addresses[chainSlug]) === null || _a === void 0 ? void 0 : _a.Socket;
+    if (!socketAddress) {
+        throw new Error("socket Address not present for chain: " + chainSlug);
+    }
+    return socketAddress;
+};
+exports.getSocketAddress = getSocketAddress;
+const getFastSwitchboardAddress = (chainSlug) => {
+    var _a;
+    const fastSwitchboardAddress = (_a = constants_1.addresses[chainSlug]) === null || _a === void 0 ? void 0 : _a.FastSwitchboard;
+    if (!fastSwitchboardAddress) {
+        throw new Error("fastSwitchboardAddress not present for chain: " + chainSlug);
+    }
+    return fastSwitchboardAddress;
+};
+exports.getFastSwitchboardAddress = getFastSwitchboardAddress;

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

@@ -0,0 +1,2 @@
+export * from "./sealRelayer";
+export * from "./proposeRelayer";