@socket.tech/dl-common 1.0.6 → 1.0.7

package/dist/dl-common/models/packet.js

@@ -0,0 +1,250 @@
+"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["MISSING_SEAL"] = "MISSING_SEAL";
+    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;

package/dist/dl-common/models/proposal.d.ts

@@ -0,0 +1,127 @@
+import { DataTypes, Model } from "sequelize";
+export declare enum TripStatus {
+    TRIP_REQUIRED = "TRIP_REQUIRED",
+    TRIP_INITIATED = "TRIP_INITIATED",
+    TRIP_SUCCESSFUL = "TRIP_SUCCESSFUL",
+    TRIP_FAILED = "TRIP_FAILED",
+    NO = "NO"
+}
+export declare enum RootMatchState {
+    ROOTS_MATCHED = "ROOTS_MATCHED",
+    ROOTS_MISMATCHED = "ROOTS_MISMATCHED",
+    NO = "NO"
+}
+export declare enum MatchState {
+    MATCHED = "MATCHED",
+    MISMATCHED = "MISMATCHED",
+    NO = "NO"
+}
+export declare enum ProposalTripRelayStatus {
+    IS_TRIPPING = "IS_TRIPPING",
+    NO = "NO",
+    TRIPPING_FAILED = "TRIPPING_FAILED",
+    TRIPPED = "TRIPPED"
+}
+export declare class Proposal extends Model {
+    id: number;
+    srcChainSlug: number;
+    dstChainSlug: number;
+    packetId: string;
+    root: string;
+    proposalCount: number;
+    switchboard: string;
+    proposer: string;
+    proposeTxHash: string;
+    proposeTime: number;
+    rootMatchState: RootMatchState;
+    switchboardMatchState: MatchState;
+    tripTime: number;
+    tripTxHash: string;
+    tripTxId: string;
+    tripErrorMessage: string;
+    tripRelayStatus: ProposalTripRelayStatus;
+    isTripped: boolean;
+    totalAttestations: number;
+    isTripRequired: boolean;
+}
+export declare const ProposalModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+        primaryKey: boolean;
+    };
+    srcChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+    };
+    dstChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+    };
+    packetId: {
+        type: DataTypes.StringDataTypeConstructor;
+        unique: string;
+    };
+    proposalCount: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        unique: string;
+    };
+    root: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    switchboard: {
+        type: DataTypes.StringDataTypeConstructor;
+        unique: string;
+    };
+    proposer: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    proposeTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    proposeTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    tripTxId: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    tripTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    tripTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    tripErrorMessage: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    isTripped: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    tripRelayStatus: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: ProposalTripRelayStatus[];
+        defaultValue: ProposalTripRelayStatus;
+    };
+    totalAttestations: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        defaultValue: number;
+    };
+    rootMatchState: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: RootMatchState[];
+        defaultValue: RootMatchState;
+    };
+    switchboardMatchState: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: MatchState[];
+        defaultValue: MatchState;
+    };
+    isTripRequired: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+};
+export declare const addProposalHooks: () => void;

package/dist/dl-common/models/proposal.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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";
+    TripStatus["TRIP_INITIATED"] = "TRIP_INITIATED";
+    TripStatus["TRIP_SUCCESSFUL"] = "TRIP_SUCCESSFUL";
+    TripStatus["TRIP_FAILED"] = "TRIP_FAILED";
+    TripStatus["NO"] = "NO";
+})(TripStatus || (exports.TripStatus = TripStatus = {}));
+var RootMatchState;
+(function (RootMatchState) {
+    RootMatchState["ROOTS_MATCHED"] = "ROOTS_MATCHED";
+    RootMatchState["ROOTS_MISMATCHED"] = "ROOTS_MISMATCHED";
+    RootMatchState["NO"] = "NO";
+})(RootMatchState || (exports.RootMatchState = RootMatchState = {}));
+var MatchState;
+(function (MatchState) {
+    MatchState["MATCHED"] = "MATCHED";
+    MatchState["MISMATCHED"] = "MISMATCHED";
+    MatchState["NO"] = "NO";
+})(MatchState || (exports.MatchState = MatchState = {}));
+var ProposalTripRelayStatus;
+(function (ProposalTripRelayStatus) {
+    ProposalTripRelayStatus["IS_TRIPPING"] = "IS_TRIPPING";
+    ProposalTripRelayStatus["NO"] = "NO";
+    ProposalTripRelayStatus["TRIPPING_FAILED"] = "TRIPPING_FAILED";
+    ProposalTripRelayStatus["TRIPPED"] = "TRIPPED";
+})(ProposalTripRelayStatus || (exports.ProposalTripRelayStatus = ProposalTripRelayStatus = {}));
+class Proposal extends sequelize_1.Model {
+}
+exports.Proposal = Proposal;
+exports.ProposalModel = {
+    id: {
+        type: sequelize_1.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+    },
+    srcChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    packetId: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueProposalPointer",
+    },
+    proposalCount: {
+        type: sequelize_1.DataTypes.INTEGER,
+        unique: "uniqueProposalPointer",
+    },
+    root: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    switchboard: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueProposalPointer",
+    },
+    proposer: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    proposeTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    proposeTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    tripTxId: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    tripTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    tripTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    tripErrorMessage: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    isTripped: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    tripRelayStatus: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(ProposalTripRelayStatus)],
+        defaultValue: ProposalTripRelayStatus.NO,
+    },
+    totalAttestations: {
+        type: sequelize_1.DataTypes.INTEGER,
+        defaultValue: 0,
+    },
+    rootMatchState: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(RootMatchState)],
+        defaultValue: RootMatchState.NO,
+    },
+    switchboardMatchState: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(MatchState)],
+        defaultValue: MatchState.NO,
+    },
+    isTripRequired: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        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/dl-common/models/switchboard.d.ts

@@ -0,0 +1,69 @@
+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;
+    switchboardId: string;
+    srcChainSlug: number;
+    dstChainSlug: number;
+    maxPacketLength: number;
+    srcSwitchboard: string;
+    dstSwitchboard: string;
+    srcCapacitor: string;
+    srcDecapacitor: string;
+    capacitorType: CapacitorType;
+    isEnabled: boolean;
+    integrationType: IntegrationTypes;
+}
+export declare const SwitchboardModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+        primaryKey: boolean;
+    };
+    switchboardId: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    srcChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+        unique: string;
+    };
+    dstChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+        unique: string;
+    };
+    maxPacketLength: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    srcSwitchboard: {
+        type: DataTypes.StringDataTypeConstructor;
+        unique: string;
+    };
+    dstSwitchboard: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    srcCapacitor: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    srcDecapacitor: {
+        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/dl-common/models/switchboard.js

@@ -0,0 +1,92 @@
+"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");
+const __1 = require("..");
+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,
+    },
+    switchboardId: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    srcChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+        unique: "uniqueSwitchboardPointer",
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+        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,
+    },
+    srcDecapacitor: {
+        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]);
+            switchboards[index] = createSwitchboardId(switchboards[index]);
+        }
+    });
+    Switchboard.beforeSave((switchboard, options) => {
+        switchboard = processStrings(switchboard);
+    });
+};
+exports.addSwitchboardHooks = addSwitchboardHooks;
+function processStrings(switchboard) {
+    if (switchboard.srcSwitchboard)
+        switchboard.srcSwitchboard = (0, __1.toLowerCase)(switchboard.srcSwitchboard);
+    if (switchboard.dstSwitchboard)
+        switchboard.dstSwitchboard = (0, __1.toLowerCase)(switchboard.dstSwitchboard);
+    if (switchboard.srcCapacitor)
+        switchboard.srcCapacitor = (0, __1.toLowerCase)(switchboard.srcCapacitor);
+    if (switchboard.srcDecapacitor)
+        switchboard.srcDecapacitor = (0, __1.toLowerCase)(switchboard.srcDecapacitor);
+    return switchboard;
+}
+function createSwitchboardId(switchboard) {
+    if (switchboard.srcSwitchboard &&
+        switchboard.srcChainSlug &&
+        switchboard.dstChainSlug)
+        switchboard.switchboardId = `${switchboard.srcChainSlug}-${switchboard.dstChainSlug}-${switchboard.srcSwitchboard.toLowerCase()}`;
+    return switchboard;
+}