@socket.tech/dl-common 1.0.2 → 1.0.3-test.10

package/dist/models/packet.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PacketModel = exports.Packet = exports.TripReason = exports.AttestRelayStatus = exports.ProposeRelayStatus = exports.PacketTripRelayStatus = exports.SealRelayStatus = void 0;
+exports.addPacketHooks = exports.PacketModel = exports.Packet = exports.TripReason = exports.AttestRelayStatus = exports.ProposeRelayStatus = exports.PacketTripRelayStatus = exports.SealRelayStatus = void 0;
 const dl_core_1 = require("@socket.tech/dl-core");
 const sequelize_1 = require("sequelize");
+const utils_1 = require("../utils");
 var SealRelayStatus;
 (function (SealRelayStatus) {
     SealRelayStatus["SEALED"] = "SEALED";
@@ -124,6 +125,12 @@ exports.PacketModel = {
     outboundTime: {
         type: sequelize_1.DataTypes.INTEGER,
     },
+    proposeTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    attestTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
     sealTime: {
         type: sequelize_1.DataTypes.INTEGER,
     },
@@ -170,6 +177,9 @@ exports.PacketModel = {
     selectedProposalCount: {
         type: sequelize_1.DataTypes.INTEGER,
     },
+    executionWaitTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
     attestTxId: {
         type: sequelize_1.DataTypes.STRING,
         defaultValue: "",
@@ -193,3 +203,39 @@ exports.PacketModel = {
         defaultValue: AttestRelayStatus.NO,
     },
 };
+function processStrings(packet) {
+    if (packet.packetId)
+        packet.packetId = (0, utils_1.toLowerCase)(packet.packetId);
+    if (packet.root)
+        packet.root = (0, utils_1.toLowerCase)(packet.root);
+    if (packet.rootSealed)
+        packet.rootSealed = (0, utils_1.toLowerCase)(packet.rootSealed);
+    if (packet.sealer)
+        packet.sealer = (0, utils_1.toLowerCase)(packet.sealer);
+    if (packet.outboundTxHash) {
+        packet.outboundTxHash = (0, utils_1.toLowerCase)(packet.outboundTxHash);
+    }
+    if (packet.sealTxHash)
+        packet.sealTxHash = (0, utils_1.toLowerCase)(packet.sealTxHash);
+    if (packet.sealSignature) {
+        packet.sealSignature = (0, utils_1.toLowerCase)(packet.sealSignature);
+    }
+    if (packet.dstSwitchboard) {
+        packet.dstSwitchboard = (0, utils_1.toLowerCase)(packet.dstSwitchboard);
+    }
+    if (packet.packetTripTxHash) {
+        packet.packetTripTxHash = (0, utils_1.toLowerCase)(packet.packetTripTxHash);
+    }
+    return packet;
+}
+const addPacketHooks = () => {
+    Packet.beforeBulkCreate((packet, options) => {
+        for (let index = 0; index < packet.length; index++) {
+            packet[index] = processStrings(packet[index]);
+        }
+    });
+    Packet.beforeSave((packet, options) => {
+        packet = processStrings(packet);
+    });
+};
+exports.addPacketHooks = addPacketHooks;

package/dist/models/proposal.d.ts

@@ -124,3 +124,4 @@ export declare const ProposalModel: {
         defaultValue: boolean;
     };
 };
+export declare const addProposalHooks: () => void;

package/dist/models/proposal.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProposalModel = exports.Proposal = exports.ProposalTripRelayStatus = exports.MatchState = exports.RootMatchState = exports.TripStatus = void 0;
+exports.addProposalHooks = exports.ProposalModel = exports.Proposal = exports.ProposalTripRelayStatus = exports.MatchState = exports.RootMatchState = exports.TripStatus = void 0;
 const sequelize_1 = require("sequelize");
+const utils_1 = require("../utils");
 var TripStatus;
 (function (TripStatus) {
     TripStatus["TRIP_REQUIRED"] = "TRIP_REQUIRED";
@@ -112,3 +113,29 @@ exports.ProposalModel = {
         defaultValue: false,
     },
 };
+function processStrings(proposal) {
+    if (proposal.packetId)
+        proposal.packetId = (0, utils_1.toLowerCase)(proposal.packetId);
+    if (proposal.root)
+        proposal.root = (0, utils_1.toLowerCase)(proposal.root);
+    if (proposal.switchboard)
+        proposal.switchboard = (0, utils_1.toLowerCase)(proposal.switchboard);
+    if (proposal.proposer)
+        proposal.proposer = (0, utils_1.toLowerCase)(proposal.proposer);
+    if (proposal.proposeTxHash)
+        proposal.proposeTxHash = (0, utils_1.toLowerCase)(proposal.proposeTxHash);
+    if (proposal.tripTxHash)
+        proposal.tripTxHash = (0, utils_1.toLowerCase)(proposal.tripTxHash);
+    return proposal;
+}
+const addProposalHooks = () => {
+    Proposal.beforeBulkCreate((proposal, options) => {
+        for (let index = 0; index < proposal.length; index++) {
+            proposal[index] = processStrings(proposal[index]);
+        }
+    });
+    Proposal.beforeSave((proposal, options) => {
+        proposal = processStrings(proposal);
+    });
+};
+exports.addProposalHooks = addProposalHooks;

package/dist/models/switchboard.d.ts

@@ -0,0 +1,61 @@
+import { IntegrationTypes } from "@socket.tech/dl-core";
+import { DataTypes, Model } from "sequelize";
+export declare enum CapacitorType {
+    singleCapacitor = "1",
+    hashChainCapacitor = "2"
+}
+export declare class Switchboard extends Model {
+    id: number;
+    srcChainSlug: number;
+    dstChainSlug: number;
+    maxPacketLength: number;
+    srcSwitchboard: string;
+    dstSwitchboard: string;
+    srcCapacitor: string;
+    capacitorType: CapacitorType;
+    isEnabled: boolean;
+    integrationType: IntegrationTypes;
+}
+export declare const SwitchboardModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+        primaryKey: boolean;
+    };
+    srcChainSlug: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        unique: string;
+    };
+    dstChainSlug: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        unique: string;
+    };
+    maxPacketLength: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    srcSwitchboard: {
+        type: DataTypes.StringDataTypeConstructor;
+        unique: string;
+    };
+    dstSwitchboard: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    srcCapacitor: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    capacitorType: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: CapacitorType[];
+        defaultValue: CapacitorType;
+    };
+    isEnabled: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    integrationType: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: IntegrationTypes[];
+        defaultValue: IntegrationTypes;
+    };
+};
+export declare const addSwitchboardHooks: () => Promise<void>;

package/dist/models/switchboard.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSwitchboardHooks = exports.SwitchboardModel = exports.Switchboard = exports.CapacitorType = void 0;
+const dl_core_1 = require("@socket.tech/dl-core");
+const sequelize_1 = require("sequelize");
+var CapacitorType;
+(function (CapacitorType) {
+    CapacitorType["singleCapacitor"] = "1";
+    CapacitorType["hashChainCapacitor"] = "2";
+})(CapacitorType || (exports.CapacitorType = CapacitorType = {}));
+class Switchboard extends sequelize_1.Model {
+}
+exports.Switchboard = Switchboard;
+exports.SwitchboardModel = {
+    id: {
+        type: sequelize_1.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+    },
+    srcChainSlug: {
+        type: sequelize_1.DataTypes.INTEGER,
+        unique: "uniqueSwitchboardPointer",
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.INTEGER,
+        unique: "uniqueSwitchboardPointer",
+    },
+    maxPacketLength: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    srcSwitchboard: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueSwitchboardPointer",
+    },
+    dstSwitchboard: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    srcCapacitor: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    capacitorType: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(CapacitorType)],
+        defaultValue: CapacitorType.singleCapacitor,
+    },
+    isEnabled: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    integrationType: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(dl_core_1.IntegrationTypes)],
+        defaultValue: dl_core_1.IntegrationTypes.unknown,
+    },
+};
+const addSwitchboardHooks = async () => {
+    Switchboard.beforeBulkCreate((switchboards, options) => {
+        for (let index = 0; index < switchboards.length; index++) {
+            switchboards[index] = processStrings(switchboards[index]);
+        }
+    });
+    Switchboard.beforeSave((switchboard, options) => {
+        switchboard = processStrings(switchboard);
+    });
+};
+exports.addSwitchboardHooks = addSwitchboardHooks;
+function processStrings(switchboard) {
+    if (switchboard.srcSwitchboard)
+        switchboard.srcSwitchboard = switchboard.srcSwitchboard.toLowerCase();
+    if (switchboard.dstSwitchboard)
+        switchboard.dstSwitchboard = switchboard.dstSwitchboard.toLowerCase();
+    if (switchboard.srcCapacitor)
+        switchboard.srcCapacitor = switchboard.srcCapacitor.toLowerCase();
+    return switchboard;
+}

package/dist/services/cacheService.d.ts

@@ -1,10 +1,10 @@
 export declare let client: any;
-export declare const initCache: (host: string, port: number, password: string, stage: string) => void;
+export declare const initCache: (host: string, port: number, password: string, stage: string, serviceName: string) => void;
 export declare const formatKey: (key: string) => string;
 export declare const getKey: (key: string) => Promise<any>;
 export declare const lock: (key: string, expire?: number) => Promise<boolean>;
-export declare const deleteKey: (key: string) => Promise<void>;
-export declare const unlock: (key: string) => Promise<void>;
+export declare const deleteKey: (key: string) => Promise<any>;
+export declare const unlock: (key: string) => Promise<any>;
 export declare const setKey: (key: string, value: any, expire?: number, setIfNotExist?: boolean) => Promise<boolean>;
 export declare const rpush: (key: string, values: any[]) => Promise<any>;
 export declare const lpop: (key: string) => Promise<any>;

package/dist/services/cacheService.js

@@ -3,17 +3,19 @@ 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) => {
+let servicePrefix;
+const initCache = (host, port, password, stage, serviceName) => {
     exports.client = redis.createClient({
         port,
         host,
         password,
     });
     deploymentStage = stage;
+    servicePrefix = serviceName;
 };
 exports.initCache = initCache;
 const formatKey = (key) => {
-    return deploymentStage + "_" + key;
+    return deploymentStage + "_" + servicePrefix + "_" + key;
 };
 exports.formatKey = formatKey;
 const getKey = async (key) => {
@@ -21,24 +23,15 @@ const getKey = async (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;
+    return await (0, exports.setKey)(key, "locked", expire, true);
 };
 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));
+    return await exports.client.del((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");
+    return await exports.client.del((0, exports.formatKey)(key));
 };
 exports.unlock = unlock;
 const setKey = async (key, value, expire = 0, setIfNotExist = false) => {
@@ -47,10 +40,8 @@ const setKey = async (key, value, expire = 0, setIfNotExist = false) => {
         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
@@ -76,14 +67,11 @@ const increment = async (key) => {
 };
 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;
+    return await exports.client.decr((0, exports.formatKey)(key));
 };
 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;
+    return await exports.client.sendCommand(command, params);
 };
 exports.sendCommand = sendCommand;

package/dist/services/queueService.js

@@ -15,8 +15,7 @@ const sendStandardSqsMessage = async (queueUrl, data, DelaySeconds = 0) => {
     };
     // Send the order data to the SQS queue
     const command = new client_sqs_1.SendMessageCommand(sqsOrderData);
-    let result = await client.send(command);
-    return result;
+    return await client.send(command);
 };
 exports.sendStandardSqsMessage = sendStandardSqsMessage;
 const sendStandardBatchMessages = async (QueueUrl, dataArray, DelaySecondsArray = []) => {
@@ -34,8 +33,7 @@ const sendStandardBatchMessages = async (QueueUrl, dataArray, DelaySecondsArray
     };
     // Send the order data to the SQS queue
     const command = new client_sqs_1.SendMessageBatchCommand(sqsOrderData);
-    let result = await client.send(command);
-    return result;
+    return await client.send(command);
 };
 exports.sendStandardBatchMessages = sendStandardBatchMessages;
 const sendFifoSqsMessage = async (queueUrl, data, MessageGroupId) => {
@@ -46,8 +44,7 @@ const sendFifoSqsMessage = async (queueUrl, data, 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;
+    return await client.send(command);
 };
 exports.sendFifoSqsMessage = sendFifoSqsMessage;
 exports.default = {

package/dist/utils/axios.js

@@ -5,8 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.axiosPost = exports.axiosGet = void 0;
 const axios_1 = __importDefault(require("axios"));
+const __1 = require("..");
 const axiosGet = async (url, config = {}, errorLogging = false) => {
     var _a, _b, _c, _d;
+    if (!url)
+        throw (0, __1.InternalServerError)("GET request url not provided");
     try {
         const response = await axios_1.default.get(url, config);
         return { success: true, ...response === null || response === void 0 ? void 0 : response.data };
@@ -27,6 +30,10 @@ const axiosGet = async (url, config = {}, errorLogging = false) => {
 exports.axiosGet = axiosGet;
 const axiosPost = async (url, data, config = {}, errorLogging = false) => {
     var _a, _b, _c, _d;
+    if (!url)
+        throw (0, __1.InternalServerError)("POST request url not provided");
+    if (!data)
+        throw (0, __1.InternalServerError)("POST request data not provided");
     try {
         const response = await axios_1.default.post(url, data, config);
         return { success: true, ...response === null || response === void 0 ? void 0 : response.data };

package/dist/utils/discord.d.ts

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

package/dist/utils/discord.js

@@ -1,17 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendToDiscordWebhook = void 0;
+exports.sendToDiscordWebhook = exports.initDiscord = void 0;
+const __1 = require("..");
 const axios_1 = require("./axios");
-const sendToDiscordWebhook = async (data) => {
+let discordWebhookUrl;
+let serviceName;
+const initDiscord = (webhookUrl_, serviceName_) => {
+    discordWebhookUrl = webhookUrl_;
+    serviceName = serviceName_;
+};
+exports.initDiscord = initDiscord;
+const sendToDiscordWebhook = async (title, data, optionalConfig = {}) => {
     try {
-        const discordWebhookUrl = process.env.DISCORD_WEBHOOK_URL;
         if (!discordWebhookUrl) {
-            throw new Error("DISCORD_WEBHOOK_URL not provided");
+            throw (0, __1.InternalServerError)("DISCORD_WEBHOOK_URL not provided");
         }
-        await (0, axios_1.axiosPost)(discordWebhookUrl, { content: JSON.stringify(data) });
+        let content = formatMsg(title, data);
+        await (0, axios_1.axiosPost)(discordWebhookUrl, { content, ...optionalConfig });
     }
     catch (error) {
         throw error;
     }
 };
 exports.sendToDiscordWebhook = sendToDiscordWebhook;
+const formatMsg = (title, data) => {
+    let message = `**${title}**\n`;
+    // Iterate through the object's key-value pairs
+    for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+            message += `${key}: ${data[key]}\n`;
+        }
+    }
+    return message;
+};

package/dist/utils/ethersAwsKmsSigner.d.ts

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

package/dist/utils/ethersAwsKmsSigner.js

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

package/dist/utils/eventGetter.d.ts

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

package/dist/utils/eventGetter.js

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

package/dist/utils/extraUtils.d.ts

@@ -1,3 +1,21 @@
+/**
+ * defining functions.
+ */
+export declare const isEmpty: (data: any) => boolean;
+export declare const checkMissingFields: (fields: {
+    [key: string]: any;
+}) => void;
+export declare const checkEnvValue: (key: string) => string;
+export declare const checkMissingFieldsAndType: (fields: {
+    [key: string]: any;
+}, types?: {
+    [key: string]: string;
+}) => void;
+export declare const checkObjectFieldsAndType: (data: {
+    [key: string]: any;
+}, types?: {
+    [key: string]: any;
+}, prefix?: string) => void;
 export declare const removeFields: (obj: any, fieldsToRemove: string[]) => any;
 export declare const filterFields: (obj: any, fieldsAllowed: string[]) => any;
 /**
@@ -12,11 +30,3 @@ export declare const responseBody: (statusCode?: number, message?: null | string
     };
     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

@@ -1,37 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.responseBody = exports.filterFields = exports.removeFields = void 0;
+exports.responseBody = exports.filterFields = exports.removeFields = exports.checkObjectFieldsAndType = exports.checkMissingFieldsAndType = exports.checkEnvValue = exports.checkMissingFields = exports.isEmpty = void 0;
+const constants_1 = require("../constants");
 /**
  * defining functions.
  */
 const isEmpty = (data) => {
-    if (data === undefined || data === null || data === "") {
+    if (data === undefined || data === null) {
         return true;
     }
     else {
         return false;
     }
 }; // end of isEmpty.
+exports.isEmpty = isEmpty;
 const checkMissingFields = (fields) => {
     for (const field in fields) {
-        if (isEmpty(fields[field])) {
-            throw { message: `missing field : ${field}`, code: 1 };
+        let value = fields[field];
+        if (!value) {
+            throw (0, constants_1.BadRequestError)(`missing field : ${field}`);
         }
     }
 };
+exports.checkMissingFields = checkMissingFields;
+const checkEnvValue = (key) => {
+    let value = process.env[key];
+    if (!value) {
+        throw (0, constants_1.InternalServerError)(`${key} not found`);
+    }
+    return value;
+};
+exports.checkEnvValue = checkEnvValue;
 const checkMissingFieldsAndType = (fields, types = {}) => {
     for (const field in fields) {
-        if (isEmpty(fields[field])) {
-            throw { message: `missing field : ${field}`, code: 1 };
+        if ((0, exports.isEmpty)(fields[field])) {
+            throw (0, constants_1.BadRequestError)(`missing field : ${field}`);
         }
         if (types[field] && typeof fields[field] !== types[field]) {
-            throw {
-                message: `Type of ${field} expected : "${types[field]}", got : "${typeof fields[field]}"`,
-                code: 1,
-            };
+            throw (0, constants_1.BadRequestError)(`Type of ${field} expected : "${types[field]}", got : "${typeof fields[field]}"`);
+        }
+    }
+};
+exports.checkMissingFieldsAndType = checkMissingFieldsAndType;
+const checkObjectFieldsAndType = (data, types = {}, prefix = "") => {
+    let keys = Object.keys(types);
+    for (const key of keys) {
+        if ((0, exports.isEmpty)(data[key])) {
+            throw (0, constants_1.BadRequestError)(`missing field : ${prefix}.${key}`);
+        }
+        if (typeof data[key] === "object") {
+            (0, exports.checkObjectFieldsAndType)(data[key], types[key], `${prefix}.${key}`);
+        }
+        else if (typeof data[key] !== types[key]) {
+            throw (0, constants_1.BadRequestError)(`Type of ${prefix}.${key} expected : "${types[key]}", got : "${typeof data[key]}"`);
         }
     }
 };
+exports.checkObjectFieldsAndType = checkObjectFieldsAndType;
 const removeFields = (obj, fieldsToRemove) => {
     for (const field in obj) {
         if (fieldsToRemove.includes(field)) {
@@ -76,10 +101,3 @@ const responseBody = (statusCode = 400, message = null, data = null, success = t
     };
 }; // end responseBody function.
 exports.responseBody = responseBody;
-exports.default = {
-    isEmpty,
-    checkMissingFields,
-    checkMissingFieldsAndType,
-    removeFields: exports.removeFields,
-    filterFields: exports.filterFields,
-};

package/dist/utils/idUtils.d.ts

@@ -1,7 +1,7 @@
 export interface PacketDetails {
     chainSlug: number;
     capacitorAddr: string;
-    packetNonce: string;
+    packetCount: string;
 }
 export interface MessageDetails {
     chainSlug: number;
@@ -10,4 +10,5 @@ export interface MessageDetails {
 }
 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;
+export declare const packPacketId: (chainSlug: number, capacitorAddr: string, packetCount: string) => string;
+export declare function encodePacketId(chainSlug: number, capacitorAddress: string, packetCount: number): string;