@socket.tech/dl-common 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Socket
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# dl-batcher-service

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./models";
+export * from "./types";
+export * from "./services";
+export * from "./utils";

package/dist/index.js

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

package/dist/models/attestSignature.d.ts

@@ -0,0 +1,34 @@
+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;
+    };
+};

package/dist/models/attestSignature.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttestSignatureModel = exports.AttestSignature = void 0;
+const sequelize_1 = require("sequelize");
+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,
+    },
+};

package/dist/models/attestations.d.ts

@@ -0,0 +1,69 @@
+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.IntegerDataTypeConstructor;
+    };
+    dstChainSlug: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    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;
+    };
+};

package/dist/models/attestations.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttestationModel = exports.Attestation = void 0;
+const sequelize_1 = require("sequelize");
+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.INTEGER,
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    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,
+    },
+};

package/dist/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./packet";
+export * from "./message";
+export * from "./attestSignature";

package/dist/models/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("./packet"), exports);
+__exportStar(require("./message"), exports);
+__exportStar(require("./attestSignature"), exports);

package/dist/models/message.d.ts

@@ -0,0 +1,165 @@
+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;
+}
+export declare const MessageModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+    };
+    srcChainSlug: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    dstChainSlug: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    srcPlug: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    destPlug: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    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.StringDataTypeConstructor;
+        defaultValue: string;
+    };
+};

package/dist/models/message.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageModel = exports.Message = exports.ExecutionRelayStatus = void 0;
+const sequelize_1 = require("sequelize");
+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.INTEGER,
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    srcPlug: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    destPlug: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    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.STRING,
+        defaultValue: "",
+    },
+};