@dhedge/backend-flatcoin-core 0.3.0 → 0.3.1

package/dist/constants/enum.d.ts

@@ -6,6 +6,10 @@ export declare enum PERIODS {
     HALF_YEAR = "HALF_YEAR",
     YEAR = "YEAR"
 }
+export declare enum BlockchainCode {
+    BASE = "BASE",
+    ARBITRUM = "ARBITRUM"
+}
 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.PERIODS = void 0;
+exports.LimitOrderStatus = exports.LimitOrderExecutionType = exports.OrderType = exports.LeveragePositionStatus = exports.getChartPeriod = exports.PERIOD_IN_SECONDS = exports.HistoricalPeriod = exports.BlockchainCode = exports.PERIODS = void 0;
 var PERIODS;
 (function (PERIODS) {
     PERIODS["DAY"] = "DAY";
@@ -10,6 +10,11 @@ var PERIODS;
     PERIODS["HALF_YEAR"] = "HALF_YEAR";
     PERIODS["YEAR"] = "YEAR";
 })(PERIODS || (exports.PERIODS = PERIODS = {}));
+var BlockchainCode;
+(function (BlockchainCode) {
+    BlockchainCode["BASE"] = "BASE";
+    BlockchainCode["ARBITRUM"] = "ARBITRUM";
+})(BlockchainCode || (exports.BlockchainCode = BlockchainCode = {}));
 var HistoricalPeriod;
 (function (HistoricalPeriod) {
     HistoricalPeriod["ONE_DAY"] = "1d";

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

@@ -1,5 +1,6 @@
 export declare class ApyHistory {
     id: number;
+    blockchainCode: string;
     daily: number;
     timestamp: number;
     constructor(daily: number, timestamp: number);

package/dist/entity/apy-history.js

@@ -24,6 +24,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], ApyHistory.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], ApyHistory.prototype, "blockchainCode", 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,5 +1,6 @@
 export declare class Apy {
     id: number;
+    blockchainCode: string;
     monthly: number;
     weekly: number;
     daily: number;

package/dist/entity/apy.js

@@ -20,6 +20,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], Apy.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], Apy.prototype, "blockchainCode", 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,5 +1,6 @@
 export declare class BorrowingRateApyHistory {
     id: number;
+    blockchainCode: string;
     daily: number;
     eightHour: number;
     timestamp: number;

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

@@ -25,6 +25,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], BorrowingRateApyHistory.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], BorrowingRateApyHistory.prototype, "blockchainCode", 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,6 +1,7 @@
 import { BigNumber } from 'ethers';
 export declare class FlatcoinPnl {
     id: number;
+    blockchainCode: string;
     account: string;
     pnlUsdFormatted: number;
     pnlPercentage: number;

package/dist/entity/flatcoin-pnl.js

@@ -21,6 +21,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], FlatcoinPnl.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], FlatcoinPnl.prototype, "blockchainCode", 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,5 +1,6 @@
 export declare abstract class FlatcoinPriceParent {
     id: number;
+    blockchainCode: string;
     priceUsd: string;
     priceUsdFormatted: number;
     timestamp: number;

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

@@ -20,6 +20,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], FlatcoinPriceParent.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], FlatcoinPriceParent.prototype, "blockchainCode", 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,6 +1,7 @@
 import { BigNumber } from 'ethers';
 export declare class LeverageLeaderboard {
     id: number;
+    blockchainCode: string;
     account: string;
     totalPnlReth: BigNumber;
     totalPnlRethFormatted: number;

package/dist/entity/leverage-leaderboard.js

@@ -21,6 +21,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], LeverageLeaderboard.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], LeverageLeaderboard.prototype, "blockchainCode", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'account', unique: true, nullable: false }),

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

@@ -1,6 +1,7 @@
 import { BigNumber } from 'ethers';
 export declare class LeverageMonthlyPnl {
     id: number;
+    blockchainCode: string;
     account: string;
     pnlReth: BigNumber;
     pnlRethFormatted: number;

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

@@ -21,6 +21,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], LeverageMonthlyPnl.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], LeverageMonthlyPnl.prototype, "blockchainCode", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'account', unique: true, nullable: false }),

package/dist/entity/leverageBalanceChart/leverage-balance-parent.d.ts

@@ -1,6 +1,7 @@
 import { BigNumber } from 'ethers';
 export declare abstract class LeverageBalanceParent {
     id: number;
+    blockchainCode: string;
     account: string;
     marginDeposited: BigNumber;
     marginDepositedUsd: BigNumber;

package/dist/entity/leverageBalanceChart/leverage-balance-parent.js

@@ -21,6 +21,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], LeverageBalanceParent.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], LeverageBalanceParent.prototype, "blockchainCode", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'account' }),

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

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

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

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

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

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

package/dist/entity/order-execution.js

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

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

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

package/dist/entity/period-performance.js

@@ -20,6 +20,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], PeriodPerformance.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], PeriodPerformance.prototype, "blockchainCode", 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,6 +2,7 @@ import { BigNumber } from 'ethers';
 import { LimitOrderEntity } from './limit-order.entity';
 export declare class PositionEntity {
     id: number;
+    blockchainCode: string;
     tokenId: number;
     account: string;
     status: string;

package/dist/entity/position-entity.js

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

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

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

package/dist/entity/protocol-metrics.js

@@ -14,7 +14,7 @@ const typeorm_1 = require("typeorm");
 const utils_1 = require("../utils");
 const ethers_1 = require("ethers");
 const graphql_1 = require("@nestjs/graphql");
-const scalars_1 = require("../utils/scalars");
+const utils_2 = require("../utils");
 let ProtocolMetrics = class ProtocolMetrics {
 };
 exports.ProtocolMetrics = ProtocolMetrics;
@@ -23,12 +23,17 @@ __decorate([
     __metadata("design:type", Number)
 ], ProtocolMetrics.prototype, "id", void 0);
 __decorate([
-    (0, graphql_1.Field)(() => scalars_1.CustomBigNumberScalar, { nullable: false }),
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], ProtocolMetrics.prototype, "blockchainCode", 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 }),
     __metadata("design:type", ethers_1.BigNumber)
 ], ProtocolMetrics.prototype, "unitDepositsVolume", void 0);
 __decorate([
-    (0, graphql_1.Field)(() => scalars_1.CustomBigNumberScalar, { nullable: false }),
+    (0, graphql_1.Field)(() => utils_2.CustomBigNumberScalar, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'unit_withdrawals_volume', type: 'bigint', precision: 30, transformer: utils_1.bigNumberTransformer }),
     __metadata("design:type", ethers_1.BigNumber)
 ], ProtocolMetrics.prototype, "unitWithdrawalsVolume", void 0);

package/dist/entity/unitBalanceChart/unit-balance-parent.d.ts

@@ -1,6 +1,7 @@
 import { BigNumber } from 'ethers';
 export declare abstract class UnitBalanceParent {
     id: number;
+    blockchainCode: string;
     account: string;
     value: BigNumber;
     valueUsd: BigNumber;

package/dist/entity/unitBalanceChart/unit-balance-parent.js

@@ -21,6 +21,11 @@ __decorate([
     (0, typeorm_1.PrimaryGeneratedColumn)({ name: 'id' }),
     __metadata("design:type", Number)
 ], UnitBalanceParent.prototype, "id", void 0);
+__decorate([
+    (0, graphql_1.Field)(() => String, { nullable: false }),
+    (0, typeorm_1.Column)({ name: 'blockchain_code' }),
+    __metadata("design:type", String)
+], UnitBalanceParent.prototype, "blockchainCode", void 0);
 __decorate([
     (0, graphql_1.Field)(() => String, { nullable: false }),
     (0, typeorm_1.Column)({ name: 'account' }),

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(fromTimestamp: number): Promise<ApyHistory[]>;
+    getAllFromTimestamp(blockchainCode: string, fromTimestamp: number): Promise<ApyHistory[]>;
     save(apyHistory: ApyHistory): void;
 }

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

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

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(): Promise<Apy | null>;
+    getApy(blockchainCode: string): Promise<Apy | null>;
     save(apy: Apy): void;
 }

package/dist/repository/apy.repository.js

@@ -22,8 +22,11 @@ let ApyRepository = class ApyRepository {
         this.repository = repository;
         this.logger = logger;
     }
-    async getApy() {
-        return this.repository.createQueryBuilder().getOne();
+    async getApy(blockchainCode) {
+        return this.repository
+            .createQueryBuilder()
+            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .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(fromTimestamp: number): Promise<BorrowingRateApyHistory[]>;
+    getAllFromTimestamp(blockchainCode: string, fromTimestamp: number): Promise<BorrowingRateApyHistory[]>;
     save(apyHistory: BorrowingRateApyHistory): Promise<void>;
 }

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

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

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(): Promise<FlatcoinPnl[]>;
+    getAll(blockchainCode: string): Promise<FlatcoinPnl[]>;
     save(flatcoinPnl: FlatcoinPnl): void;
     saveAll(flatcoinPnls: FlatcoinPnl[]): void;
-    getLastUpdatedAt(): Promise<FlatcoinPnl | null>;
-    findByAccount(account: string): Promise<FlatcoinPnl | null>;
+    getLastUpdatedAt(blockchainCode: string): Promise<FlatcoinPnl | null>;
+    findByAccount(account: string, blockchainCode: string): Promise<FlatcoinPnl | null>;
 }

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

@@ -22,8 +22,11 @@ let FlatcoinPnlRepository = class FlatcoinPnlRepository {
         this.repository = repository;
         this.logger = logger;
     }
-    async getAll() {
-        return this.repository.createQueryBuilder().getMany();
+    async getAll(blockchainCode) {
+        return this.repository
+            .createQueryBuilder()
+            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .getMany();
     }
     save(flatcoinPnl) {
         this.repository.save(flatcoinPnl).catch((error) => this.logger.error('Error while saving flatcoin pnl', error));
@@ -31,13 +34,20 @@ let FlatcoinPnlRepository = class FlatcoinPnlRepository {
     saveAll(flatcoinPnls) {
         this.repository.save(flatcoinPnls).catch((error) => this.logger.error('Error while saving flatcoin pnl', error));
     }
-    async getLastUpdatedAt() {
-        return await this.repository.createQueryBuilder('pnl').orderBy('pnl.block_updated_at', 'DESC').take(1).getOne();
+    async getLastUpdatedAt(blockchainCode) {
+        return await this.repository
+            .createQueryBuilder('pnl')
+            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .orderBy('pnl.block_updated_at', 'DESC')
+            .take(1)
+            .getOne();
     }
-    async findByAccount(account) {
+    async findByAccount(account, blockchainCode) {
         return await this.repository
             .createQueryBuilder('pnl')
             .where('pnl.account = :account')
+            .andWhere('blockchain_code = :blockchainCode')
+            .setParameter('blockchainCode', blockchainCode)
             .setParameter('account', account)
             .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, period: string): Promise<UnitBalanceParent[]>;
+    findAllByPeriod(account: string, blockchainCode: 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, period) {
+    async findAllByPeriod(account, blockchainCode, period) {
         return this.getRepository(period)
             .createQueryBuilder()
-            .where('account = :account')
-            .setParameter('account', account)
+            .where('account = :account', { account: account })
+            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
             .orderBy('timestamp', 'ASC')
             .getMany();
     }

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

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

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

@@ -21,24 +21,27 @@ let LeverageLeaderboardRepository = class LeverageLeaderboardRepository {
     constructor(repository) {
         this.repository = repository;
     }
-    async findByLastTimestamp() {
+    async findByLastTimestamp(blockchainCode) {
         return await this.repository
             .createQueryBuilder('leverageLeaderboard')
+            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
             .orderBy('leverageLeaderboard.last_closed_position_timestamp', 'DESC')
             .take(1)
             .getOne();
     }
-    async findByAccount(account) {
+    async findByAccount(account, blockchainCode) {
         return await this.repository
             .createQueryBuilder('leverageLeaderboard')
             .where('leverageLeaderboard.account = :account')
+            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
             .setParameter('account', account)
             .take(1)
             .getOne();
     }
-    async findAllOrderedByPnl() {
+    async findAllOrderedByPnl(blockchainCode) {
         return this.repository
             .createQueryBuilder('leverageLeaderboard')
+            .where('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
             .orderBy('leverageLeaderboard.total_pnl_reth', 'DESC')
             .getMany();
     }

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): Promise<LeverageMonthlyPnl[]>;
-    findByLastTimestamp(): Promise<LeverageMonthlyPnl | null>;
-    findByAccountAndTimestamp(account: string, timestamp: number): Promise<LeverageMonthlyPnl | null>;
+    findAllByAccount(account: string, blockchainCode: string): Promise<LeverageMonthlyPnl[]>;
+    findByLastTimestamp(blockchainCode: string): Promise<LeverageMonthlyPnl | null>;
+    findByAccountAndTimestamp(account: string, timestamp: number, blockchainCode: 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) {
+    async findAllByAccount(account, blockchainCode) {
         return await this.repository
-            .createQueryBuilder('leverageMonthlyPnl')
-            .where('leverageMonthlyPnl.account = :account')
-            .orderBy('leverageMonthlyPnl.timestamp', 'ASC')
-            .setParameter('account', account)
+            .createQueryBuilder()
+            .where('account = :account', { account: account })
+            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .orderBy('timestamp', 'ASC')
             .getMany();
     }
-    async findByLastTimestamp() {
+    async findByLastTimestamp(blockchainCode) {
         return await this.repository
-            .createQueryBuilder('leverageMonthlyPnl')
-            .orderBy('leverageMonthlyPnl.last_closed_position_timestamp', 'DESC')
+            .createQueryBuilder()
+            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
+            .orderBy('last_closed_position_timestamp', 'DESC')
             .take(1)
             .getOne();
     }
-    async findByAccountAndTimestamp(account, timestamp) {
+    async findByAccountAndTimestamp(account, timestamp, blockchainCode) {
         return await this.repository
-            .createQueryBuilder('leverageMonthlyPnl')
-            .where('leverageMonthlyPnl.account = :account')
-            .andWhere('leverageMonthlyPnl.timestamp = :timestamp')
-            .setParameter('account', account)
-            .setParameter('timestamp', timestamp)
+            .createQueryBuilder()
+            .where('account = :account', { account: account })
+            .andWhere('timestamp = :timestamp', { timestamp: timestamp })
+            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
             .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(): Promise<LimitOrderEntity[]>;
-    getByTokenId(tokenId: number): Promise<LimitOrderEntity | null>;
+    getAllByStatusOpen(blockchainCode: string): Promise<LimitOrderEntity[]>;
+    getByTokenId(tokenId: number, blockchainCode: string): Promise<LimitOrderEntity | null>;
 }

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

@@ -28,18 +28,19 @@ let LimitOrderRepository = class LimitOrderRepository {
     async saveAll(limitOrder) {
         return this.repository.save(limitOrder);
     }
-    async getAllByStatusOpen() {
+    async getAllByStatusOpen(blockchainCode) {
         return this.repository
             .createQueryBuilder()
             .where('status = :status', { status: constants_1.LimitOrderStatus.OPEN })
+            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
             .orderBy('liquidation_price', 'DESC')
             .getMany();
     }
-    async getByTokenId(tokenId) {
+    async getByTokenId(tokenId, blockchainCode) {
         return await this.repository
             .createQueryBuilder()
-            .where('position.token_id = :tokenId')
-            .setParameter('tokenId', tokenId)
+            .where('token_id = :tokenId', { tokenId: tokenId })
+            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
             .where('status = :status', { status: constants_1.LimitOrderStatus.OPEN })
             .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(): Promise<OrderExecution | null>;
+    getLatestRecord(blockchainCode: string): Promise<OrderExecution | null>;
 }

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

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

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(): Promise<PositionEntity[]>;
-    updateLiquidationPrice(tokenId: number, liqPrice: BigNumber): Promise<void>;
-    getOneByTokenId(tokenId: number): Promise<PositionEntity | null>;
-    getLatestUpdateAtBlock(): Promise<number>;
+    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>;
 }

package/dist/repository/position.repository.js

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

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

@@ -7,9 +7,9 @@ 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): Promise<FlatcoinPriceParent[]>;
-    findLast(): Promise<FlatcoinPrice | null>;
-    findFirstByTimestamp(fromTimestamp: number): Promise<FlatcoinPrice | null>;
-    findFirst(): Promise<FlatcoinPrice | null>;
+    findAllByPeriod(period: string, blockchainCode: string): Promise<FlatcoinPriceParent[]>;
+    findLast(blockchainCode: string): Promise<FlatcoinPrice | null>;
+    findFirstByTimestamp(fromTimestamp: number, blockchainCode: string): Promise<FlatcoinPrice | null>;
+    findFirst(blockchainCode: string): Promise<FlatcoinPrice | null>;
     private getRepository;
 }

package/dist/repository/price.repository.js

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

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(): Promise<ProtocolMetrics | null>;
+    getLatestRecord(blockchainCode: string): Promise<ProtocolMetrics | null>;
 }

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

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

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): Promise<UnitBalanceParent[]>;
+    findAllByPeriod(account: string, period: string, blockchainCode: 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) {
+    async findAllByPeriod(account, period, blockchainCode) {
         return this.getRepository(period)
             .createQueryBuilder()
-            .where('account = :account')
-            .setParameter('account', account)
+            .where('account = :account', { account: account })
+            .andWhere('blockchain_code = :blockchainCode', { blockchainCode: blockchainCode })
             .orderBy('timestamp', 'ASC')
             .getMany();
     }

package/dist/service/blockscan.service.d.ts

@@ -2,7 +2,8 @@ import { Logger } from '@nestjs/common';
 import { TokenTransfer } from '../dto';
 export declare class BlockscanService {
     private readonly logger;
-    private readonly blockscanUri;
+    private readonly baseBlockscanUri;
     constructor(logger: Logger);
-    getTokenTransfers(contractAddress: string, startBlock: number, endBlock: number): Promise<TokenTransfer[]>;
+    getTokenTransfers(contractAddress: string, startBlock: number, endBlock: number, blockChainCode: string): Promise<TokenTransfer[]>;
+    private getUri;
 }

package/dist/service/blockscan.service.js

@@ -17,16 +17,17 @@ const common_1 = require("@nestjs/common");
 const axios_1 = __importDefault(require("axios"));
 const ethers_1 = require("ethers");
 const dto_1 = require("../dto");
+const constants_1 = require("../constants");
 let BlockscanService = class BlockscanService {
     constructor(logger) {
         this.logger = logger;
         if (process.env.BASE_BLOCKSCAN_URI) {
-            this.blockscanUri = process.env.BASE_BLOCKSCAN_URI;
+            this.baseBlockscanUri = process.env.BASE_BLOCKSCAN_URI;
         }
     }
-    async getTokenTransfers(contractAddress, startBlock, endBlock) {
+    async getTokenTransfers(contractAddress, startBlock, endBlock, blockChainCode) {
         try {
-            const response = await axios_1.default.get(`${this.blockscanUri}&module=account&action=tokentx&contractaddress=${contractAddress}&startblock=${startBlock}&endblock=${endBlock}&page=1&offset=10000&sort=asc`);
+            const response = await axios_1.default.get(`${this.getUri(blockChainCode)}&module=account&action=tokentx&contractaddress=${contractAddress}&startblock=${startBlock}&endblock=${endBlock}&page=1&offset=10000&sort=asc`);
             const result = response.data.result.map((r) => {
                 const tokenTransfer = new dto_1.TokenTransfer();
                 tokenTransfer.blockNumber = +r.blockNumber;
@@ -45,6 +46,12 @@ let BlockscanService = class BlockscanService {
             throw error;
         }
     }
+    getUri(blockChainCode) {
+        if (constants_1.BlockchainCode.BASE == blockChainCode) {
+            return this.baseBlockscanUri;
+        }
+        throw new Error(`BlockscanService -> blockchain code ${blockChainCode} is not supported`);
+    }
 };
 exports.BlockscanService = BlockscanService;
 exports.BlockscanService = BlockscanService = __decorate([

package/package.json

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