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

package/README.md

@@ -1 +1,18 @@
 # dl-batcher-service
+
+to start server locally,
+`npm run start`
+
+to deploy complete service to dev,
+`npm run deploy`
+
+to deploy a sepific function (for example if change in apis, can only deploy routeHandler. Similarly if only change in cron timings, can deploy only cronHandler) -
+`sls deploy -f cronHandler`
+
+to check logs locally in terminal -
+`sls logs -f <function>`
+
+for publishing -
+`yarn lint`
+`yarn run build`
+`npm publish`

package/dist/constants/enums.d.ts

@@ -0,0 +1,33 @@
+export declare enum tableNames {
+    packet = "packets",
+    signature = "signatures",
+    attestation = "attestations",
+    message = "messages",
+    nativePacket = "native_packets",
+    proposal = "proposals",
+    switchboard = "switchboards",
+    tripState = "trip_states",
+    attestSignatures = "attest_signatures"
+}
+export declare enum MessageStatuses {
+    RECEIVED = "RECEIVED",
+    SEALED = "SEALED",
+    PROPOSED = "PROPOSED",
+    CONFIRMED = "CONFIRMED",
+    EXECUTION_SUCCESS = "EXECUTION_SUCCESS",
+    EXECUTION_FAILURE = "EXECUTION_FAILURE"
+}
+export declare enum MessageStatusStep {
+    RECEIVED = 0,
+    SEALED = 1,
+    PROPOSED = 2,
+    CONFIRMED = 3,
+    EXECUTION_SUCCESS = 4,
+    EXECUTION_FAILURE = 5
+}
+export declare enum StatusCodes {
+    SUCCESS = "SUCCESS",
+    NOT_FOUND = "NOT_FOUND",
+    BAD_REQUEST = "BAD_REQUEST",
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
+}

package/dist/constants/enums.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCodes = exports.MessageStatusStep = exports.MessageStatuses = exports.tableNames = void 0;
+var tableNames;
+(function (tableNames) {
+    tableNames["packet"] = "packets";
+    tableNames["signature"] = "signatures";
+    tableNames["attestation"] = "attestations";
+    tableNames["message"] = "messages";
+    tableNames["nativePacket"] = "native_packets";
+    tableNames["proposal"] = "proposals";
+    tableNames["switchboard"] = "switchboards";
+    tableNames["tripState"] = "trip_states";
+    tableNames["attestSignatures"] = "attest_signatures";
+})(tableNames || (exports.tableNames = tableNames = {}));
+var MessageStatuses;
+(function (MessageStatuses) {
+    MessageStatuses["RECEIVED"] = "RECEIVED";
+    MessageStatuses["SEALED"] = "SEALED";
+    MessageStatuses["PROPOSED"] = "PROPOSED";
+    MessageStatuses["CONFIRMED"] = "CONFIRMED";
+    MessageStatuses["EXECUTION_SUCCESS"] = "EXECUTION_SUCCESS";
+    MessageStatuses["EXECUTION_FAILURE"] = "EXECUTION_FAILURE";
+})(MessageStatuses || (exports.MessageStatuses = MessageStatuses = {}));
+var MessageStatusStep;
+(function (MessageStatusStep) {
+    MessageStatusStep[MessageStatusStep["RECEIVED"] = 0] = "RECEIVED";
+    MessageStatusStep[MessageStatusStep["SEALED"] = 1] = "SEALED";
+    MessageStatusStep[MessageStatusStep["PROPOSED"] = 2] = "PROPOSED";
+    MessageStatusStep[MessageStatusStep["CONFIRMED"] = 3] = "CONFIRMED";
+    MessageStatusStep[MessageStatusStep["EXECUTION_SUCCESS"] = 4] = "EXECUTION_SUCCESS";
+    MessageStatusStep[MessageStatusStep["EXECUTION_FAILURE"] = 5] = "EXECUTION_FAILURE";
+})(MessageStatusStep || (exports.MessageStatusStep = MessageStatusStep = {}));
+var StatusCodes;
+(function (StatusCodes) {
+    StatusCodes["SUCCESS"] = "SUCCESS";
+    StatusCodes["NOT_FOUND"] = "NOT_FOUND";
+    StatusCodes["BAD_REQUEST"] = "BAD_REQUEST";
+    StatusCodes["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+})(StatusCodes || (exports.StatusCodes = StatusCodes = {}));

package/dist/constants/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./waitTime";
+export * from "./enums";
+export * from "./types";

package/dist/constants/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("./waitTime"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./types"), exports);

package/dist/constants/types.d.ts

@@ -0,0 +1,104 @@
+import { TripReason } from "../models";
+import { StatusCodes } from "./enums";
+import { ChainSlug, IntegrationTypes } from "@socket.tech/dl-core";
+export type Speed = "safeLow" | "average" | "fast" | "fastest";
+export declare enum InboundStatus {
+    NOT_TRIED = "NOT_TRIED",
+    REVERTING = "REVERTING",
+    EXECUTING = "EXECUTING",
+    SUCCESS = "SUCCESS"
+}
+export interface FeeEstimate {
+    transmissionFees: string;
+    verificationFees: string;
+    executionFees: string;
+    totalFees: string;
+}
+export declare enum RelayerAPIStatus {
+    FAILED = "FAILED",
+    SIMULATION_FAILED = "SIMULATION_FAILED",
+    COMPLETED = "COMPLETED"
+}
+export declare class ServerError {
+    code: Omit<StatusCodes, StatusCodes.SUCCESS>;
+    message?: string;
+    constructor(code: Omit<StatusCodes, StatusCodes.SUCCESS>, message?: string);
+    toString(): string;
+}
+export declare const BadRequestError: (message?: string) => ServerError;
+export declare const InternalServerError: (message?: string) => ServerError;
+export interface EthersError {
+    reason?: string;
+    code?: string;
+    argument?: string;
+    value?: string;
+}
+export type SealParams = {
+    srcChainSlug: number;
+    dstChainSlug: number;
+    dstSwitchboard: string;
+    integrationType: IntegrationTypes;
+    message: {
+        messageId: string;
+        srcPlug: string;
+        destPlug: string;
+        minMsgGasLimit: string;
+        executionParams: string;
+        transmissionParams: string;
+        executionFee: string;
+        transmissionFees: string;
+        switchboardFees: string;
+        fees: string;
+        decapacitorProof: string;
+        payload: string;
+        packedMessage: string;
+        outboundTxHash: string;
+        outboundTime: number;
+        capacitorMsgCount: string;
+    };
+    packet: {
+        capacitorPacketCount: string;
+        packetId: string;
+        srcCapacitor: string;
+        root: string;
+        sealSignature: string;
+    };
+};
+export type SealIndexedParams = {
+    srcChainSlug: number;
+    sealer: string;
+    sealTime: number;
+    sealTxHash: string;
+    rootSealed: string;
+    dstSwitchboard: string;
+    sealSignature: string;
+    packetId: string;
+};
+export interface ExecuteSigResponse {
+    messageId: string;
+    retry: boolean;
+    inboundSuccess: boolean;
+    inboundRevertString: string;
+    executeSignature: string;
+    executeMsgGasLimit: string;
+}
+export interface AttestRequest {
+    switchboardAddress: string;
+    dstChainSlug: ChainSlug;
+    packetId: string;
+    root: string;
+    proposalCount: number;
+}
+export interface AttestSuccess {
+    proposalValid: true;
+    packetId: string;
+    proposalCount: number;
+    signature: string;
+}
+export interface AttestFailure {
+    proposalValid: false;
+    packetId: string;
+    proposalCount: number;
+    reason: TripReason;
+}
+export type AttestResponse = AttestSuccess | AttestFailure;

package/dist/constants/types.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalServerError = exports.BadRequestError = exports.ServerError = exports.RelayerAPIStatus = exports.InboundStatus = void 0;
+const enums_1 = require("./enums");
+var InboundStatus;
+(function (InboundStatus) {
+    InboundStatus["NOT_TRIED"] = "NOT_TRIED";
+    InboundStatus["REVERTING"] = "REVERTING";
+    InboundStatus["EXECUTING"] = "EXECUTING";
+    InboundStatus["SUCCESS"] = "SUCCESS";
+})(InboundStatus || (exports.InboundStatus = InboundStatus = {}));
+var RelayerAPIStatus;
+(function (RelayerAPIStatus) {
+    RelayerAPIStatus["FAILED"] = "FAILED";
+    RelayerAPIStatus["SIMULATION_FAILED"] = "SIMULATION_FAILED";
+    RelayerAPIStatus["COMPLETED"] = "COMPLETED";
+})(RelayerAPIStatus || (exports.RelayerAPIStatus = RelayerAPIStatus = {}));
+class ServerError {
+    constructor(code, message) {
+        this.code = code;
+        if (message) {
+            this.message = message;
+        }
+    }
+    toString() {
+        return `code: ${this.code}, message: ${this.message}`;
+    }
+}
+exports.ServerError = ServerError;
+const BadRequestError = (message) => {
+    return new ServerError(enums_1.StatusCodes.BAD_REQUEST, message);
+};
+exports.BadRequestError = BadRequestError;
+const InternalServerError = (message) => {
+    return new ServerError(enums_1.StatusCodes.INTERNAL_SERVER_ERROR, message);
+};
+exports.InternalServerError = InternalServerError;

package/dist/constants/waitTime.d.ts

@@ -0,0 +1,7 @@
+import { ChainSlug, IntegrationTypes } from "@socket.tech/dl-core";
+export declare const getWaitTime: (integrationType: IntegrationTypes, srcChainSlug: ChainSlug, dstChainSlug: ChainSlug) => number;
+export declare const NativeWaitTime: {
+    [srcChain in ChainSlug]?: {
+        [dstChain in ChainSlug]?: number;
+    };
+};

package/dist/constants/waitTime.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeWaitTime = exports.getWaitTime = void 0;
+const dl_core_1 = require("@socket.tech/dl-core");
+const getWaitTime = (integrationType, srcChainSlug, dstChainSlug) => {
+    var _a, _b;
+    switch (integrationType) {
+        case dl_core_1.IntegrationTypes.fast:
+            return 0;
+        case dl_core_1.IntegrationTypes.fast2:
+            return 0;
+        case dl_core_1.IntegrationTypes.optimistic:
+            return 2 * 3600;
+        case dl_core_1.IntegrationTypes.native:
+            return (_b = (_a = exports.NativeWaitTime[srcChainSlug]) === null || _a === void 0 ? void 0 : _a[dstChainSlug]) !== null && _b !== void 0 ? _b : 2 * 3600;
+        default:
+            return 0;
+            break;
+    }
+};
+exports.getWaitTime = getWaitTime;
+exports.NativeWaitTime = {
+    [dl_core_1.ChainSlug.OPTIMISM_GOERLI]: {
+        [dl_core_1.ChainSlug.GOERLI]: 5 * 60,
+    },
+    [dl_core_1.ChainSlug.ARBITRUM_GOERLI]: {
+        [dl_core_1.ChainSlug.GOERLI]: 5 * 60,
+    },
+    [dl_core_1.ChainSlug.POLYGON_MUMBAI]: {
+        [dl_core_1.ChainSlug.GOERLI]: 10 * 60,
+    },
+    [dl_core_1.ChainSlug.GOERLI]: {
+        [dl_core_1.ChainSlug.POLYGON_MUMBAI]: 5 * 60,
+        [dl_core_1.ChainSlug.ARBITRUM_GOERLI]: 5 * 60,
+        [dl_core_1.ChainSlug.OPTIMISM_GOERLI]: 5 * 60,
+    },
+    [dl_core_1.ChainSlug.ARBITRUM]: {
+        [dl_core_1.ChainSlug.MAINNET]: 7 * 24 * 3600,
+    },
+    [dl_core_1.ChainSlug.OPTIMISM]: {
+        [dl_core_1.ChainSlug.MAINNET]: 7 * 24 * 3600,
+    },
+    [dl_core_1.ChainSlug.POLYGON_MAINNET]: {
+        [dl_core_1.ChainSlug.MAINNET]: 4 * 3600,
+    },
+    [dl_core_1.ChainSlug.MAINNET]: {
+        [dl_core_1.ChainSlug.ARBITRUM]: 10 * 60,
+        [dl_core_1.ChainSlug.OPTIMISM]: 10 * 60,
+        [dl_core_1.ChainSlug.POLYGON_MAINNET]: 10 * 60,
+    },
+};

package/dist/index.d.ts

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

package/dist/index.js

@@ -15,6 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./models"), exports);
-__exportStar(require("./types"), exports);
 __exportStar(require("./services"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);

package/dist/models/attestSignature.d.ts

@@ -32,3 +32,4 @@ export declare const AttestSignatureModel: {
         type: DataTypes.StringDataTypeConstructor;
     };
 };
+export declare const addSignatureHooks: () => void;

package/dist/models/attestSignature.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AttestSignatureModel = exports.AttestSignature = void 0;
+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;
@@ -30,3 +31,23 @@ exports.AttestSignatureModel = {
         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.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;
+    };
+};
+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.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,
+    },
+};
+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

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

package/dist/models/index.js

@@ -17,3 +17,5 @@ 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);

package/dist/models/message.d.ts

@@ -163,3 +163,4 @@ export declare const MessageModel: {
         defaultValue: string;
     };
 };
+export declare const addMessageHooks: () => void;

package/dist/models/message.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageModel = exports.Message = exports.ExecutionRelayStatus = void 0;
+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";
@@ -133,3 +134,50 @@ exports.MessageModel = {
         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);
+    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

@@ -63,6 +63,8 @@ export declare class Packet extends Model {
     attestRelayStatus: AttestRelayStatus;
     outboundTxHash: string;
     outboundTime: number;
+    proposeTime: number;
+    attestTime: number;
     packetTripTxHash: string;
     isFilled: boolean;
     isSealed: boolean;
@@ -71,6 +73,7 @@ export declare class Packet extends Model {
     isVerified: boolean;
     isFullyExecuted: boolean;
     tripreason: TripReason;
+    executionWaitTime: number;
 }
 export declare const PacketModel: {
     id: {
@@ -153,6 +156,12 @@ export declare const PacketModel: {
     outboundTime: {
         type: DataTypes.IntegerDataTypeConstructor;
     };
+    proposeTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    attestTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
     sealTime: {
         type: DataTypes.IntegerDataTypeConstructor;
     };
@@ -199,6 +208,9 @@ export declare const PacketModel: {
     selectedProposalCount: {
         type: DataTypes.IntegerDataTypeConstructor;
     };
+    executionWaitTime: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
     attestTxId: {
         type: DataTypes.StringDataTypeConstructor;
         defaultValue: string;
@@ -218,3 +230,4 @@ export declare const PacketModel: {
         defaultValue: AttestRelayStatus;
     };
 };
+export declare const addPacketHooks: () => void;