@dhedge/backend-flatcoin-core 0.1.28 → 0.1.30

package/dist/constants/enum.d.ts

@@ -17,3 +17,11 @@ export declare enum LeveragePositionStatus {
     CLOSED = "CLOSED",
     LIQUIDATED = "LIQUIDATED"
 }
+export declare enum OrderType {
+    NONE = 0,
+    STABLE_DEPOSIT = 1,
+    STABLE_WITHDRAW = 2,
+    LEVERAGE_OPEN = 3,
+    LEVERAGE_CLOSE = 4,
+    LEVERAGE_ADJUST = 5
+}

package/dist/constants/enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LeveragePositionStatus = exports.getChartPeriod = exports.HistoricalPeriod = exports.PERIOD_IN_SECONDS = void 0;
+exports.OrderType = exports.LeveragePositionStatus = exports.getChartPeriod = exports.HistoricalPeriod = exports.PERIOD_IN_SECONDS = void 0;
 var HistoricalPeriod;
 (function (HistoricalPeriod) {
     HistoricalPeriod["ONE_DAY"] = "1d";
@@ -30,3 +30,12 @@ var LeveragePositionStatus;
     LeveragePositionStatus["CLOSED"] = "CLOSED";
     LeveragePositionStatus["LIQUIDATED"] = "LIQUIDATED";
 })(LeveragePositionStatus || (exports.LeveragePositionStatus = LeveragePositionStatus = {}));
+var OrderType;
+(function (OrderType) {
+    OrderType[OrderType["NONE"] = 0] = "NONE";
+    OrderType[OrderType["STABLE_DEPOSIT"] = 1] = "STABLE_DEPOSIT";
+    OrderType[OrderType["STABLE_WITHDRAW"] = 2] = "STABLE_WITHDRAW";
+    OrderType[OrderType["LEVERAGE_OPEN"] = 3] = "LEVERAGE_OPEN";
+    OrderType[OrderType["LEVERAGE_CLOSE"] = 4] = "LEVERAGE_CLOSE";
+    OrderType[OrderType["LEVERAGE_ADJUST"] = 5] = "LEVERAGE_ADJUST";
+})(OrderType || (exports.OrderType = OrderType = {}));

package/dist/contracts/abi/flatcoin-errors.js

@@ -436,17 +436,6 @@ exports.FlatcoinErrors = [
         name: 'PriceImpactDuringWithdraw',
         type: 'error',
     },
-    {
-        inputs: [
-            {
-                internalType: 'uint256',
-                name: 'executableTime',
-                type: 'uint256',
-            },
-        ],
-        name: 'ExecutableTimeNotReached',
-        type: 'error',
-    },
     {
         inputs: [
             {
@@ -463,17 +452,6 @@ exports.FlatcoinErrors = [
         name: 'InvalidThresholds',
         type: 'error',
     },
-    {
-        inputs: [
-            {
-                internalType: 'string',
-                name: 'variableName',
-                type: 'string',
-            },
-        ],
-        name: 'InvariantViolation',
-        type: 'error',
-    },
     {
         inputs: [
             {
@@ -511,53 +489,4 @@ exports.FlatcoinErrors = [
         name: 'ModuleKeyEmpty',
         type: 'error',
     },
-    {
-        inputs: [
-            {
-                internalType: 'uint256',
-                name: 'tokenId',
-                type: 'uint256',
-            },
-            {
-                internalType: 'address',
-                name: 'msgSender',
-                type: 'address',
-            },
-        ],
-        name: 'NotTokenOwner',
-        type: 'error',
-    },
-    {
-        inputs: [
-            {
-                internalType: 'address',
-                name: 'msgSender',
-                type: 'address',
-            },
-        ],
-        name: 'OnlyAuthorizedModule',
-        type: 'error',
-    },
-    {
-        inputs: [
-            {
-                internalType: 'address',
-                name: 'msgSender',
-                type: 'address',
-            },
-        ],
-        name: 'OnlyOwner',
-        type: 'error',
-    },
-    {
-        inputs: [
-            {
-                internalType: 'string',
-                name: 'variableName',
-                type: 'string',
-            },
-        ],
-        name: 'ZeroAddress',
-        type: 'error',
-    },
 ];

package/dist/service/error.handler.d.ts

@@ -0,0 +1,10 @@
+import { Logger } from '@nestjs/common';
+import { NotificationService } from './notification.service';
+export declare class ErrorHandler {
+    private readonly notificationService;
+    private readonly logger;
+    private readonly errorInterface;
+    constructor(notificationService: NotificationService, logger: Logger);
+    handleError(message: string, error: any): Promise<void>;
+    getGasEstimateErrorName(gasEstimateError: string): string;
+}

package/dist/service/error.handler.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = void 0;
+const common_1 = require("@nestjs/common");
+const notification_service_1 = require("./notification.service");
+const ethers_1 = require("ethers");
+const contracts_1 = require("../contracts");
+let ErrorHandler = class ErrorHandler {
+    constructor(notificationService, logger) {
+        this.notificationService = notificationService;
+        this.logger = logger;
+        this.errorInterface = new ethers_1.ethers.utils.Interface(contracts_1.FlatcoinErrors);
+    }
+    async handleError(message, error) {
+        const messageToSlack = `${message}, error ${error?.message}`;
+        this.logger.error(messageToSlack, error);
+        this.logger.error(error.stack);
+        if (process.env.SLACK_NOTIFICATIONS_ENABLED === 'true') {
+            await this.notificationService.sendNotification(messageToSlack);
+        }
+    }
+    getGasEstimateErrorName(gasEstimateError) {
+        if (!gasEstimateError)
+            return '';
+        try {
+            const jsonStartIndex = gasEstimateError.toString().indexOf('error=') + 6;
+            const jsonEndIndex = gasEstimateError.toString().indexOf(', code=');
+            if (jsonStartIndex > 0) {
+                const errorJSON = JSON.parse(gasEstimateError.toString().slice(jsonStartIndex, jsonEndIndex));
+                return this.errorInterface.parseError(errorJSON.error.data).name;
+            }
+            else {
+                return gasEstimateError;
+            }
+        }
+        catch (error) {
+            this.logger.error("can't get gas estimate error", error);
+            return '';
+        }
+    }
+};
+exports.ErrorHandler = ErrorHandler;
+exports.ErrorHandler = ErrorHandler = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [notification_service_1.NotificationService, common_1.Logger])
+], ErrorHandler);

package/dist/service/graph-query.service.d.ts

@@ -0,0 +1,16 @@
+import { Logger } from '@nestjs/common';
+import { AnnouncedOrder, LeveragePositionEvent } from '../utils';
+import { GraphQLClient } from 'graphql-request';
+export declare class GraphQueryService {
+    private readonly graphQLClient;
+    private readonly logger;
+    constructor(graphQLClient: GraphQLClient, logger: Logger);
+    getAnnouncedOrders(timestampFrom: number): Promise<AnnouncedOrder[]>;
+    getLeverageOpens(blockFrom: number): Promise<LeveragePositionEvent[]>;
+    getLeverageCloses(blockFrom: number): Promise<LeveragePositionEvent[]>;
+    getPositionLiquidateds(blockFrom: number): Promise<LeveragePositionEvent[]>;
+}
+export declare const getAnnouncedOrdersQuery: string;
+export declare const getLeverageOpensQuery: string;
+export declare const getLeverageClosesQuery: string;
+export declare const getPositionLiquidatedsQuery: string;

package/dist/service/graph-query.service.js

@@ -0,0 +1,117 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPositionLiquidatedsQuery = exports.getLeverageClosesQuery = exports.getLeverageOpensQuery = exports.getAnnouncedOrdersQuery = exports.GraphQueryService = void 0;
+const common_1 = require("@nestjs/common");
+const graphql_request_1 = require("graphql-request");
+const constants_1 = require("../constants");
+let GraphQueryService = class GraphQueryService {
+    constructor(graphQLClient, logger) {
+        this.graphQLClient = graphQLClient;
+        this.logger = logger;
+    }
+    async getAnnouncedOrders(timestampFrom) {
+        const variables = { timestamp: timestampFrom.toString() };
+        try {
+            const response = await this.graphQLClient.request(exports.getAnnouncedOrdersQuery, variables);
+            this.logger.log(`Fetched ${response.orderAnnounceds.length} orderAnnounceds events from the graph`);
+            return response.orderAnnounceds;
+        }
+        catch (error) {
+            this.logger.error('Error fetching announced orders from the graph:', error);
+            throw error;
+        }
+    }
+    async getLeverageOpens(blockFrom) {
+        const variables = { fromBlock: blockFrom };
+        try {
+            const response = await this.graphQLClient.request(exports.getLeverageOpensQuery, variables);
+            this.logger.log(`Fetched ${response.leverageOpens.length} leverageOpens events from the graph`);
+            response.leverageOpens.forEach((events) => (events.eventType = constants_1.LeveragePositionStatus.OPEN));
+            return response.leverageOpens;
+        }
+        catch (error) {
+            this.logger.error('Error fetching leverageOpens events from the graph:', error);
+            throw error;
+        }
+    }
+    async getLeverageCloses(blockFrom) {
+        const variables = { fromBlock: blockFrom };
+        try {
+            const response = await this.graphQLClient.request(exports.getLeverageClosesQuery, variables);
+            this.logger.log(`Fetched ${response.leverageCloses.length} leverageCloses events from the graph`);
+            response.leverageCloses.forEach((events) => (events.eventType = constants_1.LeveragePositionStatus.CLOSED));
+            return response.leverageCloses;
+        }
+        catch (error) {
+            this.logger.error('Error fetching leverageCloses events from the graph:', error);
+            throw error;
+        }
+    }
+    async getPositionLiquidateds(blockFrom) {
+        const variables = { fromBlock: blockFrom };
+        try {
+            const response = await this.graphQLClient.request(exports.getPositionLiquidatedsQuery, variables);
+            this.logger.log(`Fetched ${response.positionLiquidateds.length} positionLiquidateds events from the graph`);
+            response.positionLiquidateds.forEach((events) => (events.eventType = constants_1.LeveragePositionStatus.LIQUIDATED));
+            return response.positionLiquidateds;
+        }
+        catch (error) {
+            this.logger.error('Error fetching positionLiquidateds events from the graph:', error);
+            throw error;
+        }
+    }
+};
+exports.GraphQueryService = GraphQueryService;
+exports.GraphQueryService = GraphQueryService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [graphql_request_1.GraphQLClient, common_1.Logger])
+], GraphQueryService);
+exports.getAnnouncedOrdersQuery = (0, graphql_request_1.gql) `
+  query GetAnnouncedOrders($timestamp: String) {
+    orderAnnounceds(where: { blockTimestamp_gte: $timestamp }) {
+      blockNumber
+      transactionHash
+      orderType
+      account
+      blockTimestamp
+    }
+  }
+`;
+exports.getLeverageOpensQuery = (0, graphql_request_1.gql) `
+  query GetLeverageOpens($fromBlock: Int) {
+    leverageOpens(where: { blockNumber_gt: $fromBlock }) {
+      blockNumber
+      blockTimestamp
+      tokenId
+      account
+    }
+  }
+`;
+exports.getLeverageClosesQuery = (0, graphql_request_1.gql) `
+  query GetLeverageCloses($fromBlock: Int) {
+    leverageCloses(where: { blockNumber_gt: $fromBlock }) {
+      blockNumber
+      blockTimestamp
+      tokenId
+    }
+  }
+`;
+exports.getPositionLiquidatedsQuery = (0, graphql_request_1.gql) `
+  query GetPositionLiquidateds($fromBlock: Int) {
+    positionLiquidateds(where: { blockNumber_gt: $fromBlock }) {
+      blockNumber
+      blockTimestamp
+      tokenId
+      liquidator
+    }
+  }
+`;

package/dist/service/index.d.ts

@@ -1 +1,4 @@
 export * from './app-price.service';
+export * from './graph-query.service';
+export * from './error.handler';
+export * from './notification.service';

package/dist/service/index.js

@@ -15,3 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./app-price.service"), exports);
+__exportStar(require("./graph-query.service"), exports);
+__exportStar(require("./error.handler"), exports);
+__exportStar(require("./notification.service"), exports);

package/dist/service/notification.service.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from '@nestjs/common';
+export declare class NotificationService {
+    private readonly logger;
+    private readonly slackUri;
+    constructor(logger: Logger);
+    sendNotification(message: string): Promise<void>;
+}

package/dist/service/notification.service.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationService = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = __importDefault(require("axios"));
+let NotificationService = class NotificationService {
+    constructor(logger) {
+        this.logger = logger;
+        if (process.env.SLACK_CHANNEL) {
+            this.slackUri = process.env.SLACK_CHANNEL;
+        }
+        else {
+            throw new Error('NotificationService -> env property SLACK_CHANNEL is not provided');
+        }
+    }
+    async sendNotification(message) {
+        try {
+            await axios_1.default.post(this.slackUri, { text: message });
+        }
+        catch (error) {
+            this.logger.error(`Error sending notification '${message}' to slack channel ${process.env.SLACK_CHANNEL}`, error);
+        }
+    }
+};
+exports.NotificationService = NotificationService;
+exports.NotificationService = NotificationService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [common_1.Logger])
+], NotificationService);

package/dist/utils/shared-types.d.ts

@@ -5,20 +5,49 @@ export interface DepositEvent {
     depositAmount: string;
     mintedAmount: string;
 }
-export interface Deposits {
-    deposits: DepositEvent[];
-}
 export interface WithdrawEvent {
     blockNumber: string;
     withdrawer: string;
     withdrawAmount: string;
     burnedAmount: string;
 }
-export interface Withdraws {
-    withdraws: WithdrawEvent[];
-}
-export declare class DepositWithdrawAction {
+export interface DepositWithdrawAction {
     isDeposit: boolean;
     blockNumber: number;
     unitAmount: BigNumber;
 }
+export interface AnnouncedOrder {
+    blockNumber: number;
+    transactionHash: string;
+    orderType: string;
+    account: string;
+    blockTimestamp: number;
+    executeInTime: number;
+    expirationTime: number;
+}
+export interface LeveragePositionEvent {
+    blockNumber: number;
+    blockTimestamp: number;
+    tokenId: number;
+    account: string;
+    liquidator: string;
+    eventType: string;
+}
+export interface DepositsEventsData {
+    deposits: DepositEvent[];
+}
+export interface WithdrawEventsData {
+    withdraws: WithdrawEvent[];
+}
+export interface LeverageClosesData {
+    leverageCloses: LeveragePositionEvent[];
+}
+export interface LeverageOpensData {
+    leverageOpens: LeveragePositionEvent[];
+}
+export interface PositionLiquidatedsData {
+    positionLiquidateds: LeveragePositionEvent[];
+}
+export interface AnnouncedOrderData {
+    orderAnnounceds: AnnouncedOrder[];
+}

package/dist/utils/shared-types.js

@@ -1,6 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DepositWithdrawAction = void 0;
-class DepositWithdrawAction {
-}
-exports.DepositWithdrawAction = DepositWithdrawAction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/backend-flatcoin-core",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "Backend Flatcoin Core",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,7 +23,8 @@
     "ethers": "5.7.2",
     "nest-winston": "1.9.3",
     "typeorm": "^0.3.17",
-    "winston": "3.10.0"
+    "winston": "3.10.0",
+    "graphql-request": "6.1.0"
   },
   "devDependencies": {
     "@nestjs/testing": "^9.4.3",