@socket.tech/dl-common 1.0.6 → 1.0.7

package/dist/src/statusTrackers/packet.js

@@ -0,0 +1,477 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSealTimeout = exports.updatePacketTxStatus = exports.getPacketsByTxId = exports.getPendingFullyExecutedPackets = exports.checkAndUpdateFullyExecutedStatus = exports.checkAndUpdatePacketRelayStatus = exports.getUpdateObj = void 0;
+const utils_1 = require("../utils");
+const utils_2 = require("../../dl-common/utils");
+const models_1 = require("../../dl-common/models");
+const db_1 = require("../db");
+const sequelize_1 = require("sequelize");
+const constants_1 = require("../constants");
+const constants_2 = require("../../dl-common/constants");
+const prometheus_config_1 = require("../constants/prometheus.config");
+const confirmations_1 = require("../../dl-common/constants/confirmations");
+const services_1 = require("../../dl-common/services");
+const relayers_1 = require("../relayers");
+const dl_core_1 = require("@socket.tech/dl-core");
+const getTxId = (packet) => {
+    if (packet.sealRelayStatus === models_1.SealRelayStatus.SEALING)
+        return packet.sealTxId;
+    if (packet.proposeRelayStatus === models_1.ProposeRelayStatus.PROPOSING)
+        return packet.proposeTxId;
+    if (packet.attestRelayStatus === models_1.AttestRelayStatus.ATTESTING)
+        return packet.attestTxId;
+    console.log("No pending txId found for packet ", packet.packetId);
+    return null;
+};
+const getUpdateObj = (packet, status, txHash, chainId, confirmations) => {
+    let updateObj;
+    if (status === constants_2.RelayerAPIStatus.FAILED) {
+        updateObj = getFailedTxStatusUpdateObj(packet, txHash);
+    }
+    else if (status === constants_2.RelayerAPIStatus.SIMULATION_FAILED ||
+        status === constants_2.RelayerAPIStatus.DUPLICATE_NONCE_TX) {
+        updateObj = getRetryTxStatusUpdateObj(packet, txHash);
+    }
+    else if (status === constants_2.RelayerAPIStatus.COMPLETED) {
+        updateObj = getCompletedTxStatusUpdateObj(packet, txHash, chainId, confirmations);
+    }
+    return updateObj;
+};
+exports.getUpdateObj = getUpdateObj;
+const getCompletedTxStatusUpdateObj = (packet, txHash, chainId, confirmations) => {
+    let updateObj = { packetId: packet.packetId };
+    if (packet.sealRelayStatus === models_1.SealRelayStatus.SEALING) {
+        let isEnoughTimePassed = (0, utils_2.currentTimestampInSeconds)() - packet.outboundTime >
+            (0, exports.getSealTimeout)(packet.srcChainSlug);
+        let isEnoughConfirmations = chainId &&
+            confirmations &&
+            (0, confirmations_1.getConfirmations)(chainId) &&
+            confirmations > (0, confirmations_1.getConfirmations)(chainId);
+        if (isEnoughTimePassed || isEnoughConfirmations) {
+            /// add discord alert
+            console.log({ isEnoughTimePassed, isEnoughConfirmations });
+            updateObj = {
+                ...updateObj,
+                isSealed: true,
+                sealRelayStatus: models_1.SealRelayStatus.SEALED,
+                sealTxHash: txHash,
+            };
+        }
+    }
+    if (packet.proposeRelayStatus === models_1.ProposeRelayStatus.PROPOSING)
+        updateObj = {
+            ...updateObj,
+            proposeRelayStatus: models_1.ProposeRelayStatus.PROPOSED,
+            proposeTxHash: txHash,
+            isProposed: true,
+        };
+    if (packet.attestRelayStatus === models_1.AttestRelayStatus.ATTESTING)
+        updateObj = {
+            ...updateObj,
+            attestRelayStatus: models_1.AttestRelayStatus.ATTESTED,
+            attestTxHash: txHash,
+            isAttested: true,
+        };
+    return updateObj;
+};
+const getRetryTxStatusUpdateObj = (packet, txHash) => {
+    let updateObj = { packetId: packet.packetId };
+    if (packet.sealRelayStatus === models_1.SealRelayStatus.SEALING)
+        updateObj = {
+            ...updateObj,
+            sealRelayStatus: models_1.SealRelayStatus.NO,
+            sealTxHash: txHash,
+        };
+    if (packet.proposeRelayStatus === models_1.ProposeRelayStatus.PROPOSING)
+        updateObj = {
+            ...updateObj,
+            proposeRelayStatus: models_1.ProposeRelayStatus.NO,
+            proposeTxHash: txHash,
+        };
+    if (packet.attestRelayStatus === models_1.AttestRelayStatus.ATTESTING)
+        updateObj = {
+            ...updateObj,
+            attestRelayStatus: models_1.AttestRelayStatus.NO,
+            attestTxHash: txHash,
+        };
+    return updateObj;
+};
+const getFailedTxStatusUpdateObj = (packet, txHash) => {
+    let updateObj = { packetId: packet.packetId };
+    if (packet.sealRelayStatus === models_1.SealRelayStatus.SEALING)
+        updateObj = {
+            ...updateObj,
+            sealRelayStatus: models_1.SealRelayStatus.SEAL_FAILED,
+            sealTxHash: txHash,
+        };
+    if (packet.proposeRelayStatus === models_1.ProposeRelayStatus.PROPOSING)
+        updateObj = {
+            ...updateObj,
+            proposeRelayStatus: models_1.ProposeRelayStatus.PROPOSE_FAILED,
+            proposeTxHash: txHash,
+        };
+    if (packet.attestRelayStatus === models_1.AttestRelayStatus.ATTESTING)
+        updateObj = {
+            ...updateObj,
+            attestRelayStatus: models_1.AttestRelayStatus.ATTEST_FAILED,
+            attestTxHash: txHash,
+        };
+    return updateObj;
+};
+const checkAndUpdatePacketRelayStatus = async () => {
+    try {
+        const packets = await getPendingRelayPackets();
+        if (packets.length === 0) {
+            utils_1.logger.info(`No pending relay packets found, returning`);
+            return;
+        }
+        (0, utils_1.logInfo)({
+            info: "PACKET_RELAY_STATUS_CHECKING",
+            packetIds: packets.map((p) => p.packetId),
+            total: packets.length,
+            messageIds: [],
+        });
+        const txIds = new Set();
+        const packetDbUpdates = [];
+        const statusCount = {};
+        const txIdStatusMap = {};
+        const packetMap = {};
+        packets.forEach((packet) => {
+            const txId = getTxId(packet);
+            if (!txId)
+                return;
+            txIds.add(txId);
+            packetMap[packet.packetId] = packet;
+        });
+        const url = (0, constants_1.multipleTxStatusUrl)();
+        (0, utils_1.logInfo)({
+            info: "CALLING_RELAYER",
+            packetIds: packets.map((p) => p.packetId),
+            txIds,
+            messageIds: [],
+        });
+        const tx = await (0, utils_2.axiosPost)(url, { txIds: [...txIds] });
+        const responses = tx === null || tx === void 0 ? void 0 : tx.data;
+        (0, utils_1.logInfo)({
+            info: "RELAYER_RESPONSE",
+            packetIds: packets.map((p) => p.packetId),
+            txIds,
+            responses,
+            messageIds: [],
+        });
+        responses.forEach((response) => {
+            const { txId, txHash, status } = response;
+            txIdStatusMap[txId] = { txHash, status };
+        });
+        packets.forEach((packet) => {
+            const txId = getTxId(packet);
+            if (!txId)
+                return;
+            const { status, txHash } = txIdStatusMap[txId];
+            if (statusCount[status])
+                statusCount[status] += 1;
+            else
+                statusCount[status] = 1;
+            const updateObj = (0, exports.getUpdateObj)(packet, status, txHash);
+            if (updateObj) {
+                // using packet fields in update is important to avoid getting default value set for other fields
+                // which are not part of updateObj. for example if only proposing, updateObj will have proposeTxHash, isProposed
+                // etc, but if we not destructure packet here, sequelize will update isSealed with default values.
+                packetDbUpdates.push({ ...packet, ...updateObj });
+                // if (updateObj.sealRelayStatus == SealRelayStatus.SEALED) {
+                //   observeHistogram(relayMetrics.sealRelay.statusUpdateHistogram, {
+                //     labels: {
+                //       [Labels.SRC_CHAIN_SLUG]: packet.srcChainSlug,
+                //     },
+                //     timeDiff: currentTimestampInSeconds() - packet.outboundTime,
+                //   });
+                // }
+                if (updateObj.proposeRelayStatus == models_1.ProposeRelayStatus.PROPOSED) {
+                    (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.proposeRelay.statusUpdateHistogram, {
+                        labels: {
+                            [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: packet.srcChainSlug,
+                            [prometheus_config_1.Labels.DST_CHAIN_SLUG]: packet.dstChainSlug,
+                            [prometheus_config_1.Labels.INTEGRATION_TYPE]: packet.integrationType,
+                        },
+                        timeDiff: (0, utils_2.currentTimestampInSeconds)() - packet.outboundTime,
+                    });
+                }
+                if (updateObj.attestRelayStatus == models_1.AttestRelayStatus.ATTESTED) {
+                    (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.attestRelay.statusUpdateHistogram, {
+                        labels: {
+                            [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: packet.srcChainSlug,
+                            [prometheus_config_1.Labels.DST_CHAIN_SLUG]: packet.dstChainSlug,
+                            [prometheus_config_1.Labels.INTEGRATION_TYPE]: packet.integrationType,
+                        },
+                        timeDiff: (0, utils_2.currentTimestampInSeconds)() - packet.outboundTime,
+                    });
+                }
+            }
+        });
+        (0, utils_1.logInfo)({
+            info: "PACKET_STATUS_CHECK_DB_UPDATE",
+            packetIds: packets.map((p) => p.packetId),
+            statusCount,
+            messageIds: [],
+        });
+        if (packetDbUpdates.length > 0) {
+            await savePacketUpdates(packetDbUpdates);
+        }
+        (0, utils_1.logInfo)({
+            info: "PACKET_STATUS_CHECK_DB_UPDATE_DONE",
+            packetIds: packets.map((p) => p.packetId),
+            messageIds: [],
+        });
+    }
+    catch (error) {
+        console.log("checkAndUpdatePacketRelayStatus", error);
+    }
+};
+exports.checkAndUpdatePacketRelayStatus = checkAndUpdatePacketRelayStatus;
+const savePacketUpdates = async (dbUpdates) => {
+    try {
+        //@ts-ignore
+        await models_1.Packet.bulkCreate(dbUpdates, {
+            updateOnDuplicate: [
+                // "isSealed",
+                "isProposed",
+                "isAttested",
+                "sealTxHash",
+                "attestTxHash",
+                "proposeTxHash",
+                "proposeRelayStatus",
+                "sealRelayStatus",
+                "attestRelayStatus",
+            ],
+        });
+    }
+    catch (error) {
+        utils_1.logger.error("Error while saving status  updates", error);
+        throw new Error(`Error while saving status  updates ${error === null || error === void 0 ? void 0 : error.message}`);
+    }
+};
+const checkAndUpdateFullyExecutedStatus = async () => {
+    var _a;
+    try {
+        const packets = await (0, exports.getPendingFullyExecutedPackets)();
+        const fullyExecutedPacketIds = [];
+        for (const packet of packets) {
+            let fullyExecuted = true;
+            if (!((_a = packet.Messages) === null || _a === void 0 ? void 0 : _a.length))
+                continue;
+            const messagesInPacket = 1; // update this later when using multi-message packets
+            let messageCount = 0;
+            for (const message of packet.Messages) {
+                if (!message.isExecuted) {
+                    fullyExecuted = false;
+                    break;
+                }
+                messageCount++;
+            }
+            if (fullyExecuted && messageCount === messagesInPacket) {
+                fullyExecutedPacketIds.push(packet.packetId);
+            }
+        }
+        (0, utils_1.logInfo)({
+            info: "UPDATING_PACKET_EXECUTION_STATUS_DB",
+            packetIds: packets.map((p) => p.packetId),
+            messageIds: [],
+        });
+        if (fullyExecutedPacketIds.length > 0) {
+            await saveFullyExecutedPacketUpdates(fullyExecutedPacketIds);
+        }
+        (0, utils_1.logInfo)({
+            info: "UPDATED_PACKET_EXECUTION_STATUS_DB",
+            packetIds: packets.map((p) => p.packetId),
+            messageIds: [],
+        });
+    }
+    catch (error) {
+        console.log("error in checkAndUpdateFullyExecutedStatus: ", error);
+    }
+};
+exports.checkAndUpdateFullyExecutedStatus = checkAndUpdateFullyExecutedStatus;
+const saveFullyExecutedPacketUpdates = async (packetIds) => {
+    try {
+        await models_1.Packet.update({
+            isFullyExecuted: true,
+        }, {
+            where: {
+                packetId: {
+                    [sequelize_1.Op.in]: packetIds,
+                },
+            },
+        });
+    }
+    catch (error) {
+        utils_1.logger.error("Error while saving status  updates", error);
+        throw new Error(`Error while saving status  updates ${error === null || error === void 0 ? void 0 : error.message}`);
+    }
+};
+const getPendingRelayPackets = async () => {
+    const startTime = new Date(new Date().getTime() - 30 * 1000); // 30 seconds ago
+    const oneDayAgo = new Date(new Date().getTime() - 24 * 60 * 60 * 1000); // 24 hours ago
+    let results = [];
+    try {
+        results = await models_1.Packet.findAll({
+            limit: constants_1.checkTxStatusLimit,
+            where: {
+                [sequelize_1.Op.or]: [
+                    {
+                        sealRelayStatus: models_1.SealRelayStatus.SEALING,
+                    },
+                    { proposeRelayStatus: models_1.ProposeRelayStatus.PROPOSING },
+                    { attestRelayStatus: models_1.AttestRelayStatus.ATTESTING },
+                ],
+                updatedAt: {
+                    [sequelize_1.Op.and]: [
+                        { [sequelize_1.Op.lte]: startTime },
+                        { [sequelize_1.Op.gte]: oneDayAgo }, // updatedAt >= oneDayAgo
+                    ],
+                },
+            },
+            order: [
+                [
+                    db_1.attesterDBInst.cast(db_1.attesterDBInst.col("updatedAt"), "timestamp"),
+                    "ASC",
+                ],
+            ],
+        });
+        results = results.map((result) => result.get({ plain: true }));
+    }
+    catch (err) {
+        utils_1.logger.error(`packet-txstatus-checker -> error while querying Packets-Awaiting-RelayCompletion`);
+        utils_1.logger.error("Error", err);
+    }
+    return results;
+};
+const getPendingFullyExecutedPackets = async () => {
+    const startTime = new Date(new Date().getTime() - 30 * 1000); // 30 seconds ago
+    const oneDayAgo = new Date(new Date().getTime() - 24 * 60 * 60 * 1000); // 24 hours ago
+    const packets = await models_1.Packet.findAll({
+        limit: constants_1.proposeBatchQueryLimit,
+        where: {
+            isFullyExecuted: false,
+            isAttested: true,
+            tripReason: models_1.TripReason.NO,
+            updatedAt: {
+                [sequelize_1.Op.and]: [
+                    { [sequelize_1.Op.lte]: startTime },
+                    { [sequelize_1.Op.gte]: oneDayAgo }, // updatedAt >=24 hours ago
+                ],
+            },
+        },
+        include: [
+            {
+                model: models_1.Message,
+                // we dont want to fetch messages which dont have inboundSuccess as true.
+                // if there are no valid messages, no point fetching packet as well. therefore not
+                // using required: false;
+                where: {
+                    inboundSuccess: true,
+                    executeRelayStatus: {
+                        [sequelize_1.Op.ne]: models_1.ExecutionRelayStatus.IGNORED,
+                    },
+                },
+                attributes: ["messageId", "isExecuted"],
+            },
+        ],
+        order: [["updatedAt", "ASC"]],
+    });
+    console.log(" getPendingFullyExecutedPackets count: ", packets.length);
+    return packets;
+};
+exports.getPendingFullyExecutedPackets = getPendingFullyExecutedPackets;
+const getPacketsByTxId = async (txIds) => {
+    const packets = (await models_1.Packet.findAll({
+        where: {
+            [sequelize_1.Op.or]: [
+                { sealTxId: { [sequelize_1.Op.in]: txIds } },
+                { proposeTxId: { [sequelize_1.Op.in]: txIds } },
+                { attestTxId: { [sequelize_1.Op.in]: txIds } },
+            ],
+        },
+    })).map((el) => el.get({ plain: true }));
+    return packets;
+};
+exports.getPacketsByTxId = getPacketsByTxId;
+const updatePacketTxStatus = async (updates) => {
+    const statusCount = {};
+    const txIdStatusMap = {};
+    updates.forEach((update) => {
+        txIdStatusMap[update.txId] = update;
+    });
+    const txIds = updates.map((u) => u.txId);
+    const packets = await (0, exports.getPacketsByTxId)(txIds);
+    const packetDbUpdates = [];
+    let isRelayProposeRequired = false;
+    for (const packet of packets) {
+        const txId = getTxId(packet);
+        if (!txId || !txIdStatusMap[txId])
+            return;
+        const { status, txHash, chainId, confirmations } = txIdStatusMap[txId];
+        if (statusCount[status])
+            statusCount[status] += 1;
+        else
+            statusCount[status] = 1;
+        const updateObj = (0, exports.getUpdateObj)(packet, status, txHash, chainId, confirmations);
+        if (updateObj) {
+            packetDbUpdates.push({ ...packet, ...updateObj });
+            if (updateObj === null || updateObj === void 0 ? void 0 : updateObj.isSealed)
+                isRelayProposeRequired = true;
+            if (updateObj.sealRelayStatus === models_1.SealRelayStatus.SEAL_FAILED)
+                await (0, relayers_1.markSealRecentError)();
+            observeStatusUpdateMetrics(packet, updateObj);
+        }
+    }
+    const updatedPacketIds = packetDbUpdates.map((p) => p.packetId);
+    console.log({ updatedPacketIds });
+    if (packetDbUpdates.length > 0) {
+        // console.log({packetDbUpdates});
+        await savePacketUpdates(packetDbUpdates);
+    }
+    if (isRelayProposeRequired) {
+        await (0, services_1.sendStandardSqsMessage)(constants_1.SQS_BASE_URL + constants_1.QueueName.BATCHER_TASK_QUEUE, {
+            type: constants_1.TaskNames.RELAY_PROPOSE,
+            data: { counter: Math.floor(Math.random() * 100) },
+        });
+    }
+};
+exports.updatePacketTxStatus = updatePacketTxStatus;
+const observeStatusUpdateMetrics = (packet, updateObj) => {
+    if (updateObj.sealRelayStatus == models_1.SealRelayStatus.SEALED &&
+        (updateObj === null || updateObj === void 0 ? void 0 : updateObj.isSealed)) {
+        (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.sealRelay.statusUpdateHistogram, {
+            labels: {
+                [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: packet.srcChainSlug,
+            },
+            timeDiff: (0, utils_2.currentTimestampInSeconds)() - packet.outboundTime,
+        });
+    }
+    if (updateObj.proposeRelayStatus == models_1.ProposeRelayStatus.PROPOSED) {
+        (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.proposeRelay.statusUpdateHistogram, {
+            labels: {
+                [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: packet.srcChainSlug,
+                [prometheus_config_1.Labels.DST_CHAIN_SLUG]: packet.dstChainSlug,
+                [prometheus_config_1.Labels.INTEGRATION_TYPE]: packet.integrationType,
+            },
+            timeDiff: (0, utils_2.currentTimestampInSeconds)() - packet.outboundTime,
+        });
+    }
+    if (updateObj.attestRelayStatus == models_1.AttestRelayStatus.ATTESTED) {
+        (0, prometheus_config_1.observeHistogram)(prometheus_config_1.relayMetrics.attestRelay.statusUpdateHistogram, {
+            labels: {
+                [prometheus_config_1.Labels.SRC_CHAIN_SLUG]: packet.srcChainSlug,
+                [prometheus_config_1.Labels.DST_CHAIN_SLUG]: packet.dstChainSlug,
+                [prometheus_config_1.Labels.INTEGRATION_TYPE]: packet.integrationType,
+            },
+            timeDiff: (0, utils_2.currentTimestampInSeconds)() - packet.outboundTime,
+        });
+    }
+};
+const getSealTimeout = (chainSlug) => {
+    if (chainSlug === dl_core_1.ChainSlug.POLYGON_MAINNET)
+        return 15 * 60;
+    return 5 * 60;
+};
+exports.getSealTimeout = getSealTimeout;

package/dist/src/utils/chain-utils.d.ts

@@ -0,0 +1,5 @@
+import { type TransactionReceipt } from "@ethersproject/providers";
+import { type BigNumber } from "ethers";
+import { type ChainSlug } from "@socket.tech/dl-core";
+export declare const getReceipt: (txHash: string, chainSlug: ChainSlug) => Promise<TransactionReceipt>;
+export declare const getRPCGasPrice: (chainSlug: ChainSlug) => Promise<BigNumber>;

package/dist/src/utils/chain-utils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRPCGasPrice = exports.getReceipt = void 0;
+const constants_1 = require("../constants");
+const index_1 = require("../../dl-common/index");
+const logger_1 = require("./logger");
+const getReceipt = async (txHash, chainSlug) => {
+    let receipt;
+    try {
+        const provider = (0, constants_1.getProvider)(chainSlug);
+        receipt = await provider.getTransactionReceipt(txHash);
+    }
+    catch (e) {
+        const err = e;
+        if ((err === null || err === void 0 ? void 0 : err.code) === "INVALID_ARGUMENT") {
+            throw new index_1.ServerError(index_1.StatusCodes.BAD_REQUEST, `invalid hash ${txHash}`);
+        }
+        else {
+            logger_1.logger.error("Error while getting receipt", err.toString());
+            throw new index_1.ServerError(index_1.StatusCodes.INTERNAL_SERVER_ERROR);
+        }
+    }
+    if (!receipt) {
+        throw new index_1.ServerError(index_1.StatusCodes.NOT_FOUND, `tx ${txHash} not found on ${chainSlug} `);
+    }
+    return receipt;
+};
+exports.getReceipt = getReceipt;
+const getRPCGasPrice = async (chainSlug) => {
+    let gasPrice;
+    try {
+        const provider = (0, constants_1.getProvider)(chainSlug);
+        gasPrice = await provider.getGasPrice();
+    }
+    catch (e) {
+        const err = e;
+        logger_1.logger.error("Error while getting gas price from rpc", err.toString());
+        throw (0, index_1.InternalServerError)("Error while getting gas price from rpc");
+    }
+    return gasPrice;
+};
+exports.getRPCGasPrice = getRPCGasPrice;

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

@@ -0,0 +1,2 @@
+export * from "./logger";
+export * from "./chain-utils";

package/dist/src/utils/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./logger"), exports);
+__exportStar(require("./chain-utils"), exports);

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,9 @@
+export declare const logger: import("@aws-lambda-powertools/logger/lib/Logger").Logger;
+export interface LogType {
+    info: string;
+    packetIds: string[];
+    messageIds: string[];
+    [key: string]: any;
+}
+export declare const logInfo: (logInfo: LogType) => void;
+export declare const logError: (logInfo: LogType) => void;

package/dist/src/utils/logger.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logError = exports.logInfo = exports.logger = void 0;
+const ll_common_1 = require("@socket.tech/ll-common");
+exports.logger = (0, ll_common_1.createLogger)(process.env.REGION || "N/A", "socket-dl-batcher");
+const logInfo = (logInfo) => exports.logger.info(`${JSON.stringify(logInfo)}`);
+exports.logInfo = logInfo;
+const logError = (logInfo) => exports.logger.error(`${JSON.stringify(logInfo)}`);
+exports.logError = logError;

package/dist/utils/s3Service.js

@@ -50,7 +50,7 @@ exports.uploadFileToS3 = uploadFileToS3;
 const getBucketAndFileName = (deploymentMode, account = __1.Accounts.dl) => {
     const S3_BUCKET_NAME = deploymentMode === dl_core_1.DeploymentMode.SURGE ||
         deploymentMode == dl_core_1.DeploymentMode.PROD
-        ? `socket-${account}-prod`
+        ? `socket-${account}-${deploymentMode}`
         : `socket-ll-${deploymentMode}`;
     const S3_RPC_CONFIG_FILE_PATH = deploymentMode + "RpcConfig.json";
     return { S3_BUCKET_NAME, S3_RPC_CONFIG_FILE_PATH };

package/dist/utils/signer/socketSigner.d.ts

@@ -0,0 +1,32 @@
+import { type Provider, type TransactionRequest, type TransactionResponse } from "@ethersproject/abstract-provider";
+import { type Deferrable } from "@ethersproject/properties";
+import { SocketRelaySigner } from "../relaySigner";
+import { Contract, type Wallet } from "ethers";
+export declare const EIP712_SAFE_TX_TYPE: {
+    SafeTx: {
+        type: string;
+        name: string;
+    }[];
+};
+export declare class SocketSigner extends SocketRelaySigner {
+    readonly provider: Provider;
+    readonly chainId: number;
+    readonly safeAddress: string;
+    readonly safeWrapperAddress: string;
+    readonly relayUrl: string;
+    readonly relayerAPIKey: string;
+    readonly signingWallet?: Wallet | undefined;
+    readonly useSafe: boolean;
+    readonly useEOA: boolean;
+    readonly sequential: boolean;
+    readonly isCritical: boolean;
+    readonly metadata: object;
+    readonly safeWrapperContract: Contract;
+    readonly address: string;
+    constructor(provider: Provider, chainId: number, safeAddress: string, safeWrapperAddress: string, relayUrl: string, relayerAPIKey: string, signingWallet?: Wallet | undefined, useSafe?: boolean, useEOA?: boolean, sequential?: boolean, isCritical?: boolean, metadata?: object);
+    setSigningWallet(signingWallet: Wallet): SocketRelaySigner;
+    setSafeWrapperAddress(safeWrapperAddress: string): SocketRelaySigner;
+    setSafeAddress(safeAddress: string): SocketRelaySigner;
+    getAddress(): Promise<string>;
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+}