@socket.tech/dl-common 1.0.16 → 1.0.17

package/dist/models/message.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMessageHooks = exports.MessageModel = exports.Message = exports.ExecutionRelayStatus = void 0;
+const sequelize_1 = require("sequelize");
+const utils_1 = require("../utils");
+var ExecutionRelayStatus;
+(function (ExecutionRelayStatus) {
+    ExecutionRelayStatus["EXECUTED"] = "EXECUTED";
+    ExecutionRelayStatus["EXECUTING"] = "EXECUTING";
+    ExecutionRelayStatus["NO"] = "NO";
+    ExecutionRelayStatus["EXECUTE_FAILED"] = "EXECUTE_FAILED";
+    ExecutionRelayStatus["IGNORED"] = "IGNORED";
+})(ExecutionRelayStatus || (exports.ExecutionRelayStatus = ExecutionRelayStatus = {}));
+class Message extends sequelize_1.Model {
+}
+exports.Message = Message;
+exports.MessageModel = {
+    id: {
+        type: sequelize_1.DataTypes.INTEGER,
+        autoIncrement: true,
+    },
+    srcChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    srcPlug: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    destPlug: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    executeData: {
+        type: sequelize_1.DataTypes.TEXT,
+        defaultValue: "",
+    },
+    messageId: {
+        type: sequelize_1.DataTypes.STRING,
+        primaryKey: true,
+    },
+    minMsgGasLimit: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    executionParams: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    transmissionParams: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    fees: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    executionFee: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    transmissionFees: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    switchboardFees: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    decapacitorProof: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    },
+    payload: {
+        type: sequelize_1.DataTypes.TEXT,
+    },
+    packedMessage: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    capacitorMsgCount: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    capacitorPacketCount: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    rootHash: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    isVerified: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    isExecuted: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    executeRelayStatus: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(ExecutionRelayStatus)],
+        defaultValue: ExecutionRelayStatus.NO,
+    },
+    executor: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    executeTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    executeTxId: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    executeTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    executeSignature: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    executeMsgGasLimit: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    outboundTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    outboundTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    firstSimulationTimestamp: {
+        type: sequelize_1.DataTypes.INTEGER,
+        defaultValue: 0,
+    },
+    retry: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    inboundSuccess: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    inboundRevertString: {
+        type: sequelize_1.DataTypes.TEXT,
+        defaultValue: "",
+    },
+};
+function processStrings(message) {
+    if (message.srcPlug)
+        message.srcPlug = (0, utils_1.toLowerCase)(message.srcPlug);
+    if (message.destPlug)
+        message.destPlug = (0, utils_1.toLowerCase)(message.destPlug);
+    if (message.messageId)
+        message.messageId = (0, utils_1.toLowerCase)(message.messageId);
+    if (message.executionParams) {
+        message.executionParams = (0, utils_1.toLowerCase)(message.executionParams);
+    }
+    if (message.transmissionParams) {
+        message.transmissionParams = (0, utils_1.toLowerCase)(message.transmissionParams);
+    }
+    if (message.packedMessage) {
+        message.packedMessage = (0, utils_1.toLowerCase)(message.packedMessage);
+    }
+    if (message.decapacitorProof) {
+        message.decapacitorProof = (0, utils_1.toLowerCase)(message.decapacitorProof);
+    }
+    if (message.payload)
+        message.payload = (0, utils_1.toLowerCase)(message.payload);
+    if (message.executor)
+        message.executor = (0, utils_1.toLowerCase)(message.executor);
+    if (message.executeTxHash) {
+        message.executeTxHash = (0, utils_1.toLowerCase)(message.executeTxHash);
+    }
+    if (message.outboundTxHash) {
+        message.outboundTxHash = (0, utils_1.toLowerCase)(message.outboundTxHash);
+    }
+    if (message.packedMessage) {
+        message.packedMessage = (0, utils_1.toLowerCase)(message.packedMessage);
+    }
+    if (message.rootHash)
+        message.rootHash = (0, utils_1.toLowerCase)(message.rootHash);
+    if (message.payload)
+        message.payload = message.payload.slice(0, 10004);
+    if (message.inboundRevertString)
+        message.inboundRevertString = message.inboundRevertString.slice(0, 1000);
+    if (message.executeData)
+        message.executeData = message.executeData.slice(0, 5000);
+    return message;
+}
+const addMessageHooks = () => {
+    Message.beforeBulkCreate((message, options) => {
+        for (let index = 0; index < message.length; index++) {
+            message[index] = processStrings(message[index]);
+        }
+    });
+    Message.beforeSave((message, options) => {
+        message = processStrings(message);
+    });
+};
+exports.addMessageHooks = addMessageHooks;

package/dist/models/packet.d.ts

@@ -0,0 +1,240 @@
+import { IntegrationTypes } from "@socket.tech/dl-core";
+import { DataTypes, Model } from "sequelize";
+export declare enum SealRelayStatus {
+    SEALED = "SEALED",
+    SEALING = "SEALING",
+    NO = "NO",
+    SEAL_FAILED = "SEAL_FAILED"
+}
+export declare enum PacketTripRelayStatus {
+    IS_TRIPPING = "IS_TRIPPING",
+    NO = "NO",
+    TRIPPING_FAILED = "TRIPPING_FAILED",
+    TRIPPED = "TRIPPED"
+}
+export declare enum ProposeRelayStatus {
+    PROPOSED = "PROPOSED",
+    PROPOSING = "PROPOSING",
+    CONFIRMING = "CONFIRMING",
+    NO = "NO",
+    PROPOSE_FAILED = "PROPOSE_FAILED",
+    CONFIRM_FAILED = "CONFIRM_FAILED"
+}
+export declare enum AttestRelayStatus {
+    ATTESTED = "ATTESTED",
+    ATTESTING = "ATTESTING",
+    NO = "NO",
+    ATTEST_FAILED = "ATTEST_FAILED"
+}
+export declare enum TripReason {
+    SWITCHBOARD_MISMATCHED = "SWITCHBOARD_MISMATCHED",
+    ROOT_MISMATCHED = "ROOT_MISMATCHED",
+    NO = "NO"
+}
+export declare class Packet extends Model {
+    id: number;
+    switchboardId: string;
+    packetId: string;
+    srcChainSlug: number;
+    dstChainSlug: number;
+    srcCapacitor: string;
+    dstSwitchboard: string;
+    integrationType: IntegrationTypes;
+    capacitorPacketCount: string;
+    root: string;
+    rootSealed: string;
+    sealer: string;
+    sealTxHash: string;
+    sealTxId: string;
+    sealSignature: string;
+    sealTime: number;
+    sealRelayStatus: SealRelayStatus;
+    packetTripTime: number;
+    packetTripTxnHash: string;
+    packetTripErrorMessage: string;
+    isPacketTripped: boolean;
+    packetTripRelayStatus: PacketTripRelayStatus;
+    proposeTxId: string;
+    proposeTxHash: string;
+    proposeRelayStatus: ProposeRelayStatus;
+    selectedProposalCount: number;
+    attestTxId: string;
+    attestTxHash: string;
+    attestRelayStatus: AttestRelayStatus;
+    outboundTxHash: string;
+    outboundTime: number;
+    sealIndexTime: number;
+    proposeTime: number;
+    attestTime: number;
+    packetTripTxHash: string;
+    isFilled: boolean;
+    isSealed: boolean;
+    isProposed: boolean;
+    isAttested: boolean;
+    isVerified: boolean;
+    isFullyExecuted: boolean;
+    tripreason: TripReason;
+    executionWaitTime: number;
+}
+export declare const PacketModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+    };
+    srcChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+    };
+    dstChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+    };
+    srcCapacitor: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    dstSwitchboard: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    switchboardId: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    integrationType: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: IntegrationTypes[];
+        defaultValue: IntegrationTypes;
+    };
+    packetId: {
+        type: DataTypes.StringDataTypeConstructor;
+        primaryKey: boolean;
+    };
+    capacitorPacketCount: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    root: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    rootSealed: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    isFilled: {
+        type: DataTypes.AbstractDataTypeConstructor;
+    };
+    isSealed: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    isProposed: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    isAttested: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    isVerified: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    isFullyExecuted: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    sealer: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    sealRelayStatus: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: SealRelayStatus[];
+        defaultValue: SealRelayStatus;
+    };
+    sealTxId: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    sealTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    outboundTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    outboundTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    proposeTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    attestTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    sealTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    sealIndexTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    sealSignature: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    packetTripRelayStatus: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: PacketTripRelayStatus[];
+        defaultValue: PacketTripRelayStatus;
+    };
+    packetTripTxId: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    packetTripTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    packetTripErrorMessage: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    packetTripTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    isPacketTripped: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    proposeTxId: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    proposeTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    proposeRelayStatus: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: ProposeRelayStatus[];
+        defaultValue: ProposeRelayStatus;
+    };
+    selectedProposalCount: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    executionWaitTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    attestTxId: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    attestTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    tripReason: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: TripReason[];
+        defaultValue: TripReason;
+    };
+    attestRelayStatus: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: AttestRelayStatus[];
+        defaultValue: AttestRelayStatus;
+    };
+};
+export declare const addPacketHooks: () => void;

package/dist/models/packet.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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";
+    SealRelayStatus["SEALING"] = "SEALING";
+    SealRelayStatus["NO"] = "NO";
+    SealRelayStatus["SEAL_FAILED"] = "SEAL_FAILED";
+})(SealRelayStatus || (exports.SealRelayStatus = SealRelayStatus = {}));
+var PacketTripRelayStatus;
+(function (PacketTripRelayStatus) {
+    PacketTripRelayStatus["IS_TRIPPING"] = "IS_TRIPPING";
+    PacketTripRelayStatus["NO"] = "NO";
+    PacketTripRelayStatus["TRIPPING_FAILED"] = "TRIPPING_FAILED";
+    PacketTripRelayStatus["TRIPPED"] = "TRIPPED";
+})(PacketTripRelayStatus || (exports.PacketTripRelayStatus = PacketTripRelayStatus = {}));
+var ProposeRelayStatus;
+(function (ProposeRelayStatus) {
+    ProposeRelayStatus["PROPOSED"] = "PROPOSED";
+    ProposeRelayStatus["PROPOSING"] = "PROPOSING";
+    ProposeRelayStatus["CONFIRMING"] = "CONFIRMING";
+    ProposeRelayStatus["NO"] = "NO";
+    ProposeRelayStatus["PROPOSE_FAILED"] = "PROPOSE_FAILED";
+    ProposeRelayStatus["CONFIRM_FAILED"] = "CONFIRM_FAILED";
+})(ProposeRelayStatus || (exports.ProposeRelayStatus = ProposeRelayStatus = {}));
+var AttestRelayStatus;
+(function (AttestRelayStatus) {
+    AttestRelayStatus["ATTESTED"] = "ATTESTED";
+    AttestRelayStatus["ATTESTING"] = "ATTESTING";
+    AttestRelayStatus["NO"] = "NO";
+    AttestRelayStatus["ATTEST_FAILED"] = "ATTEST_FAILED";
+})(AttestRelayStatus || (exports.AttestRelayStatus = AttestRelayStatus = {}));
+var TripReason;
+(function (TripReason) {
+    TripReason["SWITCHBOARD_MISMATCHED"] = "SWITCHBOARD_MISMATCHED";
+    TripReason["ROOT_MISMATCHED"] = "ROOT_MISMATCHED";
+    TripReason["NO"] = "NO";
+})(TripReason || (exports.TripReason = TripReason = {}));
+class Packet extends sequelize_1.Model {
+}
+exports.Packet = Packet;
+exports.PacketModel = {
+    id: {
+        type: sequelize_1.DataTypes.INTEGER,
+        autoIncrement: true,
+    },
+    srcChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    srcCapacitor: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    dstSwitchboard: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    switchboardId: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    integrationType: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(dl_core_1.IntegrationTypes)],
+        defaultValue: dl_core_1.IntegrationTypes.unknown,
+    },
+    packetId: {
+        type: sequelize_1.DataTypes.STRING,
+        primaryKey: true,
+    },
+    capacitorPacketCount: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    root: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    rootSealed: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    isFilled: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+    },
+    isSealed: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    isProposed: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    isAttested: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    isVerified: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    isFullyExecuted: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    sealer: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    sealRelayStatus: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(SealRelayStatus)],
+        defaultValue: SealRelayStatus.NO,
+    },
+    sealTxId: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    sealTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    outboundTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    outboundTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    proposeTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    attestTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    sealTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    sealIndexTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    sealSignature: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    packetTripRelayStatus: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(PacketTripRelayStatus)],
+        defaultValue: PacketTripRelayStatus.NO,
+    },
+    packetTripTxId: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    packetTripTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    packetTripErrorMessage: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    packetTripTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    isPacketTripped: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    proposeTxId: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    proposeTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    proposeRelayStatus: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(ProposeRelayStatus)],
+        defaultValue: ProposeRelayStatus.NO,
+    },
+    selectedProposalCount: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    executionWaitTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    attestTxId: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    attestTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    tripReason: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(TripReason)],
+        defaultValue: TripReason.NO,
+    },
+    // packetTripTxHash: {
+    //   type: DataTypes.STRING,
+    //   defaultValue: "",
+    // },
+    attestRelayStatus: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(AttestRelayStatus)],
+        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.switchboardId) {
+        packet.switchboardId = (0, utils_1.toLowerCase)(packet.switchboardId);
+    }
+    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;