@dhedge/backend-flatcoin-core 0.3.16 → 0.3.18

package/dist/constants/enum.d.ts

@@ -10,6 +10,9 @@ export declare enum BlockchainCode {
     BASE = "BASE",
     ARBITRUM = "ARBITRUM"
 }
+export declare enum Market {
+    RETH_BASE = "RETH_BASE"
+}
 export declare enum HistoricalPeriod {
     ONE_DAY = "1d",
     ONE_WEEK = "1w",

package/dist/constants/enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LimitOrderStatus = exports.LimitOrderExecutionType = exports.OrderType = exports.LeveragePositionStatus = exports.getChartPeriod = exports.PERIOD_IN_SECONDS = exports.HistoricalPeriod = exports.BlockchainCode = exports.PERIODS = void 0;
+exports.LimitOrderStatus = exports.LimitOrderExecutionType = exports.OrderType = exports.LeveragePositionStatus = exports.getChartPeriod = exports.PERIOD_IN_SECONDS = exports.HistoricalPeriod = exports.Market = exports.BlockchainCode = exports.PERIODS = void 0;
 var PERIODS;
 (function (PERIODS) {
     PERIODS["DAY"] = "DAY";
@@ -15,6 +15,10 @@ var BlockchainCode;
     BlockchainCode["BASE"] = "BASE";
     BlockchainCode["ARBITRUM"] = "ARBITRUM";
 })(BlockchainCode || (exports.BlockchainCode = BlockchainCode = {}));
+var Market;
+(function (Market) {
+    Market["RETH_BASE"] = "RETH_BASE";
+})(Market || (exports.Market = Market = {}));
 var HistoricalPeriod;
 (function (HistoricalPeriod) {
     HistoricalPeriod["ONE_DAY"] = "1d";

package/dist/entity/apy-history.d.ts

@@ -1,8 +1,8 @@
 export declare class ApyHistory {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     daily: number;
     weekly: number;
     timestamp: number;
-    constructor(daily: number, weekly: number, timestamp: number, blockchainCode: string);
+    constructor(daily: number, weekly: number, timestamp: number, marketId: string);
 }

package/dist/entity/apy-history.js

@@ -14,11 +14,11 @@ const typeorm_1 = require("typeorm");
 const graphql_1 = require("@nestjs/graphql");
 const utils_1 = require("../utils");
 let ApyHistory = class ApyHistory {
-    constructor(daily, weekly, timestamp, blockchainCode) {
+    constructor(daily, weekly, timestamp, marketId) {
         this.daily = daily;
         this.weekly = weekly;
         this.timestamp = timestamp;
-        this.blockchainCode = blockchainCode;
+        this.marketId = marketId;
     }
 };
 exports.ApyHistory = ApyHistory;
@@ -28,9 +28,9 @@ __decorate([
 ], ApyHistory.prototype, "id", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], ApyHistory.prototype, "blockchainCode", void 0);
+], ApyHistory.prototype, "marketId", void 0);
 __decorate([
     (0, graphql_1.Field)(() => graphql_1.Float, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'daily', type: 'decimal', precision: 30, scale: 2, nullable: false, transformer: utils_1.numericTransformer }),

package/dist/entity/apy.d.ts

@@ -1,6 +1,6 @@
 export declare class Apy {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     monthly: number;
     weekly: number;
     daily: number;

package/dist/entity/apy.js

@@ -22,9 +22,9 @@ __decorate([
 ], Apy.prototype, "id", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], Apy.prototype, "blockchainCode", void 0);
+], Apy.prototype, "marketId", void 0);
 __decorate([
     (0, graphql_1.Field)(() => graphql_1.Float, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'monthly', type: 'decimal', precision: 30, scale: 2, transformer: utils_1.numericTransformer }),

package/dist/entity/borrowing-rate-apy-history.d.ts

@@ -1,8 +1,8 @@
 export declare class BorrowingRateApyHistory {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     daily: number;
     eightHour: number;
     timestamp: number;
-    constructor(daily: number, eightHour: number, timestamp: number, blockchainCode: string);
+    constructor(daily: number, eightHour: number, timestamp: number, marketId: string);
 }

package/dist/entity/borrowing-rate-apy-history.js

@@ -14,11 +14,11 @@ const typeorm_1 = require("typeorm");
 const graphql_1 = require("@nestjs/graphql");
 const utils_1 = require("../utils");
 let BorrowingRateApyHistory = class BorrowingRateApyHistory {
-    constructor(daily, eightHour, timestamp, blockchainCode) {
+    constructor(daily, eightHour, timestamp, marketId) {
         this.daily = daily;
         this.eightHour = eightHour;
         this.timestamp = timestamp;
-        this.blockchainCode = blockchainCode;
+        this.marketId = marketId;
     }
 };
 exports.BorrowingRateApyHistory = BorrowingRateApyHistory;
@@ -28,9 +28,9 @@ __decorate([
 ], BorrowingRateApyHistory.prototype, "id", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], BorrowingRateApyHistory.prototype, "blockchainCode", void 0);
+], BorrowingRateApyHistory.prototype, "marketId", void 0);
 __decorate([
     (0, graphql_1.Field)(() => graphql_1.Float, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'daily', type: 'decimal', precision: 30, scale: 2, nullable: false, transformer: utils_1.numericTransformer }),

package/dist/entity/flatcoin-pnl.d.ts

@@ -1,7 +1,7 @@
 import { BigNumber } from 'ethers';
 export declare class FlatcoinPnl {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     account: string;
     pnlUsdFormatted: number;
     pnlPercentage: number;

package/dist/entity/flatcoin-pnl.js

@@ -23,9 +23,9 @@ __decorate([
 ], FlatcoinPnl.prototype, "id", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], FlatcoinPnl.prototype, "blockchainCode", void 0);
+], FlatcoinPnl.prototype, "marketId", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'account' }),

package/dist/entity/flatcoin.price.parent.d.ts

@@ -1,6 +1,6 @@
 export declare abstract class FlatcoinPriceParent {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     priceUsd: string;
     priceUsdFormatted: number;
     timestamp: number;

package/dist/entity/flatcoin.price.parent.js

@@ -22,9 +22,9 @@ __decorate([
 ], FlatcoinPriceParent.prototype, "id", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], FlatcoinPriceParent.prototype, "blockchainCode", void 0);
+], FlatcoinPriceParent.prototype, "marketId", void 0);
 __decorate([
     (0, graphql_1.Field)(),
     (0, typeorm_1.Column)({ name: 'price_usd', type: 'numeric', precision: 30 }),

package/dist/entity/leverage-leaderboard.d.ts

@@ -1,13 +1,17 @@
 import { BigNumber } from 'ethers';
 export declare class LeverageLeaderboard {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     account: string;
     period: string;
     totalPnlReth: BigNumber;
+    totalPnlCollateral: BigNumber;
     totalPnlRethFormatted: number;
+    totalPnlCollateralFormatted: number;
     totalTradedVolumeReth: BigNumber;
     totalTradedVolumeRethFormatted: number;
+    totalTradedVolumeCollateral: BigNumber;
+    totalTradedVolumeCollateralFormatted: number;
     closedTradesCount: number;
     lastClosedPositionTimestamp: number;
 }

package/dist/entity/leverage-leaderboard.js

@@ -23,9 +23,9 @@ __decorate([
 ], LeverageLeaderboard.prototype, "id", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], LeverageLeaderboard.prototype, "blockchainCode", void 0);
+], LeverageLeaderboard.prototype, "marketId", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'account', unique: true, nullable: false }),
@@ -40,6 +40,10 @@ __decorate([
     (0, typeorm_1.Column)({ name: 'total_pnl_reth', type: 'bigint', precision: 30, transformer: utils_1.bigNumberTransformer }),
     __metadata("design:type", ethers_1.BigNumber)
 ], LeverageLeaderboard.prototype, "totalPnlReth", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'total_pnl_collateral', type: 'bigint', precision: 30, transformer: utils_1.bigNumberTransformer }),
+    __metadata("design:type", ethers_1.BigNumber)
+], LeverageLeaderboard.prototype, "totalPnlCollateral", void 0);
 __decorate([
     (0, graphql_1.Field)(() => graphql_1.Float, { nullable: true }),
     (0, typeorm_1.Column)({
@@ -51,6 +55,17 @@ __decorate([
     }),
     __metadata("design:type", Number)
 ], LeverageLeaderboard.prototype, "totalPnlRethFormatted", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => graphql_1.Float, { nullable: true }),
+    (0, typeorm_1.Column)({
+        name: 'total_pnl_collateral_formatted',
+        type: 'decimal',
+        precision: 30,
+        scale: 2,
+        transformer: utils_1.numericTransformer,
+    }),
+    __metadata("design:type", Number)
+], LeverageLeaderboard.prototype, "totalPnlCollateralFormatted", void 0);
 __decorate([
     (0, typeorm_1.Column)({ name: 'total_traded_volume_reth', type: 'bigint', precision: 30, transformer: utils_1.bigNumberTransformer }),
     __metadata("design:type", ethers_1.BigNumber)
@@ -59,6 +74,14 @@ __decorate([
     (0, graphql_1.Field)(() => graphql_1.Float, { nullable: true }),
     __metadata("design:type", Number)
 ], LeverageLeaderboard.prototype, "totalTradedVolumeRethFormatted", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'total_traded_volume_collateral', type: 'bigint', precision: 30, transformer: utils_1.bigNumberTransformer }),
+    __metadata("design:type", ethers_1.BigNumber)
+], LeverageLeaderboard.prototype, "totalTradedVolumeCollateral", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => graphql_1.Float, { nullable: true }),
+    __metadata("design:type", Number)
+], LeverageLeaderboard.prototype, "totalTradedVolumeCollateralFormatted", void 0);
 __decorate([
     (0, graphql_1.Field)(() => graphql_1.Float, { nullable: true }),
     (0, typeorm_1.Column)({ name: 'closed_trades_count', type: 'numeric', precision: 25, transformer: utils_1.numericTransformer }),

package/dist/entity/leverage-monthly-pnl.d.ts

@@ -1,10 +1,12 @@
 import { BigNumber } from 'ethers';
 export declare class LeverageMonthlyPnl {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     account: string;
     pnlReth: BigNumber;
+    pnlCollateral: BigNumber;
     pnlRethFormatted: number;
+    pnlCollateralFormatted: number;
     timestamp: number;
     lastClosedPositionTimestamp: number;
 }

package/dist/entity/leverage-monthly-pnl.js

@@ -23,9 +23,9 @@ __decorate([
 ], LeverageMonthlyPnl.prototype, "id", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], LeverageMonthlyPnl.prototype, "blockchainCode", void 0);
+], LeverageMonthlyPnl.prototype, "marketId", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'account', unique: true, nullable: false }),
@@ -35,11 +35,26 @@ __decorate([
     (0, typeorm_1.Column)({ name: 'pnl_reth', type: 'bigint', precision: 30, transformer: utils_1.bigNumberTransformer }),
     __metadata("design:type", ethers_1.BigNumber)
 ], LeverageMonthlyPnl.prototype, "pnlReth", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'pnl_collateral', type: 'bigint', precision: 30, transformer: utils_1.bigNumberTransformer }),
+    __metadata("design:type", ethers_1.BigNumber)
+], LeverageMonthlyPnl.prototype, "pnlCollateral", void 0);
 __decorate([
     (0, graphql_1.Field)(() => graphql_1.Float, { nullable: true }),
     (0, typeorm_1.Column)({ name: 'pnl_reth_formatted', type: 'decimal', precision: 30, scale: 4, transformer: utils_1.numericTransformer }),
     __metadata("design:type", Number)
 ], LeverageMonthlyPnl.prototype, "pnlRethFormatted", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => graphql_1.Float, { nullable: true }),
+    (0, typeorm_1.Column)({
+        name: 'pnl_collateral_formatted',
+        type: 'decimal',
+        precision: 30,
+        scale: 4,
+        transformer: utils_1.numericTransformer,
+    }),
+    __metadata("design:type", Number)
+], LeverageMonthlyPnl.prototype, "pnlCollateralFormatted", void 0);
 __decorate([
     (0, graphql_1.Field)(() => graphql_1.Float, { nullable: true }),
     (0, typeorm_1.Column)({ name: 'timestamp', type: 'numeric', precision: 25, transformer: utils_1.numericTransformer }),

package/dist/entity/limit-order.entity.d.ts

@@ -2,7 +2,7 @@ import { BigNumber } from 'ethers';
 import { PositionEntity } from './position-entity';
 export declare class LimitOrderEntity {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     status: string;
     priceLowerThreshold: BigNumber;
     priceUpperThreshold: BigNumber;

package/dist/entity/limit-order.entity.js

@@ -22,9 +22,9 @@ __decorate([
     __metadata("design:type", Number)
 ], LimitOrderEntity.prototype, "id", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], LimitOrderEntity.prototype, "blockchainCode", void 0);
+], LimitOrderEntity.prototype, "marketId", void 0);
 __decorate([
     (0, typeorm_1.Column)({ name: 'status', nullable: false }),
     __metadata("design:type", String)

package/dist/entity/multichain-config.d.ts

@@ -1,6 +1,6 @@
 export declare class MultichainConfig {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     appName: string;
     blockchainNetworkName: string;
     blockchainId: number;

package/dist/entity/multichain-config.js

@@ -19,9 +19,9 @@ __decorate([
     __metadata("design:type", Number)
 ], MultichainConfig.prototype, "id", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ name: 'blockchain_code', nullable: false }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], MultichainConfig.prototype, "blockchainCode", void 0);
+], MultichainConfig.prototype, "marketId", void 0);
 __decorate([
     (0, typeorm_1.Column)({ name: 'app_name', nullable: false }),
     __metadata("design:type", String)

package/dist/entity/order-execution.d.ts

@@ -1,6 +1,6 @@
 export declare class OrderExecution {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     txHash: string;
     executorAddress: string;
     type: string;

package/dist/entity/order-execution.js

@@ -20,9 +20,9 @@ __decorate([
     __metadata("design:type", Number)
 ], OrderExecution.prototype, "id", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], OrderExecution.prototype, "blockchainCode", void 0);
+], OrderExecution.prototype, "marketId", void 0);
 __decorate([
     (0, typeorm_1.Column)({ name: 'tx_hash' }),
     __metadata("design:type", String)

package/dist/entity/period-performance.d.ts

@@ -1,6 +1,6 @@
 export declare class PeriodPerformance {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     day: number;
     week: number;
     month: number;

package/dist/entity/period-performance.js

@@ -22,9 +22,9 @@ __decorate([
 ], PeriodPerformance.prototype, "id", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], PeriodPerformance.prototype, "blockchainCode", void 0);
+], PeriodPerformance.prototype, "marketId", void 0);
 __decorate([
     (0, graphql_1.Field)(() => graphql_1.Float, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'day', type: 'decimal', precision: 30, scale: 2, transformer: utils_1.numericTransformer }),

package/dist/entity/position-entity.d.ts

@@ -2,7 +2,7 @@ import { BigNumber } from 'ethers';
 import { LimitOrderEntity } from './limit-order.entity';
 export declare class PositionEntity {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     tokenId: number;
     account: string;
     status: string;

package/dist/entity/position-entity.js

@@ -22,9 +22,9 @@ __decorate([
     __metadata("design:type", Number)
 ], PositionEntity.prototype, "id", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], PositionEntity.prototype, "blockchainCode", void 0);
+], PositionEntity.prototype, "marketId", void 0);
 __decorate([
     (0, typeorm_1.Column)({
         name: 'token_id',

package/dist/entity/protocol-metrics.d.ts

@@ -1,7 +1,7 @@
 import { BigNumber } from 'ethers';
 export declare class ProtocolMetrics {
     id: number;
-    blockchainCode: string;
+    marketId: string;
     unitDepositsVolume: BigNumber;
     unitWithdrawalsVolume: BigNumber;
     leverageTotalVolumeUsd: number;

package/dist/entity/protocol-metrics.js

@@ -24,9 +24,9 @@ __decorate([
 ], ProtocolMetrics.prototype, "id", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
-    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    (0, typeorm_1.Column)({ name: 'market_id' }),
     __metadata("design:type", String)
-], ProtocolMetrics.prototype, "blockchainCode", void 0);
+], ProtocolMetrics.prototype, "marketId", void 0);
 __decorate([
     (0, graphql_1.Field)(() => utils_2.CustomBigNumberScalar, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'unit_deposits_volume', type: 'bigint', precision: 30, transformer: utils_1.bigNumberTransformer }),

package/dist/repository/apy-history.repository.d.ts

@@ -5,6 +5,6 @@ export declare class ApyHistoryRepository {
     private readonly repository;
     private readonly logger;
     constructor(repository: Repository<ApyHistory>, logger: Logger);
-    getAllFromTimestamp(blockchainCode: string, fromTimestamp: number): Promise<ApyHistory[]>;
+    getAllFromTimestamp(marketId: string, fromTimestamp: number): Promise<ApyHistory[]>;
     save(apyHistory: ApyHistory): void;
 }

package/dist/repository/apy-history.repository.js

@@ -22,11 +22,11 @@ let ApyHistoryRepository = class ApyHistoryRepository {
         this.repository = repository;
         this.logger = logger;
     }
-    async getAllFromTimestamp(blockchainCode, fromTimestamp) {
+    async getAllFromTimestamp(marketId, fromTimestamp) {
         return await this.repository
             .createQueryBuilder('apy_history')
             .where('timestamp > :fromTimestamp', { fromTimestamp: fromTimestamp })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .orderBy('apy_history.timestamp', 'ASC')
             .getMany();
     }

package/dist/repository/apy.repository.d.ts

@@ -5,6 +5,6 @@ export declare class ApyRepository {
     private repository;
     private readonly logger;
     constructor(repository: Repository<Apy>, logger: Logger);
-    getApy(blockchainCode: string): Promise<Apy | null>;
+    getApy(marketId: string): Promise<Apy | null>;
     save(apy: Apy): void;
 }

package/dist/repository/apy.repository.js

@@ -22,11 +22,8 @@ let ApyRepository = class ApyRepository {
         this.repository = repository;
         this.logger = logger;
     }
-    async getApy(blockchainCode) {
-        return this.repository
-            .createQueryBuilder()
-            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
-            .getOne();
+    async getApy(marketId) {
+        return this.repository.createQueryBuilder().where('market_id = :marketId', { marketId: marketId }).getOne();
     }
     save(apy) {
         this.repository.save(apy).catch((error) => this.logger.error('Error while saving apy', error));

package/dist/repository/borrowing-rate-apy-history.repository.d.ts

@@ -3,6 +3,6 @@ import { BorrowingRateApyHistory } from '../entity';
 export declare class BorrowingRateApyHistoryRepository {
     private readonly repository;
     constructor(repository: Repository<BorrowingRateApyHistory>);
-    getAllFromTimestamp(blockchainCode: string, fromTimestamp: number): Promise<BorrowingRateApyHistory[]>;
+    getAllFromTimestamp(marketId: string, fromTimestamp: number): Promise<BorrowingRateApyHistory[]>;
     save(apyHistory: BorrowingRateApyHistory): Promise<void>;
 }

package/dist/repository/borrowing-rate-apy-history.repository.js

@@ -21,11 +21,11 @@ let BorrowingRateApyHistoryRepository = class BorrowingRateApyHistoryRepository
     constructor(repository) {
         this.repository = repository;
     }
-    async getAllFromTimestamp(blockchainCode, fromTimestamp) {
+    async getAllFromTimestamp(marketId, fromTimestamp) {
         return await this.repository
             .createQueryBuilder()
             .where('timestamp > :fromTimestamp', { fromTimestamp: fromTimestamp })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .orderBy('timestamp', 'ASC')
             .getMany();
     }

package/dist/repository/flatcoin-pnl.repository.d.ts

@@ -5,9 +5,9 @@ export declare class FlatcoinPnlRepository {
     private readonly repository;
     private readonly logger;
     constructor(repository: Repository<FlatcoinPnl>, logger: Logger);
-    getAll(blockchainCode: string): Promise<FlatcoinPnl[]>;
+    getAll(marketId: string): Promise<FlatcoinPnl[]>;
     save(flatcoinPnl: FlatcoinPnl): void;
     saveAll(flatcoinPnls: FlatcoinPnl[]): void;
-    getLastUpdatedAt(blockchainCode: string): Promise<FlatcoinPnl | null>;
-    findByAccount(account: string, blockchainCode: string): Promise<FlatcoinPnl | null>;
+    getLastUpdatedAt(marketId: string): Promise<FlatcoinPnl | null>;
+    findByAccount(account: string, marketId: string): Promise<FlatcoinPnl | null>;
 }

package/dist/repository/flatcoin-pnl.repository.js

@@ -22,11 +22,8 @@ let FlatcoinPnlRepository = class FlatcoinPnlRepository {
         this.repository = repository;
         this.logger = logger;
     }
-    async getAll(blockchainCode) {
-        return this.repository
-            .createQueryBuilder()
-            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
-            .getMany();
+    async getAll(marketId) {
+        return this.repository.createQueryBuilder().where('market_id = :marketId', { marketId: marketId }).getMany();
     }
     save(flatcoinPnl) {
         this.repository.save(flatcoinPnl).catch((error) => this.logger.error('Error while saving flatcoin pnl', error));
@@ -34,21 +31,19 @@ let FlatcoinPnlRepository = class FlatcoinPnlRepository {
     saveAll(flatcoinPnls) {
         this.repository.save(flatcoinPnls).catch((error) => this.logger.error('Error while saving flatcoin pnl', error));
     }
-    async getLastUpdatedAt(blockchainCode) {
+    async getLastUpdatedAt(marketId) {
         return await this.repository
             .createQueryBuilder('pnl')
-            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .where('market_id = :marketId', { marketId: marketId })
             .orderBy('pnl.block_updated_at', 'DESC')
             .take(1)
             .getOne();
     }
-    async findByAccount(account, blockchainCode) {
+    async findByAccount(account, marketId) {
         return await this.repository
             .createQueryBuilder('pnl')
-            .where('pnl.account = :account')
-            .andWhere('blockchain_code = :blockchainCode')
-            .setParameter('blockchainCode', blockchainCode)
-            .setParameter('account', account)
+            .where('pnl.account = :account', { account: account })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .take(1)
             .getOne();
     }

package/dist/repository/leverage-balance.repository.d.ts

@@ -12,6 +12,6 @@ export declare class LeverageBalanceRepository {
     private leverageBalanceThreeMonthsRepository;
     private leverageBalanceOneYearRepository;
     constructor(leverageBalanceOneDayRepository: Repository<LeverageBalanceOneDay>, leverageBalanceOneWeekRepository: Repository<LeverageBalanceOneWeek>, leverageBalanceOneMonthRepository: Repository<LeverageBalanceOneMonth>, leverageBalanceThreeMonthsRepository: Repository<LeverageBalanceThreeMonths>, leverageBalanceOneYearRepository: Repository<LeverageBalanceOneYear>);
-    findAllByPeriod(account: string, blockchainCode: string, period: string): Promise<UnitBalanceParent[]>;
+    findAllByPeriod(account: string, marketId: string, period: string): Promise<UnitBalanceParent[]>;
     getRepository(period: string): Repository<any>;
 }

package/dist/repository/leverage-balance.repository.js

@@ -30,11 +30,11 @@ let LeverageBalanceRepository = class LeverageBalanceRepository {
         this.leverageBalanceThreeMonthsRepository = leverageBalanceThreeMonthsRepository;
         this.leverageBalanceOneYearRepository = leverageBalanceOneYearRepository;
     }
-    async findAllByPeriod(account, blockchainCode, period) {
+    async findAllByPeriod(account, marketId, period) {
         return this.getRepository(period)
             .createQueryBuilder()
             .where('account = :account', { account: account })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .orderBy('timestamp', 'ASC')
             .getMany();
     }

package/dist/repository/leverage-leaderboard.repository.d.ts

@@ -3,9 +3,9 @@ import { LeverageLeaderboard } from '../entity';
 export declare class LeverageLeaderboardRepository {
     private repository;
     constructor(repository: Repository<LeverageLeaderboard>);
-    findByLastTimestamp(blockchainCode: string, period: string): Promise<LeverageLeaderboard | null>;
-    findByAccount(account: string, blockchainCode: string, period: string): Promise<LeverageLeaderboard | null>;
-    findAllOrderedByPnl(blockchainCode: string, period: string): Promise<LeverageLeaderboard[]>;
+    findByLastTimestamp(marketId: string, period: string): Promise<LeverageLeaderboard | null>;
+    findByAccount(account: string, marketId: string, period: string): Promise<LeverageLeaderboard | null>;
+    findAllOrderedByPnl(marketId: string, period: string): Promise<LeverageLeaderboard[]>;
     saveAll(leverageLeaderboard: LeverageLeaderboard[]): Promise<void>;
-    deleteByCodeAndPeriod(blockchainCode: string, period: string): Promise<void>;
+    deleteByCodeAndPeriod(marketId: string, period: string): Promise<void>;
 }

package/dist/repository/leverage-leaderboard.repository.js

@@ -21,28 +21,28 @@ let LeverageLeaderboardRepository = class LeverageLeaderboardRepository {
     constructor(repository) {
         this.repository = repository;
     }
-    async findByLastTimestamp(blockchainCode, period) {
+    async findByLastTimestamp(marketId, period) {
         return await this.repository
             .createQueryBuilder('leverageLeaderboard')
-            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .where('market_id = :marketId', { marketId: marketId })
             .andWhere('period = :period', { period: period })
             .orderBy('leverageLeaderboard.last_closed_position_timestamp', 'DESC')
             .take(1)
             .getOne();
     }
-    async findByAccount(account, blockchainCode, period) {
+    async findByAccount(account, marketId, period) {
         return await this.repository
             .createQueryBuilder('leverageLeaderboard')
             .where('leverageLeaderboard.account = :account', { account: account })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .andWhere('period = :period', { period: period })
             .take(1)
             .getOne();
     }
-    async findAllOrderedByPnl(blockchainCode, period) {
+    async findAllOrderedByPnl(marketId, period) {
         return this.repository
             .createQueryBuilder('leverageLeaderboard')
-            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .where('market_id = :marketId', { marketId: marketId })
             .andWhere('period = :period', { period: period })
             .orderBy('leverageLeaderboard.total_pnl_reth', 'DESC')
             .getMany();
@@ -50,10 +50,10 @@ let LeverageLeaderboardRepository = class LeverageLeaderboardRepository {
     async saveAll(leverageLeaderboard) {
         await this.repository.save(leverageLeaderboard);
     }
-    async deleteByCodeAndPeriod(blockchainCode, period) {
+    async deleteByCodeAndPeriod(marketId, period) {
         await this.repository
             .createQueryBuilder()
-            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .where('market_id = :marketId', { marketId: marketId })
             .andWhere('period = :period', { period: period })
             .delete();
     }

package/dist/repository/leverage-monthly-pnl.repository.d.ts

@@ -3,8 +3,8 @@ import { Repository } from 'typeorm';
 export declare class LeverageMonthlyPnlRepository {
     private repository;
     constructor(repository: Repository<LeverageMonthlyPnl>);
-    findAllByAccount(account: string, blockchainCode: string): Promise<LeverageMonthlyPnl[]>;
-    findByLastTimestamp(blockchainCode: string): Promise<LeverageMonthlyPnl | null>;
-    findByAccountAndTimestamp(account: string, timestamp: number, blockchainCode: string): Promise<LeverageMonthlyPnl | null>;
+    findAllByAccount(account: string, marketId: string): Promise<LeverageMonthlyPnl[]>;
+    findByLastTimestamp(marketId: string): Promise<LeverageMonthlyPnl | null>;
+    findByAccountAndTimestamp(account: string, timestamp: number, marketId: string): Promise<LeverageMonthlyPnl | null>;
     saveAll(leverageLeaderboard: LeverageMonthlyPnl[]): Promise<void>;
 }

package/dist/repository/leverage-monthly-pnl.repository.js

@@ -21,28 +21,28 @@ let LeverageMonthlyPnlRepository = class LeverageMonthlyPnlRepository {
     constructor(repository) {
         this.repository = repository;
     }
-    async findAllByAccount(account, blockchainCode) {
+    async findAllByAccount(account, marketId) {
         return await this.repository
             .createQueryBuilder()
             .where('account = :account', { account: account })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .orderBy('timestamp', 'ASC')
             .getMany();
     }
-    async findByLastTimestamp(blockchainCode) {
+    async findByLastTimestamp(marketId) {
         return await this.repository
             .createQueryBuilder()
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .where('market_id = :marketId', { marketId: marketId })
             .orderBy('last_closed_position_timestamp', 'DESC')
             .take(1)
             .getOne();
     }
-    async findByAccountAndTimestamp(account, timestamp, blockchainCode) {
+    async findByAccountAndTimestamp(account, timestamp, marketId) {
         return await this.repository
             .createQueryBuilder()
             .where('account = :account', { account: account })
             .andWhere('timestamp = :timestamp', { timestamp: timestamp })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .take(1)
             .getOne();
     }

package/dist/repository/limit-order.repository.d.ts

@@ -5,6 +5,6 @@ export declare class LimitOrderRepository {
     constructor(repository: Repository<LimitOrderEntity>);
     save(limitOrder: LimitOrderEntity): Promise<LimitOrderEntity>;
     saveAll(limitOrder: LimitOrderEntity[]): Promise<LimitOrderEntity[]>;
-    getAllByStatusOpen(blockchainCode: string): Promise<LimitOrderEntity[]>;
-    getByTokenId(tokenId: number, blockchainCode: string): Promise<LimitOrderEntity | null>;
+    getAllByStatusOpen(marketId: string): Promise<LimitOrderEntity[]>;
+    getByTokenId(tokenId: number, marketId: string): Promise<LimitOrderEntity | null>;
 }

package/dist/repository/limit-order.repository.js

@@ -28,19 +28,19 @@ let LimitOrderRepository = class LimitOrderRepository {
     async saveAll(limitOrder) {
         return this.repository.save(limitOrder);
     }
-    async getAllByStatusOpen(blockchainCode) {
+    async getAllByStatusOpen(marketId) {
         return this.repository
             .createQueryBuilder()
             .where('status = :status', { status: constants_1.LimitOrderStatus.OPEN })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .orderBy('liquidation_price', 'DESC')
             .getMany();
     }
-    async getByTokenId(tokenId, blockchainCode) {
+    async getByTokenId(tokenId, marketId) {
         return await this.repository
             .createQueryBuilder()
             .where('token_id = :tokenId', { tokenId: tokenId })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .where('status = :status', { status: constants_1.LimitOrderStatus.OPEN })
             .take(1)
             .getOne();

package/dist/repository/multichain-config.repository.d.ts

@@ -4,5 +4,5 @@ export declare class MultichainConfigRepository {
     private repository;
     constructor(repository: Repository<MultichainConfig>);
     getById(id: number): Promise<MultichainConfig | null>;
-    getByAppAndCode(appName: string, blockchainCode: string): Promise<MultichainConfig | null>;
+    getByAppAndCode(appName: string, marketId: string): Promise<MultichainConfig | null>;
 }

package/dist/repository/multichain-config.repository.js

@@ -24,13 +24,11 @@ let MultichainConfigRepository = class MultichainConfigRepository {
     async getById(id) {
         return this.repository.createQueryBuilder().where('id = :id').setParameter('id', id).take(1).getOne();
     }
-    async getByAppAndCode(appName, blockchainCode) {
+    async getByAppAndCode(appName, marketId) {
         return this.repository
             .createQueryBuilder()
-            .where('app_name = :appName')
-            .andWhere('blockchain_code = :blockchainCode')
-            .setParameter('appName', appName)
-            .setParameter('blockchainCode', blockchainCode)
+            .where('app_name = :appName', { appName: appName })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .take(1)
             .getOne();
     }

package/dist/repository/order-execution.repository.d.ts

@@ -5,5 +5,5 @@ export declare class OrderExecutionRepository {
     constructor(repository: Repository<OrderExecution>);
     save(orderExecution: OrderExecution): Promise<OrderExecution>;
     saveAll(orderExecutions: OrderExecution[]): Promise<OrderExecution[]>;
-    getLatestRecord(blockchainCode: string): Promise<OrderExecution | null>;
+    getLatestRecord(marketId: string): Promise<OrderExecution | null>;
 }

package/dist/repository/order-execution.repository.js

@@ -27,11 +27,10 @@ let OrderExecutionRepository = class OrderExecutionRepository {
     async saveAll(orderExecutions) {
         return this.repository.save(orderExecutions);
     }
-    async getLatestRecord(blockchainCode) {
+    async getLatestRecord(marketId) {
         return this.repository
             .createQueryBuilder()
-            .where('blockchain_code = :blockchainCode')
-            .setParameter('blockchainCode', blockchainCode)
+            .where('market_id = :marketId', { marketId: marketId })
             .orderBy('executed_at', 'DESC')
             .limit(1)
             .getOne();

package/dist/repository/position.repository.d.ts

@@ -6,8 +6,8 @@ export declare class PositionRepository {
     constructor(repository: Repository<PositionEntity>);
     save(position: PositionEntity): Promise<PositionEntity>;
     saveAll(positions: PositionEntity[]): Promise<PositionEntity[]>;
-    getAllByStatusOpen(blockchainCode: string): Promise<PositionEntity[]>;
-    updateLiquidationPrice(tokenId: number, blockchainCode: string, liqPrice: BigNumber): Promise<void>;
-    getOneByTokenId(tokenId: number, blockchainCode: string): Promise<PositionEntity | null>;
-    getLatestUpdateAtBlock(blockchainCode: string): Promise<number>;
+    getAllByStatusOpen(marketId: string): Promise<PositionEntity[]>;
+    updateLiquidationPrice(tokenId: number, marketId: string, liqPrice: BigNumber): Promise<void>;
+    getOneByTokenId(tokenId: number, marketId: string): Promise<PositionEntity | null>;
+    getLatestUpdateAtBlock(marketId: string): Promise<number>;
 }

package/dist/repository/position.repository.js

@@ -28,36 +28,36 @@ let PositionRepository = class PositionRepository {
     async saveAll(positions) {
         return this.repository.save(positions);
     }
-    async getAllByStatusOpen(blockchainCode) {
+    async getAllByStatusOpen(marketId) {
         return this.repository
             .createQueryBuilder()
             .where('status = :status', { status: constants_1.LeveragePositionStatus.OPEN })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .orderBy('liquidation_price', 'DESC')
             .getMany();
     }
-    async updateLiquidationPrice(tokenId, blockchainCode, liqPrice) {
+    async updateLiquidationPrice(tokenId, marketId, liqPrice) {
         await this.repository
             .createQueryBuilder()
             .update(entity_1.PositionEntity)
             .set({ liquidationPrice: liqPrice })
             .where('token_id = :tokenId', { tokenId: tokenId })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .execute();
     }
-    async getOneByTokenId(tokenId, blockchainCode) {
+    async getOneByTokenId(tokenId, marketId) {
         return await this.repository
             .createQueryBuilder()
             .where('token_id = :tokenId', { tokenId: tokenId })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .take(1)
             .getOne();
     }
-    async getLatestUpdateAtBlock(blockchainCode) {
+    async getLatestUpdateAtBlock(marketId) {
         const p = await this.repository
             .createQueryBuilder('position')
             .select(['position.block_updated_at'])
-            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .where('market_id = :marketId', { marketId: marketId })
             .orderBy('block_updated_at', 'DESC')
             .getRawOne();
         return p ? parseInt(p.block_updated_at) : 0;

package/dist/repository/price.repository.d.ts

@@ -7,10 +7,10 @@ export declare class PriceRepository {
     private flatcoinPriceOneYearRepository;
     private readonly repository;
     constructor(flatcoinPriceOneDayRepository: Repository<FlatcoinPriceOneDay>, flatcoinPriceOneWeekRepository: Repository<FlatcoinPriceOneWeek>, flatcoinPriceOneMonthRepository: Repository<FlatcoinPriceOneMonth>, flatcoinPriceOneYearRepository: Repository<FlatcoinPriceOneYear>, repository: Repository<FlatcoinPrice>);
-    findAllByPeriod(period: string, blockchainCode: string): Promise<FlatcoinPriceParent[]>;
-    findLast(blockchainCode: string): Promise<FlatcoinPrice | null>;
-    findFirstByTimestamp(fromTimestamp: number, blockchainCode: string): Promise<FlatcoinPrice | null>;
-    findFirstByBlock(fromBlock: number, blockchainCode: string): Promise<FlatcoinPrice | null>;
-    findFirst(blockchainCode: string): Promise<FlatcoinPrice | null>;
+    findAllByPeriod(period: string, marketId: string): Promise<FlatcoinPriceParent[]>;
+    findLast(marketId: string): Promise<FlatcoinPrice | null>;
+    findFirstByTimestamp(fromTimestamp: number, marketId: string): Promise<FlatcoinPrice | null>;
+    findFirstByBlock(fromBlock: number, marketId: string): Promise<FlatcoinPrice | null>;
+    findFirst(marketId: string): Promise<FlatcoinPrice | null>;
     private getRepository;
 }

package/dist/repository/price.repository.js

@@ -26,50 +26,45 @@ let PriceRepository = class PriceRepository {
         this.flatcoinPriceOneYearRepository = flatcoinPriceOneYearRepository;
         this.repository = repository;
     }
-    async findAllByPeriod(period, blockchainCode) {
+    async findAllByPeriod(period, marketId) {
         return this.getRepository(period)
             .createQueryBuilder('price')
-            .where('blockchain_code = :blockchainCode')
-            .setParameter('blockchainCode', blockchainCode)
+            .where('market_id = :marketId', { marketId: marketId })
             .orderBy('price.timestamp', 'ASC')
             .getMany();
     }
-    async findLast(blockchainCode) {
+    async findLast(marketId) {
         return this.repository
             .createQueryBuilder()
-            .where('blockchain_code = :blockchainCode')
-            .setParameter('blockchainCode', blockchainCode)
+            .where('market_id = :marketId', { marketId: marketId })
             .orderBy('timestamp', 'DESC')
             .take(1)
             .getOne();
     }
-    async findFirstByTimestamp(fromTimestamp, blockchainCode) {
+    async findFirstByTimestamp(fromTimestamp, marketId) {
         return await this.repository
             .createQueryBuilder('price')
             .where('timestamp > :fromTimestamp')
-            .andWhere('blockchain_code = :blockchainCode')
-            .setParameter('blockchainCode', blockchainCode)
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .orderBy('price.timestamp', 'ASC')
             .setParameter('fromTimestamp', fromTimestamp)
             .take(1)
             .getOne();
     }
-    async findFirstByBlock(fromBlock, blockchainCode) {
+    async findFirstByBlock(fromBlock, marketId) {
         return await this.repository
             .createQueryBuilder()
             .where('block_number > :fromBlock')
-            .andWhere('blockchain_code = :blockchainCode')
-            .setParameter('blockchainCode', blockchainCode)
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .setParameter('fromBlock', fromBlock)
             .orderBy('timestamp', 'ASC')
             .take(1)
             .getOne();
     }
-    async findFirst(blockchainCode) {
+    async findFirst(marketId) {
         return await this.repository
             .createQueryBuilder('price')
-            .where('blockchain_code = :blockchainCode')
-            .setParameter('blockchainCode', blockchainCode)
+            .where('market_id = :marketId', { marketId: marketId })
             .orderBy('price.timestamp', 'ASC')
             .take(1)
             .getOne();

package/dist/repository/protocol-metrics.repository.d.ts

@@ -4,5 +4,5 @@ export declare class ProtocolMetricsRepository {
     private repository;
     constructor(repository: Repository<ProtocolMetrics>);
     save(protocolMetrics: ProtocolMetrics): Promise<ProtocolMetrics>;
-    getLatestRecord(blockchainCode: string): Promise<ProtocolMetrics | null>;
+    getLatestRecord(marketId: string): Promise<ProtocolMetrics | null>;
 }

package/dist/repository/protocol-metrics.repository.js

@@ -24,10 +24,10 @@ let ProtocolMetricsRepository = class ProtocolMetricsRepository {
     async save(protocolMetrics) {
         return this.repository.save(protocolMetrics);
     }
-    async getLatestRecord(blockchainCode) {
+    async getLatestRecord(marketId) {
         return this.repository
             .createQueryBuilder()
-            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .where('market_id = :marketId', { marketId: marketId })
             .limit(1)
             .getOne();
     }

package/dist/repository/unit-balance.repository.d.ts

@@ -12,6 +12,6 @@ export declare class UnitBalanceRepository {
     private unitBalanceHalfYearRepository;
     private unitBalanceOneYearRepository;
     constructor(unitBalanceOneWeekRepository: Repository<UnitBalanceOneWeek>, unitBalanceOneMonthRepository: Repository<UnitBalanceOneMonth>, unitBalanceThreeMonthsRepository: Repository<UnitBalanceThreeMonths>, unitBalanceHalfYearRepository: Repository<UnitBalanceHalfYear>, unitBalanceOneYearRepository: Repository<UnitBalanceOneYear>);
-    findAllByPeriod(account: string, period: string, blockchainCode: string): Promise<UnitBalanceParent[]>;
+    findAllByPeriod(account: string, period: string, marketId: string): Promise<UnitBalanceParent[]>;
     getRepository(period: string): Repository<any>;
 }

package/dist/repository/unit-balance.repository.js

@@ -30,11 +30,11 @@ let UnitBalanceRepository = class UnitBalanceRepository {
         this.unitBalanceHalfYearRepository = unitBalanceHalfYearRepository;
         this.unitBalanceOneYearRepository = unitBalanceOneYearRepository;
     }
-    async findAllByPeriod(account, period, blockchainCode) {
+    async findAllByPeriod(account, period, marketId) {
         return this.getRepository(period)
             .createQueryBuilder()
             .where('account = :account', { account: account })
-            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .andWhere('market_id = :marketId', { marketId: marketId })
             .orderBy('timestamp', 'ASC')
             .getMany();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/backend-flatcoin-core",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "description": "Backend Flatcoin Core",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",