@socket.tech/dl-common 1.0.1

package/dist/services/cacheService.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendCommand = exports.decrement = exports.increment = exports.getListLength = exports.lpop = exports.rpush = exports.setKey = exports.unlock = exports.deleteKey = exports.lock = exports.getKey = exports.formatKey = exports.initCache = exports.client = void 0;
+const redis = require("async-redis");
+let deploymentStage;
+const initCache = (host, port, password, stage) => {
+    exports.client = redis.createClient({
+        port,
+        host,
+        password,
+    });
+    deploymentStage = stage;
+};
+exports.initCache = initCache;
+const formatKey = (key) => {
+    return deploymentStage + "_" + key;
+};
+exports.formatKey = formatKey;
+const getKey = async (key) => {
+    return await exports.client.get((0, exports.formatKey)(key));
+};
+exports.getKey = getKey;
+const lock = async (key, expire = 0) => {
+    let result = await (0, exports.setKey)(key, "locked", expire, true);
+    if (result)
+        console.log("acquired lock!");
+    else
+        console.log("blocked");
+    return result;
+};
+exports.lock = lock;
+const deleteKey = async (key) => {
+    let result = await exports.client.del((0, exports.formatKey)(key));
+    if (result)
+        console.log("deleted ", (0, exports.formatKey)(key));
+};
+exports.deleteKey = deleteKey;
+const unlock = async (key) => {
+    let result = await exports.client.del((0, exports.formatKey)(key));
+    if (result)
+        console.log("unlocked");
+};
+exports.unlock = unlock;
+const setKey = async (key, value, expire = 0, setIfNotExist = false) => {
+    let params = [(0, exports.formatKey)(key), value];
+    if (expire > 0)
+        params.push("EX", expire);
+    if (setIfNotExist)
+        params.push("NX");
+    console.log("command : SET ", params);
+    let response = await exports.client.sendCommand("SET", params);
+    if (response) {
+        console.log((0, exports.formatKey)(key) + " set to => " + value);
+        return true;
+    }
+    else
+        return false;
+};
+exports.setKey = setKey;
+const rpush = async (key, values) => {
+    return await exports.client.rpush((0, exports.formatKey)(key), values);
+};
+exports.rpush = rpush;
+const lpop = async (key) => {
+    return await exports.client.lpop((0, exports.formatKey)(key));
+};
+exports.lpop = lpop;
+const getListLength = async (key) => {
+    return await exports.client.llen((0, exports.formatKey)(key));
+};
+exports.getListLength = getListLength;
+const increment = async (key) => {
+    let value = await exports.client.incr((0, exports.formatKey)(key));
+    console.log("incremented key : ", (0, exports.formatKey)(key), " value : ", value);
+    return value;
+};
+exports.increment = increment;
+const decrement = async (key) => {
+    let value = await exports.client.decr((0, exports.formatKey)(key));
+    console.log("decremented key : ", (0, exports.formatKey)(key), " value : ", value);
+    return value;
+};
+exports.decrement = decrement;
+const sendCommand = async (command, params) => {
+    params[0] = (0, exports.formatKey)(params[0]);
+    let result = await exports.client.sendCommand(command, params);
+    return result;
+};
+exports.sendCommand = sendCommand;

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./queueService";
+export * from "./cacheService";

package/dist/services/index.js

@@ -0,0 +1,19 @@
+"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("./queueService"), exports);
+__exportStar(require("./cacheService"), exports);
+// export * from "./apiService";

package/dist/services/queueService.d.ts

@@ -0,0 +1,10 @@
+export declare const initQueue: (region: string) => void;
+export declare const sendStandardSqsMessage: (queueUrl: string, data: any, DelaySeconds?: number) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
+export declare const sendStandardBatchMessages: (QueueUrl: string, dataArray: any[], DelaySecondsArray?: number[]) => Promise<import("@aws-sdk/client-sqs").SendMessageBatchCommandOutput>;
+export declare const sendFifoSqsMessage: (queueUrl: string, data: any, MessageGroupId: string) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
+declare const _default: {
+    sendStandardSqsMessage: (queueUrl: string, data: any, DelaySeconds?: number) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
+    sendFifoSqsMessage: (queueUrl: string, data: any, MessageGroupId: string) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
+    sendStandardBatchMessages: (QueueUrl: string, dataArray: any[], DelaySecondsArray?: number[]) => Promise<import("@aws-sdk/client-sqs").SendMessageBatchCommandOutput>;
+};
+export default _default;

package/dist/services/queueService.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendFifoSqsMessage = exports.sendStandardBatchMessages = exports.sendStandardSqsMessage = exports.initQueue = void 0;
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+let client;
+const initQueue = (region) => {
+    client = new client_sqs_1.SQSClient({ region });
+};
+exports.initQueue = initQueue;
+const sendStandardSqsMessage = async (queueUrl, data, DelaySeconds = 0) => {
+    let sqsOrderData = {
+        MessageBody: JSON.stringify(data),
+        QueueUrl: queueUrl,
+        DelaySeconds,
+    };
+    // Send the order data to the SQS queue
+    const command = new client_sqs_1.SendMessageCommand(sqsOrderData);
+    let result = await client.send(command);
+    return result;
+};
+exports.sendStandardSqsMessage = sendStandardSqsMessage;
+const sendStandardBatchMessages = async (QueueUrl, dataArray, DelaySecondsArray = []) => {
+    let Entries = [];
+    for (let i = 0; i < dataArray.length; i++) {
+        Entries.push({
+            MessageBody: JSON.stringify(dataArray[i]),
+            Id: i,
+            DelaySeconds: DelaySecondsArray[i] ? DelaySecondsArray[i] : 0,
+        });
+    }
+    let sqsOrderData = {
+        Entries,
+        QueueUrl,
+    };
+    // Send the order data to the SQS queue
+    const command = new client_sqs_1.SendMessageBatchCommand(sqsOrderData);
+    let result = await client.send(command);
+    return result;
+};
+exports.sendStandardBatchMessages = sendStandardBatchMessages;
+const sendFifoSqsMessage = async (queueUrl, data, MessageGroupId) => {
+    let sqsOrderData = {
+        MessageBody: JSON.stringify(data),
+        QueueUrl: queueUrl,
+        MessageGroupId,
+    };
+    // Send the order data to the SQS queue
+    const command = new client_sqs_1.SendMessageCommand(sqsOrderData);
+    let result = await client.send(command);
+    return result;
+};
+exports.sendFifoSqsMessage = sendFifoSqsMessage;
+exports.default = {
+    sendStandardSqsMessage: exports.sendStandardSqsMessage,
+    sendFifoSqsMessage: exports.sendFifoSqsMessage,
+    sendStandardBatchMessages: exports.sendStandardBatchMessages,
+};

package/dist/types/codes.d.ts

@@ -0,0 +1,22 @@
+export declare enum MessageStatuses {
+    RECEIVED = "RECEIVED",
+    SEALED = "SEALED",
+    PROPOSED = "PROPOSED",
+    CONFIRMED = "CONFIRMED",
+    EXECUTION_SUCCESS = "EXECUTION_SUCCESS",
+    EXECUTION_FAILURE = "EXECUTION_FAILURE"
+}
+export declare enum MessageStatusStep {
+    RECEIVED = 0,
+    SEALED = 1,
+    PROPOSED = 2,
+    CONFIRMED = 3,
+    EXECUTION_SUCCESS = 4,
+    EXECUTION_FAILURE = 5
+}
+export declare enum StatusCodes {
+    SUCCESS = "SUCCESS",
+    NOT_FOUND = "NOT_FOUND",
+    BAD_REQUEST = "BAD_REQUEST",
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
+}

package/dist/types/codes.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCodes = exports.MessageStatusStep = exports.MessageStatuses = void 0;
+var MessageStatuses;
+(function (MessageStatuses) {
+    MessageStatuses["RECEIVED"] = "RECEIVED";
+    MessageStatuses["SEALED"] = "SEALED";
+    MessageStatuses["PROPOSED"] = "PROPOSED";
+    MessageStatuses["CONFIRMED"] = "CONFIRMED";
+    MessageStatuses["EXECUTION_SUCCESS"] = "EXECUTION_SUCCESS";
+    MessageStatuses["EXECUTION_FAILURE"] = "EXECUTION_FAILURE";
+})(MessageStatuses || (exports.MessageStatuses = MessageStatuses = {}));
+var MessageStatusStep;
+(function (MessageStatusStep) {
+    MessageStatusStep[MessageStatusStep["RECEIVED"] = 0] = "RECEIVED";
+    MessageStatusStep[MessageStatusStep["SEALED"] = 1] = "SEALED";
+    MessageStatusStep[MessageStatusStep["PROPOSED"] = 2] = "PROPOSED";
+    MessageStatusStep[MessageStatusStep["CONFIRMED"] = 3] = "CONFIRMED";
+    MessageStatusStep[MessageStatusStep["EXECUTION_SUCCESS"] = 4] = "EXECUTION_SUCCESS";
+    MessageStatusStep[MessageStatusStep["EXECUTION_FAILURE"] = 5] = "EXECUTION_FAILURE";
+})(MessageStatusStep || (exports.MessageStatusStep = MessageStatusStep = {}));
+var StatusCodes;
+(function (StatusCodes) {
+    StatusCodes["SUCCESS"] = "SUCCESS";
+    StatusCodes["NOT_FOUND"] = "NOT_FOUND";
+    StatusCodes["BAD_REQUEST"] = "BAD_REQUEST";
+    StatusCodes["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+})(StatusCodes || (exports.StatusCodes = StatusCodes = {}));

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./codes";
+export * from "./types";

package/dist/types/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("./codes"), exports);
+__exportStar(require("./types"), exports);

package/dist/types/types.d.ts

@@ -0,0 +1,86 @@
+import { StatusCodes } from "./codes";
+export type Speed = "safeLow" | "average" | "fast" | "fastest";
+export declare enum InboundStatus {
+    NOT_TRIED = "NOT_TRIED",
+    REVERTING = "REVERTING",
+    EXECUTING = "EXECUTING",
+    SUCCESS = "SUCCESS"
+}
+export interface FeeEstimate {
+    transmissionFees: string;
+    verificationFees: string;
+    executionFees: string;
+    totalFees: string;
+}
+export declare enum RelayerAPIStatus {
+    FAILED = "FAILED",
+    SIMULATION_FAILED = "SIMULATION_FAILED",
+    COMPLETED = "COMPLETED"
+}
+export declare class ServerError {
+    code: Omit<StatusCodes, StatusCodes.SUCCESS>;
+    message?: string;
+    constructor(code: Omit<StatusCodes, StatusCodes.SUCCESS>, message?: string);
+    toString(): string;
+}
+export declare class BadRequestError {
+    code: Omit<StatusCodes, StatusCodes.SUCCESS>;
+    message?: string;
+    constructor(message?: string);
+    toString(): string;
+}
+export interface EthersError {
+    reason?: string;
+    code?: string;
+    argument?: string;
+    value?: string;
+}
+export type SealParams = {
+    srcChainSlug: number;
+    dstChainSlug: number;
+    dstSwitchboard: string;
+    message: {
+        messageId: string;
+        srcPlug: string;
+        destPlug: string;
+        minMsgGasLimit: string;
+        executionParams: string;
+        transmissionParams: string;
+        executionFee: string;
+        transmissionFees: string;
+        switchboardFees: string;
+        fees: string;
+        decapacitorProof: string;
+        payload: string;
+        packedMessage: string;
+        outboundTxHash: string;
+        outboundTime: number;
+        capacitorMsgCount: string;
+    };
+    packet: {
+        capacitorPacketCount: string;
+        rootHash: string;
+        packetId: string;
+        srcCapacitor: string;
+        root: string;
+        sealSignature: string;
+    };
+};
+export type SealIndexedParams = {
+    srcChainSlug: number;
+    sealer: string;
+    sealTime: number;
+    sealTxHash: string;
+    rootSealed: string;
+    dstSwitchboard: string;
+    sealSignature: string;
+    packetId: string;
+};
+export interface ExecuteSigResponse {
+    messageId: string;
+    retry: boolean;
+    inboundSuccess: boolean;
+    inboundRevertString: string;
+    executeSignature: string;
+    executeMsgGasLimit: string;
+}

package/dist/types/types.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = exports.ServerError = exports.RelayerAPIStatus = exports.InboundStatus = void 0;
+const codes_1 = require("./codes");
+var InboundStatus;
+(function (InboundStatus) {
+    InboundStatus["NOT_TRIED"] = "NOT_TRIED";
+    InboundStatus["REVERTING"] = "REVERTING";
+    InboundStatus["EXECUTING"] = "EXECUTING";
+    InboundStatus["SUCCESS"] = "SUCCESS";
+})(InboundStatus || (exports.InboundStatus = InboundStatus = {}));
+var RelayerAPIStatus;
+(function (RelayerAPIStatus) {
+    RelayerAPIStatus["FAILED"] = "FAILED";
+    RelayerAPIStatus["SIMULATION_FAILED"] = "SIMULATION_FAILED";
+    RelayerAPIStatus["COMPLETED"] = "COMPLETED";
+})(RelayerAPIStatus || (exports.RelayerAPIStatus = RelayerAPIStatus = {}));
+class ServerError {
+    constructor(code, message) {
+        this.code = code;
+        if (message) {
+            this.message = message;
+        }
+    }
+    toString() {
+        return `code: ${this.code}, message: ${this.message}`;
+    }
+}
+exports.ServerError = ServerError;
+class BadRequestError {
+    constructor(message) {
+        this.code = codes_1.StatusCodes.BAD_REQUEST;
+        if (message) {
+            this.message = message;
+        }
+    }
+    toString() {
+        return `code: ${this.code}, message: ${this.message}`;
+    }
+}
+exports.BadRequestError = BadRequestError;

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,47 @@
+"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 axiosGet = async (url, config = {}, errorLogging = false) => {
+    var _a, _b, _c, _d;
+    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;
+    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.chunks = exports.MAX_PAYLOAD_SIZE = void 0;
+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);
+    }
+}
+exports.chunks = chunks;

package/dist/utils/discord.d.ts

@@ -0,0 +1 @@
+export declare const sendToDiscordWebhook: (data: any) => Promise<void>;

package/dist/utils/discord.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToDiscordWebhook = void 0;
+const axios_1 = require("./axios");
+const sendToDiscordWebhook = async (data) => {
+    try {
+        const discordWebhookUrl = process.env.DISCORD_WEBHOOK_URL;
+        if (!discordWebhookUrl) {
+            throw new Error("DISCORD_WEBHOOK_URL not provided");
+        }
+        await (0, axios_1.axiosPost)(discordWebhookUrl, { content: JSON.stringify(data) });
+    }
+    catch (error) {
+        throw error;
+    }
+};
+exports.sendToDiscordWebhook = sendToDiscordWebhook;

package/dist/utils/extraUtils.d.ts

@@ -0,0 +1,22 @@
+export declare const removeFields: (obj: any, fieldsToRemove: string[]) => any;
+export declare const filterFields: (obj: any, fieldsAllowed: string[]) => any;
+/**
+ * util function to return body response.
+ * params: statusCode, message, data.
+//  */
+export declare const responseBody: (statusCode?: number, message?: null | string, data?: any, success?: boolean, error_code?: number | null) => {
+    statusCode: number;
+    headers: {
+        "Access-Control-Allow-Origin": string;
+        "Access-Control-Allow-Credentials": boolean;
+    };
+    body: string;
+};
+declare const _default: {
+    isEmpty: (data: any) => boolean;
+    checkMissingFields: (fields: any) => void;
+    checkMissingFieldsAndType: (fields: any, types?: any) => void;
+    removeFields: (obj: any, fieldsToRemove: string[]) => any;
+    filterFields: (obj: any, fieldsAllowed: string[]) => any;
+};
+export default _default;

package/dist/utils/extraUtils.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseBody = exports.filterFields = exports.removeFields = void 0;
+/**
+ * defining functions.
+ */
+const isEmpty = (data) => {
+    if (data === undefined || data === null || data === "") {
+        return true;
+    }
+    else {
+        return false;
+    }
+}; // end of isEmpty.
+const checkMissingFields = (fields) => {
+    for (const field in fields) {
+        if (isEmpty(fields[field])) {
+            throw { message: `missing field : ${field}`, code: 1 };
+        }
+    }
+};
+const checkMissingFieldsAndType = (fields, types = {}) => {
+    for (const field in fields) {
+        if (isEmpty(fields[field])) {
+            throw { message: `missing field : ${field}`, code: 1 };
+        }
+        if (types[field] && typeof fields[field] !== types[field]) {
+            throw {
+                message: `Type of ${field} expected : "${types[field]}", got : "${typeof fields[field]}"`,
+                code: 1,
+            };
+        }
+    }
+};
+const removeFields = (obj, fieldsToRemove) => {
+    for (const field in obj) {
+        if (fieldsToRemove.includes(field)) {
+            delete obj[field];
+        }
+    }
+    return obj;
+};
+exports.removeFields = removeFields;
+const filterFields = (obj, fieldsAllowed) => {
+    const finalObj = {};
+    for (const field in obj) {
+        if (fieldsAllowed.includes(field)) {
+            finalObj[field] = obj[field];
+        }
+    }
+    return finalObj;
+};
+exports.filterFields = filterFields;
+/**
+ * util function to return body response.
+ * params: statusCode, message, data.
+//  */
+const responseBody = (statusCode = 400, message = null, data = null, success = true, error_code = null) => {
+    // If no proper message present, or error code is not 1 => system generated error, return standard error message.
+    if (statusCode == 400 && (!message || error_code !== 1)) {
+        message = "BAD_REQUEST";
+    }
+    error_code = null;
+    return {
+        statusCode,
+        headers: {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Credentials": true,
+        },
+        body: JSON.stringify({
+            success,
+            error_code,
+            message,
+            data,
+        }),
+    };
+}; // end responseBody function.
+exports.responseBody = responseBody;
+exports.default = {
+    isEmpty,
+    checkMissingFields,
+    checkMissingFieldsAndType,
+    removeFields: exports.removeFields,
+    filterFields: exports.filterFields,
+};

package/dist/utils/idUtils.d.ts

@@ -0,0 +1,13 @@
+export interface PacketDetails {
+    chainSlug: number;
+    capacitorAddr: string;
+    packetNonce: string;
+}
+export interface MessageDetails {
+    chainSlug: number;
+    siblingPlug: string;
+    globalMessageCount: string;
+}
+export declare const unpackPacketId: (packetId: string) => PacketDetails;
+export declare const unpackMessageId: (messageId: string) => MessageDetails;
+export declare const packPacketId: (chainSlug: number, capacitorAddr: string, packetNonce: string) => string;

package/dist/utils/idUtils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packPacketId = exports.unpackMessageId = exports.unpackPacketId = void 0;
+const ethers_1 = require("ethers");
+const address_1 = require("./address");
+const utils_1 = require("ethers/lib/utils");
+const unpackPacketId = (packetId) => {
+    // 2(0x) + 1-8(chain slug) + 40(address) + 16(nonce)
+    const slugLength = packetId.length - 58;
+    const chainSlug = parseInt(ethers_1.BigNumber.from(`0x${packetId.substring(2, 2 + slugLength)}`).toString());
+    const capacitorAddr = (0, address_1.toLowerCase)(`0x${packetId.substring(2 + slugLength, 40 + 2 + slugLength)}`);
+    const packetNonce = ethers_1.BigNumber.from(`0x${packetId.substring(40 + 2 + slugLength)}`).toString();
+    return {
+        chainSlug,
+        capacitorAddr,
+        packetNonce,
+    };
+};
+exports.unpackPacketId = unpackPacketId;
+const unpackMessageId = (messageId) => {
+    // 2(0x) + 1-8(chain slug) + 40(address) + 16(nonce)
+    const slugLength = messageId.length - 58;
+    const chainSlug = parseInt(ethers_1.BigNumber.from(`0x${messageId.substring(2, 2 + slugLength)}`).toString());
+    const siblingPlug = (0, address_1.toLowerCase)(`0x${messageId.substring(2 + slugLength, 40 + 2 + slugLength)}`);
+    const globalMessageCount = ethers_1.BigNumber.from(`0x${messageId.substring(40 + 2 + slugLength)}`).toString();
+    return {
+        chainSlug,
+        siblingPlug,
+        globalMessageCount,
+    };
+};
+exports.unpackMessageId = unpackMessageId;
+const packPacketId = (chainSlug, capacitorAddr, packetNonce) => {
+    const nonce = ethers_1.BigNumber.from(packetNonce).toHexString();
+    const nonceHex = nonce.length <= 16 ? (0, utils_1.hexZeroPad)(nonce, 8).substring(2) : nonce.substring(2);
+    const slug = ethers_1.BigNumber.from(chainSlug).toHexString();
+    const slugHex = slug.length <= 10 ? (0, utils_1.hexZeroPad)(slug, 4) : slug;
+    const id = slugHex + capacitorAddr.substring(2) + nonceHex;
+    return id.toLowerCase();
+};
+exports.packPacketId = packPacketId;

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./axios";
+export * from "./discord";
+export * from "./relaySigner";
+export * from "./idUtils";
+export * from "./address";
+export * from "./dataStructHelper";
+export * from "./extraUtils";