@socket.tech/dl-common 1.0.6 → 1.0.7

package/dist/src/services/proposalCheckService.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSelectedProposalCount = exports.updateSelectedProposalCountForPackets = exports.getIncompletePackets = void 0;
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const models_1 = require("../../dl-common/models");
+const sequelize_1 = require("sequelize");
+const savePacketDbUpdates = async (updates) => {
+    try {
+        (0, utils_1.logInfo)({
+            info: "UPDATING_DB_PROPOSAL_COUNT",
+            packetIds: updates.map((u) => u.packetId),
+            messageIds: [],
+        });
+        //@ts-ignore
+        await models_1.Packet.bulkCreate(updates, {
+            updateOnDuplicate: ["selectedProposalCount"],
+        });
+        (0, utils_1.logInfo)({
+            info: "UPDATED_DB_PROPOSAL_COUNT",
+            packetIds: updates.map((u) => u.packetId),
+            messageIds: [],
+        });
+    }
+    catch (error) {
+        utils_1.logger.error("Error while saving selectedProposalCount updates", error);
+        throw new Error("Error while saving selectedProposalCount updates");
+    }
+};
+const getIncompletePackets = async (dstChainSlug) => {
+    const packets = await models_1.Packet.findAll({
+        limit: constants_1.rootMatchIndexerQueryLimit,
+        attributes: [
+            "packetId",
+            "root",
+            "rootSealed",
+            "dstSwitchboard",
+            "srcChainSlug",
+        ],
+        // add a limit and order by id desc clause
+        where: {
+            // here NO means not checked yet, default state
+            selectedProposalCount: null,
+            //   isFullyExecuted:false,  // TODO: remove this line after test done
+            srcChainSlug: {
+                [sequelize_1.Op.in]: constants_1.supportedChainSlugs,
+            },
+            dstChainSlug,
+        },
+        include: [
+            {
+                model: models_1.Proposal,
+                attributes: ["root", "packetId", "switchboard", "proposalCount"],
+            },
+        ],
+        // order: [[Sequelize.col("Packet.updatedAt"), "ASC"]],
+    });
+    console.log(dstChainSlug, "incomplete packets count", packets.length);
+    return packets;
+};
+exports.getIncompletePackets = getIncompletePackets;
+const updateSelectedProposalCountForPackets = async (chainSlug) => {
+    const chains = chainSlug != null ? [chainSlug] : constants_1.supportedChainSlugs;
+    for (const chain of chains) {
+        await (0, exports.updateSelectedProposalCount)(chain);
+    }
+};
+exports.updateSelectedProposalCountForPackets = updateSelectedProposalCountForPackets;
+const updateSelectedProposalCount = async (dstChainSlug) => {
+    const packetDbUpdates = [];
+    const packetIdsWithoutValidProposals = [];
+    try {
+        // find packets where proposal and packet root is not matched, and switchboard type is fast or optimistic
+        const packets = await (0, exports.getIncompletePackets)(dstChainSlug);
+        (0, utils_1.logInfo)({
+            info: "UPDATING_PROPOSAL_COUNT",
+            packetIds: packets.map((u) => u.packetId),
+            messageIds: [],
+        });
+        for (const packet of packets) {
+            const proposals = packet.Proposals;
+            if (!(proposals === null || proposals === void 0 ? void 0 : proposals.length)) {
+                packetIdsWithoutValidProposals.push(packet.packetId);
+                continue;
+            }
+            let isValidProposalFound = false;
+            for (const proposal of proposals) {
+                if (packet.dstSwitchboard === proposal.switchboard &&
+                    packet.rootSealed === proposal.root) {
+                    isValidProposalFound = true;
+                    packetDbUpdates.push({
+                        packetId: packet.packetId,
+                        selectedProposalCount: proposal.proposalCount,
+                    });
+                    break;
+                }
+            }
+            if (!isValidProposalFound) {
+                packetIdsWithoutValidProposals.push(packet.packetId);
+            }
+        }
+        (0, utils_1.logInfo)({
+            info: "VALID_PROPOSALS",
+            packetIds: packetIdsWithoutValidProposals,
+            messageIds: [],
+        });
+        await savePacketDbUpdates(packetDbUpdates);
+        (0, utils_1.logInfo)({
+            info: "UPDATED_PROPOSAL_COUNT",
+            packetIds: packetDbUpdates.map((u) => u.packetId),
+            messageIds: [],
+        });
+    }
+    catch (error) {
+        utils_1.logger.error(`error in updateSelectedProposalCount: ${error}`);
+        throw new Error(`error in updateSelectedProposalCount`);
+    }
+};
+exports.updateSelectedProposalCount = updateSelectedProposalCount;

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

@@ -0,0 +1,27 @@
+import { type SealParams } from "../../dl-common";
+export declare const seal: (sealRequests: SealParams[]) => Promise<any>;
+interface MessageDBUpdate {
+    srcChainSlug: number;
+    dstChainSlug: number;
+    srcPlug: string;
+    destPlug: string;
+    messageId: 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;
+    capacitorPacketCount: string;
+    rootHash: string;
+    packetId: string;
+}
+export declare const registerFeesCollected: (messageUpdates: MessageDBUpdate[]) => Promise<void>;
+export {};

package/dist/src/services/sealService.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFeesCollected = exports.seal = void 0;
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const dl_core_1 = require("@socket.tech/dl-core");
+const dl_common_1 = require("../../dl-common");
+const utils_2 = require("ethers/lib/utils");
+const seal = async (sealRequests) => {
+    var _a;
+    try {
+        (0, utils_1.logInfo)({
+            info: "SEAL_REQUESTS_INDEXING",
+            packetIds: sealRequests.map((s) => s.packet.packetId),
+            messageIds: sealRequests.map((s) => s.message.messageId),
+        });
+        const chainSlug = (_a = sealRequests[0]) === null || _a === void 0 ? void 0 : _a.srcChainSlug;
+        const sealRequestPacketIds = sealRequests.map((s) => s.packet.packetId);
+        const packetDbUpdates = [];
+        const messageDbUpdates = [];
+        // signatureDbUpdates = [];
+        sealRequests.map((sealRequest) => {
+            const { srcChainSlug, dstChainSlug, dstSwitchboard, srcSwitchboard, integrationType, } = sealRequest;
+            const { root, capacitorPacketCount } = sealRequest.packet;
+            const { outboundTime, outboundTxHash } = sealRequest.message;
+            messageDbUpdates.push({
+                ...sealRequest.message,
+                srcChainSlug,
+                dstChainSlug,
+                packetId: sealRequest.packet.packetId,
+                rootHash: root,
+                capacitorPacketCount,
+            });
+            packetDbUpdates.push({
+                srcChainSlug,
+                dstChainSlug,
+                switchboardId: `${srcChainSlug}-${dstChainSlug}-${srcSwitchboard.toLowerCase()}`,
+                dstSwitchboard,
+                integrationType,
+                ...sealRequest.packet,
+                outboundTime,
+                outboundTxHash,
+                isFilled: true,
+                executionWaitTime: Date.now() / 1000 +
+                    (0, dl_common_1.getWaitTime)(integrationType, srcChainSlug, dstChainSlug), // seconds
+            });
+        });
+        if (packetDbUpdates.length > 0)
+            await savePacketUpdates(packetDbUpdates);
+        if (messageDbUpdates.length > 0)
+            await saveMessageUpdates(messageDbUpdates);
+        (0, utils_1.logInfo)({
+            info: "SEAL_REQUESTS_QUEUING",
+            packetIds: sealRequests.map((s) => s.packet.packetId),
+            messageIds: sealRequests.map((s) => s.message.messageId),
+        });
+        await (0, dl_common_1.sendStandardSqsMessage)(constants_1.SQS_BASE_URL + constants_1.QueueName.BATCHER_TASK_QUEUE, {
+            type: constants_1.TaskNames.RELAY_SEAL,
+            data: {
+                chainSlug,
+            },
+        });
+        (0, utils_1.logInfo)({
+            info: "SEAL_REQUESTS_QUEUED",
+            packetIds: sealRequests.map((s) => s.packet.packetId),
+            messageIds: sealRequests.map((s) => s.message.messageId),
+        });
+        await (0, exports.registerFeesCollected)(messageDbUpdates);
+        // await sendPendingSimulationRequest();
+    }
+    catch (error) {
+        utils_1.logger.error("Error", error);
+        throw error;
+    }
+};
+exports.seal = seal;
+const saveMessageUpdates = async (dbUpdates) => {
+    try {
+        (0, utils_1.logInfo)({
+            info: "SEAL_REQUESTS_UPDATING_MSG_DB",
+            messageIds: dbUpdates.map((s) => s.messageId),
+            packetIds: [],
+        });
+        //@ts-ignore
+        await dl_common_1.Message.bulkCreate(dbUpdates, {
+            updateOnDuplicate: [
+                "srcChainSlug",
+                "dstChainSlug",
+                "srcPlug",
+                "destPlug",
+                "executionParams",
+                "transmissionParams",
+                "minMsgGasLimit",
+                "executionFee",
+                "transmissionFees",
+                "switchboardFees",
+                "fees",
+                "payload",
+                "decapacitorProof",
+                "packedMessage",
+                "outboundTime",
+                "outboundTxHash",
+                "capacitorMsgCount",
+                "capacitorPacketCount",
+                "rootHash",
+                "packetId",
+            ],
+        });
+        (0, utils_1.logInfo)({
+            info: "SEAL_REQUESTS_UPDATED_MSG_DB",
+            messageIds: dbUpdates.map((s) => s.messageId),
+            packetIds: [],
+        });
+    }
+    catch (error) {
+        utils_1.logger.error("Error while saving new message updates", error);
+        throw new Error(`Error while saving new message updates ${error === null || error === void 0 ? void 0 : error.message}`);
+    }
+};
+const savePacketUpdates = async (dbUpdates) => {
+    (0, utils_1.logInfo)({
+        info: "SEAL_REQUESTS_UPDATING_PKT_DB",
+        packetIds: dbUpdates.map((s) => s.packetId),
+        messageIds: [],
+    });
+    try {
+        //@ts-ignore
+        await dl_common_1.Packet.bulkCreate(dbUpdates, {
+            updateOnDuplicate: [
+                "srcChainSlug",
+                "dstChainSlug",
+                "srcCapacitor",
+                "dstSwitchboard",
+                "switchboardId",
+                "capacitorPacketCount",
+                "integrationType",
+                "root",
+                "isFilled",
+                "outboundTime",
+                "executionWaitTime",
+                "outboundTxHash",
+                "sealSignature",
+            ],
+        });
+        (0, utils_1.logInfo)({
+            info: "SEAL_REQUESTS_UPDATED_PKT_DB",
+            packetIds: dbUpdates.map((s) => s.packetId),
+            messageIds: [],
+        });
+    }
+    catch (error) {
+        utils_1.logger.error("Error while saving new packet updates", error);
+        throw new Error(`Error while saving new packet updates ${error === null || error === void 0 ? void 0 : error.message}`);
+    }
+};
+const registerFeesCollected = async (messageUpdates) => {
+    try {
+        let feesCollectedArray = [];
+        messageUpdates.map((message) => {
+            var _a;
+            feesCollectedArray.push({
+                chainId: dl_core_1.ChainSlugToId[message.srcChainSlug],
+                txHash: message.outboundTxHash,
+                identifier: message.messageId,
+                metadata: {
+                    packetId: message.packetId,
+                },
+                feeToken: (_a = constants_1.s3Config.chains[message.srcChainSlug]) === null || _a === void 0 ? void 0 : _a.nativeToken,
+                feeAmount: (0, utils_2.formatEther)(message.fees),
+            });
+        });
+        await (0, dl_common_1.axiosPost)(constants_1.relayerBaseUrl + "/registerFeesCollected", {
+            feesCollectedArray,
+        }, {
+            headers: {
+                "x-api-key": constants_1.relayerAPIKey,
+            },
+        });
+        (0, utils_1.logInfo)({
+            info: "REGISTERED_COLLECTED_FEES",
+            messagesCount: messageUpdates.length,
+            packetIds: [],
+            messageIds: []
+        });
+    }
+    catch (error) {
+        console.log("Error while registering collected fees : ", error);
+    }
+};
+exports.registerFeesCollected = registerFeesCollected;

package/dist/src/statusTrackers/failedMessage.d.ts

@@ -0,0 +1,8 @@
+interface MessageDbUpdate {
+    messageId?: string;
+    isExecuted?: boolean;
+    executeRelayStatus?: string;
+}
+export declare const checkFailedMessages: (messageIds: string[], dryRun?: boolean) => Promise<MessageDbUpdate[] | undefined>;
+export declare const saveMessageUpdates: (dbUpdates: MessageDbUpdate[]) => Promise<void>;
+export {};

package/dist/src/statusTrackers/failedMessage.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveMessageUpdates = exports.checkFailedMessages = void 0;
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+const models_1 = require("@dl-common/models");
+const common_1 = require("../relayers/common");
+const utils_1 = require("../utils");
+const checkFailedMessages = async (messageIds, dryRun = true) => {
+    if (!(messageIds === null || messageIds === void 0 ? void 0 : messageIds.length))
+        return;
+    const messages = await models_1.Message.findAll({
+        where: { messageId: messageIds },
+        raw: true,
+    });
+    const messageMap = new Map();
+    const response = [];
+    for (const message of messages) {
+        messageMap.set(message.messageId, message);
+    }
+    const messageDbUpdates = {};
+    for (const message of messages) {
+        const messageId = message.messageId;
+        messageDbUpdates[messageId] = { messageId };
+        if (message.executeRelayStatus === models_1.ExecutionRelayStatus.EXECUTE_FAILED ||
+            message.executeRelayStatus === models_1.ExecutionRelayStatus.NO) {
+            const isExecuted = await checkIfExecuted(message);
+            console.log({ messageId, isExecuted });
+            if (isExecuted) {
+                messageDbUpdates[messageId] = {
+                    isExecuted: true,
+                    executeRelayStatus: models_1.ExecutionRelayStatus.EXECUTED,
+                };
+            }
+            else {
+                messageDbUpdates[messageId] = {
+                    isExecuted: false,
+                    executeRelayStatus: models_1.ExecutionRelayStatus.NO,
+                };
+            }
+        }
+        response.push(messageDbUpdates[messageId]);
+        messageDbUpdates[messageId] = {
+            ...message,
+            ...messageDbUpdates[messageId],
+        };
+    }
+    console.log({ response });
+    if (dryRun)
+        return response;
+    await (0, exports.saveMessageUpdates)(Object.values(messageDbUpdates));
+    return response;
+};
+exports.checkFailedMessages = checkFailedMessages;
+const checkIfExecuted = async (message) => {
+    const socketContract = await (0, common_1.getSocket)(message.dstChainSlug, {});
+    return await socketContract.messageExecuted(message.messageId);
+};
+const saveMessageUpdates = async (dbUpdates) => {
+    try {
+        if (dbUpdates.length === 0)
+            return;
+        // TODO: fix this
+        await models_1.Message.bulkCreate(dbUpdates, {
+            updateOnDuplicate: ["isExecuted", "executeRelayStatus"],
+        });
+    }
+    catch (error) {
+        utils_1.logger.error("Error while saving failed message updates", error);
+        throw new Error(`Error while saving failed message updates ${error === null || error === void 0 ? void 0 : error.message}`);
+    }
+};
+exports.saveMessageUpdates = saveMessageUpdates;

package/dist/src/statusTrackers/failedPacket.d.ts

@@ -0,0 +1,13 @@
+interface PacketDbUpdate {
+    packetId?: string;
+    isSealed?: boolean;
+    sealRelayStatus?: string;
+    isProposed?: boolean;
+    proposeRelayStatus?: string;
+    selectedProposalCount?: number;
+    isAttested?: boolean;
+    attestRelayStatus?: string;
+}
+export declare const checkFailedPackets: (packetIds: string[], dryRun?: boolean) => Promise<PacketDbUpdate[] | undefined>;
+export declare const savePacketUpdates: (dbUpdates: PacketDbUpdate[]) => Promise<void>;
+export {};

package/dist/src/statusTrackers/failedPacket.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.savePacketUpdates = exports.checkFailedPackets = void 0;
+const models_1 = require("@dl-common/models");
+const common_1 = require("../relayers/common");
+const utils_1 = require("../utils");
+const utils_2 = require("@dl-common/utils");
+const checkFailedPackets = async (packetIds, dryRun = true) => {
+    if (!(packetIds === null || packetIds === void 0 ? void 0 : packetIds.length))
+        return;
+    const packets = await models_1.Packet.findAll({
+        where: { packetId: packetIds },
+        raw: true,
+    });
+    const response = [];
+    const packetMap = new Map();
+    for (const packet of packets) {
+        packetMap.set(packet.packetId, packet);
+    }
+    const packetDbUpdates = {};
+    for (const packet of packets) {
+        const packetId = packet.packetId;
+        packetDbUpdates[packetId] = { packetId };
+        if (packet.proposeRelayStatus === models_1.ProposeRelayStatus.PROPOSE_FAILED) {
+            const { isProposed, selectedProposalCount } = await checkIfProposed(packet);
+            if (isProposed) {
+                packetDbUpdates[packetId] = {
+                    ...packetDbUpdates[packetId],
+                    isProposed: true,
+                    proposeRelayStatus: models_1.ProposeRelayStatus.PROPOSED,
+                    selectedProposalCount,
+                };
+            }
+            else {
+                packetDbUpdates[packetId] = {
+                    ...packetDbUpdates[packetId],
+                    isProposed: false,
+                    proposeRelayStatus: models_1.ProposeRelayStatus.NO,
+                };
+            }
+        }
+        if (packet.attestRelayStatus === models_1.AttestRelayStatus.ATTEST_FAILED) {
+            const isAttested = await checkIfAttested(packet);
+            if (isAttested) {
+                packetDbUpdates[packetId] = {
+                    ...packetDbUpdates[packetId],
+                    isAttested: true,
+                    attestRelayStatus: models_1.AttestRelayStatus.ATTESTED,
+                };
+            }
+            else {
+                packetDbUpdates[packetId] = {
+                    ...packetDbUpdates[packetId],
+                    isAttested: false,
+                    attestRelayStatus: models_1.AttestRelayStatus.NO,
+                };
+            }
+        }
+        response.push(packetDbUpdates[packetId]);
+        packetDbUpdates[packetId] = {
+            ...packet,
+            ...packetDbUpdates[packetId],
+        };
+    }
+    console.log({ response });
+    if (dryRun)
+        return response;
+    await (0, exports.savePacketUpdates)(Object.values(packetDbUpdates));
+    return response;
+};
+exports.checkFailedPackets = checkFailedPackets;
+const checkIfProposed = async (packet) => {
+    let isProposed = false, selectedProposalCount = 0;
+    for (let i = 0; i < 5; i++) {
+        const socketContract = await (0, common_1.getSocket)(packet.dstChainSlug, {});
+        const packetRoot = await socketContract.packetIdRoots(packet.packetId, i, packet.dstSwitchboard);
+        if (packetRoot == packet.root) {
+            isProposed = true;
+            selectedProposalCount = i;
+            break;
+        }
+    }
+    return { isProposed, selectedProposalCount };
+};
+const checkIfAttested = async (packet) => {
+    const fastSwitchboard = await (0, common_1.getFastSwitchboard)(packet.dstChainSlug, {});
+    console.log(packet.root, packet.packetId, packet.selectedProposalCount, packet.srcChainSlug, (0, utils_2.currentTimestampInSeconds)());
+    return await fastSwitchboard.allowPacket(packet.root, packet.packetId, packet.selectedProposalCount, packet.srcChainSlug, (0, utils_2.currentTimestampInSeconds)() - 1000);
+};
+const savePacketUpdates = async (dbUpdates) => {
+    try {
+        if (dbUpdates.length === 0)
+            return;
+        // TODO: fix this
+        await models_1.Packet.bulkCreate(dbUpdates, {
+            updateOnDuplicate: [
+                "isProposed",
+                "proposeRelayStatus",
+                "selectedProposalCount",
+                "isAttested",
+                "attestRelayStatus",
+            ],
+        });
+    }
+    catch (error) {
+        utils_1.logger.error("Error while saving packet trip reason updates", error);
+        throw new Error(`Error while saving packet trip reason updates ${error === null || error === void 0 ? void 0 : error.message}`);
+    }
+};
+exports.savePacketUpdates = savePacketUpdates;

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

@@ -0,0 +1,3 @@
+export * from "./message";
+export * from "./packet";
+export declare const checkAndUpdateStatus: () => Promise<void>;

package/dist/src/statusTrackers/index.js

@@ -0,0 +1,26 @@
+"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 });
+exports.checkAndUpdateStatus = void 0;
+const message_1 = require("./message");
+const packet_1 = require("./packet");
+__exportStar(require("./message"), exports);
+__exportStar(require("./packet"), exports);
+const checkAndUpdateStatus = async () => {
+    await (0, message_1.checkAndUpdateMessageRelayStatus)();
+    await (0, packet_1.checkAndUpdatePacketRelayStatus)();
+};
+exports.checkAndUpdateStatus = checkAndUpdateStatus;

package/dist/src/statusTrackers/message.d.ts

@@ -0,0 +1,4 @@
+import { type TxStatusUpdate } from "../constants";
+export declare const checkAndUpdateMessageRelayStatus: () => Promise<void>;
+export declare const getMessagesByTxId: (txIds: string[]) => Promise<any[]>;
+export declare const updateMessageTxStatus: (updates: TxStatusUpdate[]) => Promise<void>;