fix: update core-interfaces imports to core-kernel

ArkEcosystem · Aug 22, 2019 · c70bf0b · c70bf0b
1 parent d0c299e
commit c70bf0b
Show file tree

Hide file tree

Showing 217 changed files with 1,286 additions and 2,121 deletions.
diff --git a/packages/core-api/package.json b/packages/core-api/package.json
@@ -21,7 +21,7 @@
         "pretest": "bash ../../scripts/pre-test.sh"
     },
     "dependencies": {
-        "@arkecosystem/core-container": "^3.0.0-next.0",
+        "@arkecosystem/core-kernel": "^3.0.0-next.0",
         "@arkecosystem/core-http-utils": "^3.0.0-next.0",
         "@arkecosystem/core-transaction-pool": "^3.0.0-next.0",
         "@arkecosystem/core-utils": "^3.0.0-next.0",

diff --git a/packages/core-api/src/formats.ts b/packages/core-api/src/formats.ts
@@ -1,4 +1,4 @@
-import { app } from "@arkecosystem/core-container";
+import { app } from "@arkecosystem/core-kernel";
 import { Utils } from "@arkecosystem/crypto";
 import { Ajv } from "ajv";
 import * as ipAddress from "ip";

diff --git a/packages/core-api/src/handlers/blocks/controller.ts b/packages/core-api/src/handlers/blocks/controller.ts
@@ -1,5 +1,4 @@
-import { app } from "@arkecosystem/core-container";
-import { Blockchain, State } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import Boom from "@hapi/boom";
 import Hapi from "@hapi/hapi";
 import { Controller } from "../shared/controller";
@@ -20,7 +19,7 @@ export class BlocksController extends Controller {
         try {
             return super.respondWithResource(
                 app
-                    .resolvePlugin<State.IStateService>("state")
+                    .resolve<Contracts.State.IStateService>("state")
                     .getStore()
                     .getGenesisBlock().data,
                 "block",
@@ -34,7 +33,7 @@ export class BlocksController extends Controller {
     public async last(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {
             return super.respondWithResource(
-                app.resolvePlugin<Blockchain.IBlockchain>("blockchain").getLastBlock().data,
+                app.resolve<Contracts.Blockchain.IBlockchain>("blockchain").getLastBlock().data,
                 "block",
                 (request.query.transform as unknown) as boolean,
             );

diff --git a/packages/core-api/src/handlers/blocks/methods.ts b/packages/core-api/src/handlers/blocks/methods.ts
@@ -1,10 +1,9 @@
-import { app } from "@arkecosystem/core-container";
-import { Database } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import Boom from "@hapi/boom";
 import { ServerCache } from "../../services";
 import { paginate, respondWithResource, toPagination } from "../utils";
 
-const databaseService = app.resolvePlugin<Database.IDatabaseService>("database");
+const databaseService = app.resolve<Contracts.Database.IDatabaseService>("database");
 const blocksRepository = databaseService.blocksBusinessRepository;
 const transactionsRepository = databaseService.transactionsBusinessRepository;
 

diff --git a/packages/core-api/src/handlers/blocks/transformer.ts b/packages/core-api/src/handlers/blocks/transformer.ts
@@ -1,5 +1,4 @@
-import { app } from "@arkecosystem/core-container";
-import { Blockchain, Database, State } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import { formatTimestamp } from "@arkecosystem/core-utils";
 import { Interfaces, Utils } from "@arkecosystem/crypto";
 
@@ -11,9 +10,11 @@ export const transformBlock = (model, transform) => {
         return model;
     }
 
-    const databaseService: Database.IDatabaseService = app.resolvePlugin<Database.IDatabaseService>("database");
-    const generator: State.IWallet = databaseService.walletManager.findByPublicKey(model.generatorPublicKey);
-    const lastBlock: Interfaces.IBlock = app.resolvePlugin<Blockchain.IBlockchain>("blockchain").getLastBlock();
+    const databaseService: Contracts.Database.IDatabaseService = app.resolve<Contracts.Database.IDatabaseService>(
+        "database",
+    );
+    const generator: Contracts.State.IWallet = databaseService.walletManager.findByPublicKey(model.generatorPublicKey);
+    const lastBlock: Interfaces.IBlock = app.resolve<Contracts.Blockchain.IBlockchain>("blockchain").getLastBlock();
 
     model.reward = Utils.BigNumber.make(model.reward);
     model.totalFee = Utils.BigNumber.make(model.totalFee);

diff --git a/packages/core-api/src/handlers/delegates/methods.ts b/packages/core-api/src/handlers/delegates/methods.ts
@@ -1,10 +1,9 @@
-import { app } from "@arkecosystem/core-container";
-import { Database } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import Boom from "@hapi/boom";
 import { ServerCache } from "../../services";
 import { paginate, respondWithResource, toPagination } from "../utils";
 
-const databaseService = app.resolvePlugin<Database.IDatabaseService>("database");
+const databaseService = app.resolve<Contracts.Database.IDatabaseService>("database");
 const blocksRepository = databaseService.blocksBusinessRepository;
 
 const index = async request => {

diff --git a/packages/core-api/src/handlers/delegates/schema.ts b/packages/core-api/src/handlers/delegates/schema.ts
@@ -1,4 +1,4 @@
-import { app } from "@arkecosystem/core-container";
+import { app } from "@arkecosystem/core-kernel";
 import Joi from "@hapi/joi";
 import { blockId } from "../shared/schemas/block-id";
 import { pagination } from "../shared/schemas/pagination";

diff --git a/packages/core-api/src/handlers/delegates/transformer.ts b/packages/core-api/src/handlers/delegates/transformer.ts
@@ -1,9 +1,9 @@
-import { State } from "@arkecosystem/core-interfaces";
+import { Contracts } from "@arkecosystem/core-kernel";
 import { delegateCalculator, formatTimestamp } from "@arkecosystem/core-utils";
 import { Utils } from "@arkecosystem/crypto";
 
-export const transformDelegate = (delegate: State.IWallet) => {
-    const attributes: State.IWalletDelegateAttributes = delegate.getAttribute("delegate");
+export const transformDelegate = (delegate: Contracts.State.IWallet) => {
+    const attributes: Contracts.State.IWalletDelegateAttributes = delegate.getAttribute("delegate");
 
     const data = {
         username: attributes.username,

diff --git a/packages/core-api/src/handlers/node/controller.ts b/packages/core-api/src/handlers/node/controller.ts
@@ -1,5 +1,4 @@
-import { app } from "@arkecosystem/core-container";
-import { Database } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import { Crypto, Managers } from "@arkecosystem/crypto";
 import Boom from "@hapi/boom";
 import Hapi from "@hapi/hapi";
@@ -82,7 +81,7 @@ export class NodeController extends Controller {
     }
 
     public async fees(request: Hapi.Request) {
-        const { transactionsBusinessRepository } = app.resolvePlugin<Database.IDatabaseService>("database");
+        const { transactionsBusinessRepository } = app.resolve<Contracts.Database.IDatabaseService>("database");
 
         // @ts-ignore
         const results = await transactionsBusinessRepository.getFeeStatistics(request.query.days);

diff --git a/packages/core-api/src/handlers/peers/controller.ts b/packages/core-api/src/handlers/peers/controller.ts
@@ -1,12 +1,12 @@
-import { P2P } from "@arkecosystem/core-interfaces";
+import { Contracts } from "@arkecosystem/core-kernel";
 import Boom from "@hapi/boom";
 import Hapi from "@hapi/hapi";
 import semver from "semver";
 import { Controller } from "../shared/controller";
 
 export class PeersController extends Controller {
     public async index(request: Hapi.Request, h: Hapi.ResponseToolkit) {
-        const allPeers: P2P.IPeer[] = this.blockchain.p2p.getStorage().getPeers();
+        const allPeers: Contracts.P2P.IPeer[] = this.blockchain.p2p.getStorage().getPeers();
 
         let result = allPeers.sort((a, b) => a.latency - b.latency);
         result = request.query.version
@@ -34,8 +34,8 @@ export class PeersController extends Controller {
 
     public async show(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {
-            const peers: P2P.IPeer[] = this.blockchain.p2p.getStorage().getPeers();
-            const peer: P2P.IPeer = peers.find(p => p.ip === request.params.ip);
+            const peers: Contracts.P2P.IPeer[] = this.blockchain.p2p.getStorage().getPeers();
+            const peer: Contracts.P2P.IPeer = peers.find(p => p.ip === request.params.ip);
 
             if (!peer) {
                 return Boom.notFound("Peer not found");

diff --git a/packages/core-api/src/handlers/peers/transformer.ts b/packages/core-api/src/handlers/peers/transformer.ts
@@ -1,4 +1,4 @@
-import { app } from "@arkecosystem/core-container";
+import { app } from "@arkecosystem/core-kernel";
 
 export const transformPeer = model => {
     return {

diff --git a/packages/core-api/src/handlers/rounds/methods.ts b/packages/core-api/src/handlers/rounds/methods.ts
@@ -1,11 +1,10 @@
-import { app } from "@arkecosystem/core-container";
-import { Database } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import Boom from "@hapi/boom";
 import { ServerCache } from "../../services";
 import { respondWithCollection } from "../utils";
 
 const delegates = async request => {
-    const databaseService = app.resolvePlugin<Database.IDatabaseService>("database");
+    const databaseService = app.resolve<Contracts.Database.IDatabaseService>("database");
     const roundsRepository = databaseService.connection.roundsRepository;
 
     const delegates = await roundsRepository.findById(request.params.id);

diff --git a/packages/core-api/src/handlers/shared/controller.ts b/packages/core-api/src/handlers/shared/controller.ts
@@ -1,5 +1,4 @@
-import { app } from "@arkecosystem/core-container";
-import { Blockchain, Database } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import Hapi from "@hapi/hapi";
 import {
     paginate,
@@ -13,8 +12,8 @@ import {
 
 export class Controller {
     protected readonly config = app.getConfig();
-    protected readonly blockchain = app.resolvePlugin<Blockchain.IBlockchain>("blockchain");
-    protected readonly databaseService = app.resolvePlugin<Database.IDatabaseService>("database");
+    protected readonly blockchain = app.resolve<Contracts.Blockchain.IBlockchain>("blockchain");
+    protected readonly databaseService = app.resolve<Contracts.Database.IDatabaseService>("database");
 
     protected paginate(request: Hapi.Request): any {
         // @ts-ignore

diff --git a/packages/core-api/src/handlers/shared/schemas/pagination.ts b/packages/core-api/src/handlers/shared/schemas/pagination.ts
@@ -1,4 +1,4 @@
-import { app } from "@arkecosystem/core-container";
+import { app } from "@arkecosystem/core-kernel";
 import Joi from "@hapi/joi";
 
 export const pagination = {

diff --git a/packages/core-api/src/handlers/transactions/controller.ts b/packages/core-api/src/handlers/transactions/controller.ts
@@ -1,12 +1,11 @@
-import { app } from "@arkecosystem/core-container";
-import { P2P, TransactionPool } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import { Enums, Interfaces } from "@arkecosystem/crypto";
 import Boom from "@hapi/boom";
 import Hapi from "@hapi/hapi";
 import { Controller } from "../shared/controller";
 
 export class TransactionsController extends Controller {
-    private readonly transactionPool = app.resolvePlugin<TransactionPool.IConnection>("transaction-pool");
+    private readonly transactionPool = app.resolve<Contracts.TransactionPool.IConnection>("transaction-pool");
 
     public async index(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {
@@ -21,11 +20,11 @@ export class TransactionsController extends Controller {
 
     public async store(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {
-            const processor: TransactionPool.IProcessor = this.transactionPool.makeProcessor();
+            const processor: Contracts.TransactionPool.IProcessor = this.transactionPool.makeProcessor();
             const result = await processor.validate((request.payload as any).transactions);
 
             if (result.broadcast.length > 0) {
-                app.resolvePlugin<P2P.IPeerService>("p2p")
+                app.resolve<Contracts.P2P.IPeerService>("p2p")
                     .getMonitor()
                     .broadcastTransactions(processor.getBroadcastTransactions());
             }

diff --git a/packages/core-api/src/handlers/transactions/methods.ts b/packages/core-api/src/handlers/transactions/methods.ts
@@ -1,10 +1,9 @@
-import { app } from "@arkecosystem/core-container";
-import { Database } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import Boom from "@hapi/boom";
 import { ServerCache } from "../../services";
 import { paginate, respondWithResource, toPagination } from "../utils";
 
-const transactionsRepository = app.resolvePlugin<Database.IDatabaseService>("database").transactionsBusinessRepository;
+const transactionsRepository = app.resolve<Contracts.Database.IDatabaseService>("database").transactionsBusinessRepository;
 
 const index = async request => {
     const transactions = await transactionsRepository.search({

diff --git a/packages/core-api/src/handlers/transactions/schema.ts b/packages/core-api/src/handlers/transactions/schema.ts
@@ -1,4 +1,4 @@
-import { app } from "@arkecosystem/core-container";
+import { app } from "@arkecosystem/core-kernel";
 import Joi from "@hapi/joi";
 import { blockId } from "../shared/schemas/block-id";
 import { pagination } from "../shared/schemas/pagination";

diff --git a/packages/core-api/src/handlers/transactions/transformer.ts b/packages/core-api/src/handlers/transactions/transformer.ts
@@ -1,11 +1,10 @@
-import { app } from "@arkecosystem/core-container";
-import { Blockchain, Database } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import { formatTimestamp } from "@arkecosystem/core-utils";
 import { Interfaces, Transactions } from "@arkecosystem/crypto";
 
 export const transformTransaction = (model, transform) => {
-    const blockchain = app.resolvePlugin<Blockchain.IBlockchain>("blockchain");
-    const databaseService = app.resolvePlugin<Database.IDatabaseService>("database");
+    const blockchain = app.resolve<Contracts.Blockchain.IBlockchain>("blockchain");
+    const databaseService = app.resolve<Contracts.Database.IDatabaseService>("database");
 
     const transaction: Interfaces.ITransaction = Transactions.TransactionFactory.fromBytesUnsafe(
         model.serialized,

diff --git a/packages/core-api/src/handlers/utils.ts b/packages/core-api/src/handlers/utils.ts
@@ -1,4 +1,4 @@
-import { app } from "@arkecosystem/core-container";
+import { app } from "@arkecosystem/core-kernel";
 import Boom from "@hapi/boom";
 import Hapi from "@hapi/hapi";
 import { transformerService } from "../services/transformer";

diff --git a/packages/core-api/src/handlers/votes/methods.ts b/packages/core-api/src/handlers/votes/methods.ts
@@ -1,13 +1,12 @@
-import { app } from "@arkecosystem/core-container";
-import { Database } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import { Enums } from "@arkecosystem/crypto";
 import Boom from "@hapi/boom";
 import { ServerCache } from "../../services";
 import { paginate, respondWithResource, toPagination } from "../utils";
 
 const { TransactionType } = Enums;
 
-const databaseService = app.resolvePlugin<Database.IDatabaseService>("database");
+const databaseService = app.resolve<Contracts.Database.IDatabaseService>("database");
 const transactionsRepository = databaseService.transactionsBusinessRepository;
 
 const index = async request => {

diff --git a/packages/core-api/src/handlers/wallets/methods.ts b/packages/core-api/src/handlers/wallets/methods.ts
@@ -1,10 +1,9 @@
-import { app } from "@arkecosystem/core-container";
-import { Database } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import Boom from "@hapi/boom";
 import { ServerCache } from "../../services";
 import { paginate, respondWithResource, toPagination } from "../utils";
 
-const databaseService = app.resolvePlugin<Database.IDatabaseService>("database");
+const databaseService = app.resolve<Contracts.Database.IDatabaseService>("database");
 const transactionsRepository = databaseService.transactionsBusinessRepository;
 
 const index = async request => {

diff --git a/packages/core-api/src/handlers/wallets/transformer.ts b/packages/core-api/src/handlers/wallets/transformer.ts
@@ -1,7 +1,7 @@
-import { State } from "@arkecosystem/core-interfaces";
+import { Contracts } from "@arkecosystem/core-kernel";
 import { Utils } from "@arkecosystem/crypto";
 
-export const transformWallet = (wallet: State.IWallet) => {
+export const transformWallet = (wallet: Contracts.State.IWallet) => {
     const username: string = wallet.getAttribute("delegate.username");
 
     return {

diff --git a/packages/core-api/src/plugin.ts b/packages/core-api/src/plugin.ts
@@ -1,14 +1,14 @@
-import { Container, Logger } from "@arkecosystem/core-interfaces";
+import { Contracts } from "@arkecosystem/core-kernel";
 import { defaults } from "./defaults";
 import { Server } from "./server";
 
 export const plugin: Container.IPluginDescriptor = {
     pkg: require("../package.json"),
     defaults,
     alias: "api",
-    async register(container: Container.IContainer, options) {
+    async register(container: Contracts.Kernel.IContainer, options) {
         if (!options.enabled) {
-            container.resolvePlugin<Logger.ILogger>("logger").info("Public API is disabled");
+            container.resolve<Contracts.Kernel.ILogger>("logger").info("Public API is disabled");
 
             return false;
         }
@@ -18,11 +18,11 @@ export const plugin: Container.IPluginDescriptor = {
 
         return server;
     },
-    async deregister(container: Container.IContainer, options) {
+    async deregister(container: Contracts.Kernel.IContainer, options) {
         if (options.enabled) {
-            container.resolvePlugin<Logger.ILogger>("logger").info(`Stopping Public API`);
+            container.resolve<Contracts.Kernel.ILogger>("logger").info(`Stopping Public API`);
 
-            await container.resolvePlugin<Server>("api").stop();
+            await container.resolve<Server>("api").stop();
         }
     },
 };
diff --git a/packages/core-api/src/server.ts b/packages/core-api/src/server.ts
@@ -1,10 +1,9 @@
-import { app } from "@arkecosystem/core-container";
 import { createServer, mountServer, plugins } from "@arkecosystem/core-http-utils";
-import { Logger } from "@arkecosystem/core-interfaces";
+import { app, Contracts } from "@arkecosystem/core-kernel";
 import Hapi from "@hapi/hapi";
 
 export class Server {
-    private logger = app.resolvePlugin<Logger.ILogger>("logger");
+    private logger = app.resolve<Contracts.Kernel.ILogger>("logger");
 
     private http: any;
     private https: any;

diff --git a/packages/core-api/src/services/cache.ts b/packages/core-api/src/services/cache.ts
@@ -1,4 +1,4 @@
-import { app } from "@arkecosystem/core-container";
+import { app } from "@arkecosystem/core-kernel";
 import { Crypto } from "@arkecosystem/crypto";
 import Hapi, { ServerMethod } from "@hapi/hapi";
 

diff --git a/packages/core-blockchain/package.json b/packages/core-blockchain/package.json
@@ -22,9 +22,8 @@
         "pretest": "bash ../../scripts/pre-test.sh"
     },
     "dependencies": {
-        "@arkecosystem/core-container": "^3.0.0-next.0",
+        "@arkecosystem/core-kernel": "^3.0.0-next.0",
         "@arkecosystem/core-database": "^3.0.0-next.0",
-        "@arkecosystem/core-event-emitter": "^3.0.0-next.0",
         "@arkecosystem/core-state": "^3.0.0-next.0",
         "@arkecosystem/core-transactions": "^3.0.0-next.0",
         "@arkecosystem/core-utils": "^3.0.0-next.0",