@socket.tech/dl-common 1.0.16 → 1.0.17

package/dist/index.js

@@ -0,0 +1,36 @@
+"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("./models"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);

package/dist/models/attestSignature.d.ts

@@ -0,0 +1,35 @@
+import { DataTypes, Model } from "sequelize";
+export declare class AttestSignature extends Model {
+    id: number;
+    packetId: string;
+    proposalCount: number;
+    root: string;
+    signature: string;
+    watcherId: string;
+}
+export declare const AttestSignatureModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+        primaryKey: boolean;
+    };
+    packetId: {
+        type: DataTypes.StringDataTypeConstructor;
+        unique: string;
+    };
+    proposalCount: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        unique: string;
+    };
+    watcherId: {
+        type: DataTypes.StringDataTypeConstructor;
+        unique: string;
+    };
+    root: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    signature: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+};
+export declare const addSignatureHooks: () => void;

package/dist/models/attestSignature.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSignatureHooks = exports.AttestSignatureModel = exports.AttestSignature = void 0;
+const sequelize_1 = require("sequelize");
+const utils_1 = require("../utils");
+class AttestSignature extends sequelize_1.Model {
+}
+exports.AttestSignature = AttestSignature;
+exports.AttestSignatureModel = {
+    id: {
+        type: sequelize_1.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+    },
+    packetId: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueAttestSignPointer",
+    },
+    proposalCount: {
+        type: sequelize_1.DataTypes.INTEGER,
+        unique: "uniqueAttestSignPointer",
+    },
+    watcherId: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueAttestSignPointer",
+    },
+    root: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    signature: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+};
+function processStrings(attestSignature) {
+    if (attestSignature.packetId) {
+        attestSignature.packetId = (0, utils_1.toLowerCase)(attestSignature.packetId);
+    }
+    if (attestSignature.signature) {
+        attestSignature.signature = (0, utils_1.toLowerCase)(attestSignature.signature);
+    }
+    return attestSignature;
+}
+const addSignatureHooks = () => {
+    AttestSignature.beforeBulkCreate((attestSignature, options) => {
+        for (let index = 0; index < attestSignature.length; index++) {
+            attestSignature[index] = processStrings(attestSignature[index]);
+        }
+    });
+    AttestSignature.beforeSave((attestSignature, options) => {
+        attestSignature = processStrings(attestSignature);
+    });
+};
+exports.addSignatureHooks = addSignatureHooks;

package/dist/models/attestation.d.ts

@@ -0,0 +1,70 @@
+import { IntegrationTypes } from "@socket.tech/dl-core";
+import { DataTypes, Model } from "sequelize";
+export declare class Attestation extends Model {
+    id: number;
+    packetId: string;
+    proposalCount: number;
+    root: string;
+    switchboard: string;
+    integrationType: IntegrationTypes;
+    srcChainSlug: number;
+    dstChainSlug: number;
+    attester: string;
+    attestTxId: string;
+    attestTxHash: string;
+    attestTime: number;
+    numberOfAttestations: number;
+}
+export declare const AttestationModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+        primaryKey: boolean;
+    };
+    packetId: {
+        type: DataTypes.StringDataTypeConstructor;
+        unique: string;
+    };
+    proposalCount: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        unique: string;
+    };
+    switchboard: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    srcChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+    };
+    dstChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+    };
+    integrationType: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    root: {
+        type: DataTypes.StringDataTypeConstructor;
+        unique: string;
+    };
+    attester: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+        unique: string;
+    };
+    attestTxId: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    attestTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    attestTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        defaultValue: number;
+    };
+    numberOfAttestations: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        defaultValue: number;
+    };
+};
+export declare const addAttestationHooks: () => void;

package/dist/models/attestation.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAttestationHooks = exports.AttestationModel = exports.Attestation = void 0;
+const sequelize_1 = require("sequelize");
+const utils_1 = require("../utils");
+class Attestation extends sequelize_1.Model {
+}
+exports.Attestation = Attestation;
+exports.AttestationModel = {
+    id: {
+        type: sequelize_1.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+    },
+    packetId: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueAttestationPointer",
+    },
+    proposalCount: {
+        type: sequelize_1.DataTypes.INTEGER,
+        unique: "uniqueAttestationPointer",
+    },
+    switchboard: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    srcChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    integrationType: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    root: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueAttestationPointer",
+    },
+    attester: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+        unique: "uniqueAttestationPointer",
+    },
+    attestTxId: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    attestTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    attestTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+        defaultValue: 0,
+    },
+    numberOfAttestations: {
+        type: sequelize_1.DataTypes.INTEGER,
+        defaultValue: 0,
+    },
+};
+const addAttestationHooks = () => {
+    Attestation.beforeBulkCreate((packet, options) => {
+        for (let index = 0; index < packet.length; index++) {
+            packet[index] = processStrings(packet[index]);
+        }
+    });
+    Attestation.beforeSave((packet, options) => {
+        packet = processStrings(packet);
+    });
+};
+exports.addAttestationHooks = addAttestationHooks;
+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.switchboard)
+        packet.switchboard = (0, utils_1.toLowerCase)(packet.switchboard);
+    if (packet.attester)
+        packet.attester = (0, utils_1.toLowerCase)(packet.attester);
+    if (packet.attestTxId)
+        packet.attestTxId = (0, utils_1.toLowerCase)(packet.attestTxId);
+    if (packet.attestTxHash)
+        packet.attestTxHash = (0, utils_1.toLowerCase)(packet.attestTxHash);
+    return packet;
+}

package/dist/models/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./packet";
+export * from "./message";
+export * from "./attestSignature";
+export * from "./attestation";
+export * from "./proposal";
+export * from "./switchboard";
+export * from "./lastBlock";

package/dist/models/index.js

@@ -0,0 +1,23 @@
+"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("./packet"), exports);
+__exportStar(require("./message"), exports);
+__exportStar(require("./attestSignature"), exports);
+__exportStar(require("./attestation"), exports);
+__exportStar(require("./proposal"), exports);
+__exportStar(require("./switchboard"), exports);
+__exportStar(require("./lastBlock"), exports);

package/dist/models/lastBlock.d.ts

@@ -0,0 +1,28 @@
+import { DataTypes, Model } from "sequelize";
+export declare class LastBlock extends Model {
+    id: number;
+    chainSlug: number;
+    blockNumber: number;
+    isFullySynced: boolean;
+    isActive: boolean;
+}
+export declare const LastBlockModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+    };
+    chainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+        primaryKey: boolean;
+    };
+    blockNumber: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    isFullySynced: {
+        type: DataTypes.AbstractDataTypeConstructor;
+    };
+    isActive: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+};

package/dist/models/lastBlock.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LastBlockModel = exports.LastBlock = void 0;
+const sequelize_1 = require("sequelize");
+class LastBlock extends sequelize_1.Model {
+}
+exports.LastBlock = LastBlock;
+exports.LastBlockModel = {
+    id: {
+        type: sequelize_1.DataTypes.INTEGER,
+        autoIncrement: true,
+    },
+    chainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+        primaryKey: true,
+    },
+    blockNumber: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    isFullySynced: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+    },
+    isActive: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: true,
+    },
+};

package/dist/models/message.d.ts

@@ -0,0 +1,171 @@
+import { DataTypes, Model } from "sequelize";
+export declare enum ExecutionRelayStatus {
+    EXECUTED = "EXECUTED",
+    EXECUTING = "EXECUTING",
+    NO = "NO",
+    EXECUTE_FAILED = "EXECUTE_FAILED",
+    IGNORED = "IGNORED"
+}
+export declare class Message extends Model {
+    id: number;
+    packetId: string;
+    srcChainSlug: number;
+    dstChainSlug: number;
+    srcPlug: string;
+    destPlug: string;
+    messageId: string;
+    fees: string;
+    minMsgGasLimit: string;
+    executionParams: string;
+    transmissionParams: string;
+    executionFee: string;
+    transmissionFees: string;
+    switchboardFees: string;
+    decapacitorProof: string;
+    payload: string;
+    packedMessage: string;
+    retry: boolean;
+    firstSimulationTimestamp: number;
+    inboundSuccess: boolean;
+    inboundRevertString: string;
+    capacitorMsgCount: number;
+    capacitorPacketCount: number;
+    rootHash: string;
+    isExecuted: boolean;
+    isVerified: boolean;
+    executor: string;
+    executeTxId: string;
+    executeTxHash: string;
+    executeTime: number;
+    outboundTxHash: string;
+    outboundTime: number;
+    executeSignature: string;
+    executeMsgGasLimit: string;
+    executeRelayStatus: ExecutionRelayStatus;
+    executeData: string;
+}
+export declare const MessageModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+    };
+    srcChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+    };
+    dstChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+    };
+    srcPlug: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    destPlug: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    executeData: {
+        type: DataTypes.TextDataTypeConstructor;
+        defaultValue: string;
+    };
+    messageId: {
+        type: DataTypes.StringDataTypeConstructor;
+        primaryKey: boolean;
+    };
+    minMsgGasLimit: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    executionParams: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    transmissionParams: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    fees: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    executionFee: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    transmissionFees: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    switchboardFees: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    decapacitorProof: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    payload: {
+        type: DataTypes.TextDataTypeConstructor;
+    };
+    packedMessage: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    capacitorMsgCount: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    capacitorPacketCount: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    rootHash: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    isVerified: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    isExecuted: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    executeRelayStatus: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: ExecutionRelayStatus[];
+        defaultValue: ExecutionRelayStatus;
+    };
+    executor: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    executeTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    executeTxId: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    executeTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    executeSignature: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    executeMsgGasLimit: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    outboundTxHash: {
+        type: DataTypes.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+    outboundTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    firstSimulationTimestamp: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        defaultValue: number;
+    };
+    retry: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    inboundSuccess: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    inboundRevertString: {
+        type: DataTypes.TextDataTypeConstructor;
+        defaultValue: string;
+    };
+};
+export declare const addMessageHooks: () => void;