@socket.tech/dl-common 1.0.12 → 1.0.13

package/dist/src/services/batcherService.js

@@ -1,197 +0,0 @@
-"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.js

@@ -1,209 +0,0 @@
-"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/signer/socketSigner.js

@@ -1,154 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocketSigner = exports.EIP712_SAFE_TX_TYPE = void 0;
-const relaySigner_1 = require("../relaySigner");
-const ethers_1 = require("ethers");
-const MultiSigWrapper_json_1 = __importDefault(require("@socket.tech/dl-core/artifacts/abi/MultiSigWrapper.json"));
-const Safe_json_1 = __importDefault(require("@socket.tech/dl-core/artifacts/abi/Safe.json"));
-const utils_1 = require("ethers/lib/utils");
-exports.EIP712_SAFE_TX_TYPE = {
-    // "SafeTx(address to,uint256 value,bytes data,uint8 operation,uint256 safeTxGas,uint256 baseGas,uint256 gasPrice,address gasToken,address refundReceiver,uint256 nonce)"
-    SafeTx: [
-        { type: "address", name: "to" },
-        { type: "uint256", name: "value" },
-        { type: "bytes", name: "data" },
-        { type: "uint8", name: "operation" },
-        { type: "uint256", name: "safeTxGas" },
-        { type: "uint256", name: "baseGas" },
-        { type: "uint256", name: "gasPrice" },
-        { type: "address", name: "gasToken" },
-        { type: "address", name: "refundReceiver" },
-        { type: "uint256", name: "nonce" },
-    ],
-};
-class SocketSigner extends relaySigner_1.SocketRelaySigner {
-    constructor(provider, chainId, 
-    // address of safe
-    safeAddress, 
-    // address of safe wrapper to store sign
-    safeWrapperAddress, relayUrl, relayerAPIKey, 
-    // wallet for signing safe hash data
-    signingWallet, 
-    // if you want to relay tx to wrapper
-    useSafe = false, 
-    // if you want to relay tx using EOA, otherwise it will use relayer
-    useEOA = false, sequential = false, 
-    // if isCritical is set to true, will try multiple relayers
-    // to get the transaction included
-    isCritical = false, metadata = {}) {
-        super(provider, chainId, relayUrl, relayerAPIKey, sequential, isCritical, metadata);
-        this.provider = provider;
-        this.chainId = chainId;
-        this.safeAddress = safeAddress;
-        this.safeWrapperAddress = safeWrapperAddress;
-        this.relayUrl = relayUrl;
-        this.relayerAPIKey = relayerAPIKey;
-        this.signingWallet = signingWallet;
-        this.useSafe = useSafe;
-        this.useEOA = useEOA;
-        this.sequential = sequential;
-        this.isCritical = isCritical;
-        this.metadata = metadata;
-        this.address =
-            this.signingWallet != null
-                ? this.signingWallet.address
-                : "0x5367Efc17020Aa1CF0943bA7eD17f1D3e4c7d7EE";
-        if (this.safeWrapperAddress.length !== 0 ||
-            this.safeWrapperAddress !== ethers_1.constants.AddressZero)
-            this.safeWrapperContract = new ethers_1.Contract(this.safeWrapperAddress, MultiSigWrapper_json_1.default, this.provider);
-        if (this.safeAddress.length !== 0 ||
-            this.safeAddress !== ethers_1.constants.AddressZero)
-            this.safeContract = new ethers_1.Contract(this.safeAddress, Safe_json_1.default, this.provider);
-    }
-    setSigningWallet(signingWallet) {
-        return new SocketSigner(this.provider, this.chainId, this.safeAddress, this.safeWrapperAddress, this.relayUrl, this.relayerAPIKey, signingWallet, this.useSafe, this.useEOA, this.sequential, this.isCritical, this.metadata);
-    }
-    setSafeWrapperAddress(safeWrapperAddress) {
-        return new SocketSigner(this.provider, this.chainId, this.safeAddress, safeWrapperAddress, this.relayUrl, this.relayerAPIKey, this.signingWallet, this.useSafe, this.useEOA, this.sequential, this.isCritical, this.metadata);
-    }
-    setSafeAddress(safeAddress) {
-        return new SocketSigner(this.provider, this.chainId, safeAddress, this.safeWrapperAddress, this.relayUrl, this.relayerAPIKey, this.signingWallet, this.useSafe, this.useEOA, this.sequential, this.isCritical, this.metadata);
-    }
-    async getAddress() {
-        if (this.signingWallet != null)
-            return this.signingWallet.address;
-        return await super.getAddress();
-    }
-    async sendTransaction(transaction) {
-        var _a, _b;
-        if (this.useSafe) {
-            if (this.safeAddress.length === 0 ||
-                this.safeAddress === ethers_1.constants.AddressZero)
-                throw new Error("safeAddress not provided");
-            if (this.safeWrapperContract == null)
-                throw new Error("safe wrapper not provided");
-            if (this.signingWallet == null)
-                throw new Error("signingWallet not provided");
-            const signerAddress = await this.getAddress();
-            const safeNonce = Number(await this.safeContract.nonce());
-            let nonce = Number(await this.safeWrapperContract.lastNonce(signerAddress));
-            if (safeNonce != 0) {
-                nonce = safeNonce > nonce ? safeNonce : nonce + 1;
-            }
-            else if (nonce !== 0)
-                nonce++;
-            if (await this.isTxHashSubmitted(transaction))
-                throw new Error("tx already submitted!");
-            const contractData = {
-                to: transaction.to,
-                value: (_a = transaction.value) !== null && _a !== void 0 ? _a : 0,
-                data: (_b = transaction.data) !== null && _b !== void 0 ? _b : "0x",
-                operation: 0,
-                safeTxGas: 0,
-                baseGas: 0,
-                gasPrice: 0,
-                gasToken: ethers_1.constants.AddressZero,
-                refundReceiver: ethers_1.constants.AddressZero,
-                nonce,
-            };
-            const signature = await this.signingWallet._signTypedData({ verifyingContract: this.safeAddress, chainId: this.chainId }, exports.EIP712_SAFE_TX_TYPE, contractData);
-            // update to & data
-            transaction.data = this.safeWrapperContract.interface.encodeFunctionData("storeOrRelaySignatures", [
-                this.signingWallet.address,
-                contractData.to,
-                nonce,
-                contractData.value,
-                contractData.data,
-                signature,
-            ]);
-            transaction.to = this.safeWrapperAddress;
-        }
-        if (this.useEOA) {
-            if (this.signingWallet == null)
-                throw new Error("signingWallet not provided");
-            return await this.signingWallet.sendTransaction(transaction);
-        }
-        return await super.sendTransaction(transaction);
-    }
-    async signMessage(message) {
-        if (!this.signingWallet)
-            throw Error("No Signing Wallet found!");
-        return await this.signingWallet.signMessage(message);
-    }
-    async isTxHashSubmitted(transaction) {
-        var _a, _b;
-        if (!this.signingWallet)
-            throw Error("No Signing Wallet found!");
-        const dataHash = (0, utils_1.keccak256)(utils_1.defaultAbiCoder.encode(["address", "uint256", "bytes"], [transaction.to, (_a = transaction.value) !== null && _a !== void 0 ? _a : 0, (_b = transaction.data) !== null && _b !== void 0 ? _b : "0x"]));
-        const safeParams = await this.safeWrapperContract.safeParams(dataHash, this.signingWallet.address);
-        console.log(safeParams, "isTxSubmitted");
-        return safeParams[1] !== "0x";
-    }
-    async checkAndSendTransaction(transaction) {
-        const isSubmitted = await this.isTxHashSubmitted(transaction);
-        if (isSubmitted)
-            return { txSent: false, txHash: "" };
-        const tx = await this.sendTransaction(transaction);
-        await tx.wait();
-        return { txSent: true, txHash: tx.hash };
-    }
-}
-exports.SocketSigner = SocketSigner;