@socket.tech/dl-common 1.0.16 → 1.0.17

package/dist/src/services/batcherService.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBatchDataArgs = exports.checkGasLimitAndAddToBatch = exports.calculateBatchGasLimit = void 0;
+const dl_core_1 = require("@socket.tech/dl-core");
+const constants_1 = require("../constants");
+const ethers_1 = require("ethers");
+const gasEstimation_1 = require("../constants/gasEstimation");
+const gasEstimationService_1 = require("./gasEstimationService");
+const common_1 = require("../relayers/common");
+const utils_1 = require("../utils");
+const calculateBatchGasLimit = async (dstChainSlug, currentBatch) => {
+    try {
+        const start = Date.now();
+        let totalGasLimit = 0;
+        const socketBatcher = await (0, common_1.getSocketBatcher)(dstChainSlug, {}, false);
+        const socketAddress = (0, common_1.getSocketAddress)(dstChainSlug);
+        (0, utils_1.logInfo)({
+            info: "ESTIMATING_GAS_PROPOSE_RELAY",
+            packetIds: currentBatch.proposeBatchDataArgs.map((a) => a[0]),
+            messageIds: [],
+        });
+        const proposeAttestGasEstimate = await socketBatcher.estimateGas.sendBatch(socketAddress, 
+        // switchboardAddress, // this may change if we have multiple switchboards. this works only for
+        // fast switchboard case
+        [], // for sealBatch
+        currentBatch.proposeBatchDataArgs, currentBatch.attestBatchDataArgs, [], {
+            value: currentBatch.totalMsgValue.toHexString(),
+        });
+        totalGasLimit += proposeAttestGasEstimate.toNumber();
+        for (const [executionDetails, messageDetails,] of currentBatch.executeBatchDataArgs) {
+            totalGasLimit += executionDetails[2].toNumber();
+        }
+        totalGasLimit = Math.floor(1.1 * totalGasLimit + 100000); // for safety
+        currentBatch.totalGasLimit = totalGasLimit;
+        (0, utils_1.logInfo)({
+            info: "FINAL_GAS_LIMIT",
+            totalGasLimit,
+            packetIds: currentBatch.proposeBatchDataArgs.map((a) => a[0]),
+            timeTaken: Date.now() - start,
+            messageIds: [],
+        });
+    }
+    catch (error) {
+        console.log("Error in calculateBatchGasLimit", error);
+    }
+    return currentBatch;
+};
+exports.calculateBatchGasLimit = calculateBatchGasLimit;
+const checkGasLimitAndAddToBatch = async (dstChainSlug, currentGasLimit, currentBatch, batchArgsArray) => {
+    const maxGasLimit = (0, gasEstimation_1.getMaxGasLimit)(dstChainSlug);
+    // console.log("maxGasLimit", maxGasLimit);
+    if (currentGasLimit > maxGasLimit) {
+        currentBatch = await (0, exports.calculateBatchGasLimit)(dstChainSlug, currentBatch);
+        // console.log(currentBatch.proposeRowIds, currentBatch.attestRowIds, currentBatch.messageRowIds);
+        batchArgsArray.push(currentBatch);
+        currentBatch = {
+            proposeBatchDataArgs: [],
+            attestBatchDataArgs: [],
+            executeBatchDataArgs: [],
+            totalMsgValue: ethers_1.BigNumber.from(0),
+            totalGasLimit: 0,
+            proposeRowIds: [],
+            attestRowIds: [],
+            messageRowIds: [],
+        };
+        currentGasLimit = 0;
+    }
+    return { currentGasLimit, batchArgsArray, currentBatch };
+};
+exports.checkGasLimitAndAddToBatch = checkGasLimitAndAddToBatch;
+const getBatchDataArgs = async (packets, packetAttestSignatures, packetProposalCounts) => {
+    let currentGasLimit = 0;
+    let packetGasLimit = 0;
+    let skip = false;
+    let batchArgsArray = [];
+    let currentBatch = {
+        proposeBatchDataArgs: [],
+        attestBatchDataArgs: [],
+        executeBatchDataArgs: [],
+        totalMsgValue: ethers_1.BigNumber.from(0),
+        totalGasLimit: 0,
+        proposeRowIds: [],
+        attestRowIds: [],
+        messageRowIds: [],
+    };
+    for (const packet of packets) {
+        // before start of every iteration, check if currentGasLimit is greater than
+        // maxGasLimit and reset packetGasLimit. Ignored on first iteration.
+        currentGasLimit += packetGasLimit;
+        ({ currentGasLimit, currentBatch, batchArgsArray } =
+            await (0, exports.checkGasLimitAndAddToBatch)(packet.dstChainSlug, currentGasLimit, currentBatch, batchArgsArray));
+        packetGasLimit = 0;
+        skip = false;
+        ({ currentBatch, packetGasLimit, skip } = await addProposeArgs(packet, currentBatch, packetGasLimit));
+        if (skip)
+            continue;
+        ({ currentBatch, packetGasLimit, skip } = await addAttestArgs(packet, packetAttestSignatures, packetProposalCounts, currentBatch, packetGasLimit));
+        if (skip)
+            continue;
+        if (!constants_1.executeRelayMode)
+            continue;
+        ({ currentBatch, packetGasLimit, skip } = await addExecuteArgs(packet, currentBatch, packetGasLimit, packetProposalCounts));
+        if (skip)
+            continue;
+    }
+    if (currentBatch.proposeBatchDataArgs.length > 0 ||
+        currentBatch.attestBatchDataArgs.length > 0 ||
+        currentBatch.executeBatchDataArgs.length > 0) {
+        currentBatch = await (0, exports.calculateBatchGasLimit)(packets[0].dstChainSlug, currentBatch);
+        batchArgsArray.push(currentBatch);
+    }
+    return batchArgsArray;
+};
+exports.getBatchDataArgs = getBatchDataArgs;
+const addProposeArgs = async (packet, currentBatch, packetGasLimit) => {
+    // If not proposed, and proposeRelayMode is also false, no point in continuing.
+    // If proposeRelayMode is false, but isProposed is true, we can still proceed if
+    // attest and execute is pending (and their relay mode is true)
+    if (!constants_1.proposeRelayMode && !packet.isProposed) {
+        return { currentBatch, packetGasLimit, skip: true };
+    }
+    if (!packet.isProposed) {
+        currentBatch.proposeBatchDataArgs.push([
+            packet.packetId,
+            packet.root,
+            packet.dstSwitchboard,
+            packet.sealSignature,
+        ]);
+        currentBatch.proposeRowIds.push(packet.id);
+        const proposeGasLimit = await (0, gasEstimationService_1.getProposeGasLimit)(packet.dstChainSlug);
+        packetGasLimit += proposeGasLimit;
+    }
+    return { currentBatch, packetGasLimit, skip: false };
+};
+const addAttestArgs = async (packet, packetAttestSignatures, packetProposalCounts, currentBatch, packetGasLimit) => {
+    // if fast integration type and not attested, and got enough signatures, add to attest batch.
+    // if not attested and didnt get enough signatures, continue from here.
+    // attestRelayMode check inside attestService. we get empty packetAttestSignatures
+    // and therefore no attestations, and no message execution(if attestation pending).
+    var _a;
+    if ([dl_core_1.IntegrationTypes.fast, dl_core_1.IntegrationTypes.fast2].includes(packet.integrationType) &&
+        !packet.isAttested) {
+        if ((_a = packetAttestSignatures[packet.packetId]) === null || _a === void 0 ? void 0 : _a.length) {
+            const attestGasLimit = await (0, gasEstimationService_1.getAttestGasLimit)(packet.dstChainSlug);
+            packetAttestSignatures[packet.packetId].map(async (signature) => {
+                currentBatch.attestBatchDataArgs.push([
+                    packet.dstSwitchboard,
+                    packet.packetId,
+                    packetProposalCounts[packet.packetId].count,
+                    packet.root,
+                    signature,
+                ]);
+                packetGasLimit += attestGasLimit;
+            });
+            currentBatch.attestRowIds.push(packet.id);
+        }
+        else {
+            // If not already attested, and didnt get enough signatures now as well, no point
+            // batching message execution. continue from here.
+            return { currentBatch, packetGasLimit, skip: true };
+        }
+    }
+    return { currentBatch, packetGasLimit, skip: false };
+};
+const addExecuteArgs = async (packet, currentBatch, packetGasLimit, packetProposalCounts) => {
+    // while getting isProposed false packets, we might get native packets
+    // with isVerified false, but valid message. skip their execution.
+    // wont appear in query again as soon as proposed.
+    if ([dl_core_1.IntegrationTypes.native, dl_core_1.IntegrationTypes.optimistic].includes(packet.integrationType) &&
+        !packet.isVerified)
+        return { currentBatch, packetGasLimit, skip: true };
+    const messages = packet.Messages;
+    if (messages === null || messages === void 0 ? void 0 : messages.length)
+        for (const message of messages) {
+            const { retry, messageId, executeMsgGasLimit, executeSignature, inboundSuccess, packetId, decapacitorProof, executionFee, minMsgGasLimit, executionParams, payload, id, } = message;
+            currentBatch.messageRowIds.push(id);
+            if (executionParams.slice(0, 4) !== "0x00") {
+                const msgValue = ethers_1.BigNumber.from("0x" + executionParams.slice(4));
+                currentBatch.totalMsgValue = currentBatch.totalMsgValue.add(msgValue);
+            }
+            currentBatch.executeBatchDataArgs.push([
+                // executionDetails,
+                [
+                    packetId,
+                    packetProposalCounts[packetId].count,
+                    ethers_1.BigNumber.from(executeMsgGasLimit),
+                    decapacitorProof,
+                    executeSignature,
+                ],
+                // msgDetails
+                [messageId, executionFee, minMsgGasLimit, executionParams, payload],
+            ]);
+            const executeGasLimit = ethers_1.BigNumber.from(executeMsgGasLimit).toNumber();
+            packetGasLimit += executeGasLimit;
+        }
+    return { currentBatch, packetGasLimit, skip: false };
+};

package/dist/src/services/executeService.d.ts

@@ -0,0 +1,16 @@
+import { type ChainSlug } from "@socket.tech/dl-core";
+import { type ExecuteSigResponse } from "../../dl-common/constants";
+export interface ExecuteSigRequest {
+    messageId: string;
+    destPlug: string;
+    srcPlug: string;
+    dstChainSlug: ChainSlug;
+    srcChainSlug: ChainSlug;
+    payload: string;
+    minMsgGasLimit: string;
+    executionParams: string;
+    packedMessage: string;
+}
+export declare const sendRetrySimulationRequest: () => Promise<void>;
+export declare const sendPendingSimulationRequest: () => Promise<void>;
+export declare const saveMessageSimulationResponse: (executeResponseData: ExecuteSigResponse[]) => Promise<void>;

package/dist/src/services/executeService.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveMessageSimulationResponse = exports.sendPendingSimulationRequest = exports.sendRetrySimulationRequest = void 0;
+const utils_1 = require("../../dl-common/utils");
+const utils_2 = require("../utils");
+const constants_1 = require("../constants");
+const models_1 = require("../../dl-common/models");
+const sequelize_1 = require("sequelize");
+const prometheus_config_1 = require("../constants/prometheus.config");
+const constants_2 = require("../../dl-common/constants");
+const ethers_1 = require("ethers");
+const sendRequest = async (messages) => {
+    const executeRequestData = [];
+    const start = Date.now();
+    for (const message of messages) {
+        executeRequestData.push({
+            messageId: message.messageId,
+            destPlug: message.destPlug,
+            srcPlug: message.srcPlug,
+            dstChainSlug: message.dstChainSlug,
+            srcChainSlug: message.srcChainSlug,
+            payload: message.payload,
+            minMsgGasLimit: message.minMsgGasLimit,
+            executionParams: message.executionParams,
+            packedMessage: message.packedMessage,
+        });
+    }
+    (0, utils_2.logInfo)({
+        info: "EXECUTOR_POST_API_CALLING",
+        messageIds: messages.map((m) => m.messageId),
+        start,
+        packetIds: [],
+    });
+    if (constants_1.EXECUTOR_URL) {
+        const response = await (0, utils_1.axiosPost)(constants_1.EXECUTOR_URL, { messageData: executeRequestData }, { headers: { "x-auth-token": constants_1.EXECUTOR_AUTH_TOKEN } });
+        (0, utils_2.logInfo)({
+            info: "EXECUTOR_POST_API_CALLED",
+            messageIds: messages.map((m) => m.messageId),
+            packetIds: [],
+            end: Date.now() - start,
+            response,
+        });
+    }
+    else {
+        // @review throw here?
+        console.log("Call to executor failed");
+    }
+};
+const sendRetrySimulationRequest = async () => {
+    try {
+        const messages = await getRetrySimulationMessages();
+        if (messages.length == 0)
+            return;
+        (0, utils_2.logInfo)({
+            info: "RETRY_SIMULATION_REQUEST",
+            msgCount: messages.length,
+            messageIds: messages.map((m) => m.messageId),
+            packetIds: [],
+        });
+        const messagesAsChunks = [...(0, utils_1.chunks)(messages, constants_1.executeBatchRelayLimit)];
+        for (const chunk of messagesAsChunks)
+            await sendRequest(chunk);
+    }
+    catch (error) {
+        console.log("error while sending retry simulation request: ", error);
+    }
+};
+exports.sendRetrySimulationRequest = sendRetrySimulationRequest;
+const sendPendingSimulationRequest = async () => {
+    try {
+        const messages = await getPendingSimulationMessages();
+        if (messages.length > 0) {
+            (0, utils_2.logInfo)({
+                info: "PENDING_SIMULATION_REQUEST",
+                msgCount: messages.length,
+                messageIds: messages.map((m) => m.messageId),
+                packetIds: [],
+            });
+            const messagesAsChunks = [...(0, utils_1.chunks)(messages, constants_1.executeBatchRelayLimit)];
+            for (const chunk of messagesAsChunks)
+                await sendRequest(chunk);
+            (0, utils_2.logInfo)({
+                info: "PENDING_SIMULATION_REQUEST_SENT",
+                messageIds: messages.map((m) => m.messageId),
+                packetIds: [],
+            });
+        }
+    }
+    catch (error) {
+        console.log("error while sendMessageSimulationRequest request: ", error);
+    }
+};
+exports.sendPendingSimulationRequest = sendPendingSimulationRequest;
+const saveMessageSimulationResponse = async (executeResponseData) => {
+    if (!(executeResponseData === null || executeResponseData === void 0 ? void 0 : executeResponseData.length))
+        return;
+    const messageIds = [];
+    executeResponseData.map((data) => {
+        messageIds.push(data.messageId);
+    });
+    const messages = await models_1.Message.findAll({
+        where: {
+            messageId: { [sequelize_1.Op.in]: messageIds },
+        },
+    });
+    const messageMap = new Map();
+    messages.forEach((message) => {
+        messageMap.set(message.messageId, message);
+    });
+    if (executeResponseData === null || executeResponseData === void 0 ? void 0 : executeResponseData.length) {
+        executeResponseData = executeResponseData.map((data) => {
+            var _a;
+            const firstSimulationTimestamp = Math.floor(Date.now() / 1000);
+            let executeRelayStatus = models_1.ExecutionRelayStatus.NO;
+            const MaxMsgGasLimit = (0, constants_1.getMaxMsgGasLimit)((_a = messageMap.get(data.messageId)) === null || _a === void 0 ? void 0 : _a.dstChainSlug);
+            // mark ignored if msgGasLimit mentioned is too big
+            if (ethers_1.BigNumber.from(data.executeMsgGasLimit).gt(MaxMsgGasLimit)) {
+                executeRelayStatus = models_1.ExecutionRelayStatus.IGNORED;
+            }
+            if (data.inboundRevertString === constants_2.ErrorReasons.ZERO_AMOUNT) {
+                executeRelayStatus = models_1.ExecutionRelayStatus.IGNORED;
+            }
+            return {
+                ...data,
+                firstSimulationTimestamp,
+                executeRelayStatus,
+            };
+        });
+        (0, utils_2.logInfo)({
+            info: "UPDATING_SIMULATION_STATES",
+            msgCount: executeResponseData.length,
+            messageIds: executeResponseData.map((m) => m.messageId),
+            packetIds: [],
+        });
+        await saveMessageUpdates(executeResponseData);
+        (0, utils_2.logInfo)({
+            info: "UPDATED_SIMULATION_STATES",
+            messageIds: executeResponseData.map((m) => m.messageId),
+            packetIds: [],
+        });
+    }
+    messages.forEach((message) => {
+        (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.executeRelay.signHistogram, {
+            labels: {
+                [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: message.srcChainSlug,
+                [prometheus_config_1.Labels.DST_CHAIN_SLUG]: message.dstChainSlug,
+            },
+            timeDiff: (0, utils_1.currentTimestampInSeconds)() - message.outboundTime,
+        });
+    });
+};
+exports.saveMessageSimulationResponse = saveMessageSimulationResponse;
+const saveMessageUpdates = async (dbUpdates) => {
+    try {
+        // TODO: fix this
+        // @ts-expect-error
+        await models_1.Message.bulkCreate(dbUpdates, {
+            updateOnDuplicate: [
+                "retry",
+                "inboundSuccess",
+                "inboundRevertString",
+                "firstSimulationTimestamp",
+                "executeSignature",
+                "executeMsgGasLimit",
+                "executeRelayStatus",
+            ],
+        });
+    }
+    catch (error) {
+        utils_2.logger.error("Error while saving execute signature updates", error);
+        throw new Error(`Error while saving execute signature  updates ${error === null || error === void 0 ? void 0 : error.message}`);
+    }
+};
+const getPendingSimulationMessages = async () => {
+    return await models_1.Message.findAll({
+        limit: constants_1.executeBatchQueryLimit,
+        where: {
+            isExecuted: false,
+            executeRelayStatus: {
+                [sequelize_1.Op.not]: models_1.ExecutionRelayStatus.IGNORED,
+            },
+            firstSimulationTimestamp: 0,
+        },
+        order: [["updatedAt", "ASC"]],
+    });
+};
+const getRetrySimulationMessages = async () => {
+    return await models_1.Message.findAll({
+        limit: constants_1.executeBatchQueryLimit,
+        where: {
+            isExecuted: false,
+            // already checked before, and within retry interval period
+            firstSimulationTimestamp: {
+                [sequelize_1.Op.gt]: Math.floor(Date.now() / 1000) - constants_1.retryInterval,
+            },
+            [sequelize_1.Op.or]: [
+                {
+                    inboundSuccess: false,
+                },
+                {
+                    retry: false,
+                },
+            ],
+            // ignore already executed, failed, executing, and ignored messages
+            executeRelayStatus: models_1.ExecutionRelayStatus.NO,
+        },
+        order: [["updatedAt", "ASC"]],
+    });
+};

package/dist/utils/address.d.ts

@@ -0,0 +1,2 @@
+export declare const checksum: (address: string) => string;
+export declare const toLowerCase: (address: string) => string;

package/dist/utils/address.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLowerCase = exports.checksum = void 0;
+const ethers_1 = require("ethers");
+const checksum = (address) => ethers_1.utils.getAddress(address);
+exports.checksum = checksum;
+const toLowerCase = (address) => address.toLowerCase();
+exports.toLowerCase = toLowerCase;

package/dist/utils/axios.d.ts

@@ -0,0 +1,2 @@
+export declare const axiosGet: (url: string, config?: {}, errorLogging?: boolean) => Promise<any>;
+export declare const axiosPost: (url: string, data: object, config?: {}, errorLogging?: boolean) => Promise<any>;

package/dist/utils/axios.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.axiosPost = exports.axiosGet = void 0;
+const axios_1 = __importDefault(require("axios"));
+const __1 = require("..");
+const axiosGet = async (url, config = {}, errorLogging = false) => {
+    var _a, _b, _c, _d;
+    if (!url)
+        throw (0, __1.InternalServerError)("GET request url not provided");
+    try {
+        const response = await axios_1.default.get(url, config);
+        return { success: true, ...response === null || response === void 0 ? void 0 : response.data };
+    }
+    catch (error) {
+        if (errorLogging) {
+            console.log("status : ", (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status);
+            console.log("error occurred, url : ", url, "\n error : ", error === null || error === void 0 ? void 0 : error.message, (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data);
+        }
+        return {
+            success: false,
+            status: (_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.status,
+            message: error === null || error === void 0 ? void 0 : error.message,
+            ...(_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.data,
+        };
+    }
+};
+exports.axiosGet = axiosGet;
+const axiosPost = async (url, data, config = {}, errorLogging = false) => {
+    var _a, _b, _c, _d;
+    if (!url)
+        throw (0, __1.InternalServerError)("POST request url not provided");
+    if (!data)
+        throw (0, __1.InternalServerError)("POST request data not provided");
+    try {
+        const response = await axios_1.default.post(url, data, config);
+        return { success: true, ...response === null || response === void 0 ? void 0 : response.data };
+    }
+    catch (error) {
+        if (errorLogging) {
+            console.log("status : ", (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status);
+            console.log("error occurred, url : ", url, "data : ", data, "\n error : ", error === null || error === void 0 ? void 0 : error.message, (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data);
+        }
+        return {
+            success: false,
+            message: error === null || error === void 0 ? void 0 : error.message,
+            status: (_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.status,
+            ...(_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.data,
+        };
+    }
+};
+exports.axiosPost = axiosPost;

package/dist/utils/dataStructHelper.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_PAYLOAD_SIZE: number;
+export declare function chunks<T>(arr: T[], n: number): Generator<T[], void>;

package/dist/utils/dataStructHelper.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PAYLOAD_SIZE = void 0;
+exports.chunks = chunks;
+exports.MAX_PAYLOAD_SIZE = 10 * 1024; // max is 24.5 kb, left some buffer for function and batch encoding
+function* chunks(arr, n) {
+    for (let i = 0; i < arr.length; i += n) {
+        yield arr.slice(i, i + n);
+    }
+}

package/dist/utils/discord.d.ts

@@ -0,0 +1,2 @@
+export declare const initDiscord: (webhookUrl_: string, serviceName_: string, discordDebugWebhookUrl_?: string | undefined) => void;
+export declare const sendToDiscordWebhook: (title: string, data: object, optionalConfig?: object, isDebug?: boolean) => Promise<void>;

package/dist/utils/discord.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToDiscordWebhook = exports.initDiscord = void 0;
+const __1 = require("..");
+const axios_1 = require("./axios");
+let discordWebhookUrl;
+let discordDebugWebhookUrl;
+let serviceName;
+const initDiscord = (webhookUrl_, serviceName_, discordDebugWebhookUrl_ = undefined) => {
+    discordWebhookUrl = webhookUrl_;
+    discordDebugWebhookUrl = discordDebugWebhookUrl_;
+    serviceName = serviceName_;
+};
+exports.initDiscord = initDiscord;
+const sendToDiscordWebhook = async (title, data, optionalConfig = {}, isDebug = false) => {
+    try {
+        if (!discordWebhookUrl) {
+            throw (0, __1.InternalServerError)("DISCORD_WEBHOOK_URL not provided");
+        }
+        if (isDebug && !discordDebugWebhookUrl) {
+            console.log("Debug mode enabled but no debug webhook provided");
+        }
+        let content = formatMsg(title, data);
+        const urlToUse = isDebug && discordDebugWebhookUrl
+            ? discordDebugWebhookUrl
+            : discordWebhookUrl;
+        await (0, axios_1.axiosPost)(urlToUse, { content, ...optionalConfig });
+    }
+    catch (error) {
+        throw error;
+    }
+};
+exports.sendToDiscordWebhook = sendToDiscordWebhook;
+const formatMsg = (title, data) => {
+    let message = `**${title}**\n`;
+    // Iterate through the object's key-value pairs
+    for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+            message += `${key}: ${data[key]}\n`;
+        }
+    }
+    return message;
+};

package/dist/utils/ethersAwsKmsSigner.d.ts

@@ -0,0 +1,2 @@
+import { KmsEthersSigner } from "./signer/kms-ethers-signer";
+export declare const getAwsKmsSigner: (keyId: string, region?: string) => Promise<KmsEthersSigner>;

package/dist/utils/ethersAwsKmsSigner.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAwsKmsSigner = void 0;
+const kms_ethers_signer_1 = require("./signer/kms-ethers-signer");
+const getAwsKmsSigner = async (keyId, region = "us-east-1") => {
+    try {
+        const kmsCredentials = {
+            kmsClientConfig: {
+                signingRegion: region,
+                region,
+            },
+            keyId,
+        };
+        let signer = new kms_ethers_signer_1.KmsEthersSigner(kmsCredentials);
+        let signerAddress = await signer.getAddress();
+        // logger.info(` keyid ${keyId} ${signerAddress}`);
+        if (!signerAddress) {
+            throw new Error(`Invalid kms signer, keyId:${keyId}`);
+        }
+        return signer;
+    }
+    catch (error) {
+        throw error;
+    }
+};
+exports.getAwsKmsSigner = getAwsKmsSigner;

package/dist/utils/eventGetter.d.ts

@@ -0,0 +1,4 @@
+import { Contract, Event, EventFilter, providers } from "ethers";
+import { StaticJsonRpcProvider } from "@ethersproject/providers";
+export declare const getEvents: (contract: Contract, filter: EventFilter | string, fromBlock: number, toBlock: number, eventBlockRange?: number) => Promise<Event[]>;
+export declare const getLogs: (provider: StaticJsonRpcProvider, address: string[], topics: string[], fromBlock: number, toBlock: number, eventBlockRange?: number) => Promise<providers.Log[]>;

package/dist/utils/eventGetter.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogs = exports.getEvents = void 0;
+const getEvents = async (contract, filter, fromBlock, toBlock, eventBlockRange = 5000) => {
+    const allEvents = [];
+    try {
+        let from = fromBlock;
+        let to = from + eventBlockRange - 1;
+        to = to < toBlock ? to : toBlock;
+        while (from <= toBlock) {
+            const events = await contract.queryFilter(filter, from, to);
+            allEvents.push(...events);
+            from = to + 1;
+            to = from + eventBlockRange - 1;
+            to = to < toBlock ? to : toBlock;
+        }
+    }
+    catch (error) {
+        throw error;
+    }
+    return allEvents;
+};
+exports.getEvents = getEvents;
+const getLogs = async (provider, address, topics, fromBlock, toBlock, eventBlockRange = 5000) => {
+    const allLogs = [];
+    try {
+        let from = fromBlock;
+        let to = from + eventBlockRange - 1;
+        to = to < toBlock ? to : toBlock;
+        while (from <= toBlock) {
+            const logs = await provider.send("eth_getLogs", [
+                {
+                    address,
+                    topics,
+                    fromBlock: `0x${from.toString(16)}`,
+                    toBlock: `0x${to.toString(16)}`,
+                },
+            ]);
+            allLogs.push(...logs);
+            from = to + 1;
+            to = from + eventBlockRange - 1;
+            to = to < toBlock ? to : toBlock;
+        }
+    }
+    catch (error) {
+        throw error;
+    }
+    return allLogs;
+};
+exports.getLogs = getLogs;