chore: leave comments for things that need reviews

packages/core-api/src/formats.ts

@@ -2,6 +2,7 @@ import { Managers, Utils } from "@arkecosystem/crypto";
 import { Ajv } from "ajv";
 import * as ipAddress from "ip";
 
+// todo: review the implementation - still needed at all or some unused?
 export const registerFormats = (ajv: Ajv) => {
     ajv.addFormat("address", {
         type: "string",

packages/core-api/src/handlers/blockchain/controller.ts

@@ -4,6 +4,7 @@ import Hapi from "@hapi/hapi";
 
 import { Controller } from "../shared/controller";
 
+// todo: remove the abstract and use dependency injection if needed
 export class BlockchainController extends Controller {
     public async index(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {

packages/core-api/src/handlers/blocks/controller.ts

@@ -4,6 +4,7 @@ import Hapi from "@hapi/hapi";
 
 import { Controller } from "../shared/controller";
 
+// todo: remove the abstract and use dependency injection if needed
 export class BlocksController extends Controller {
     public async index(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {

packages/core-api/src/handlers/blocks/transformer.ts

@@ -1,6 +1,7 @@
 import { app, Container, Contracts, Utils as AppUtils } from "@arkecosystem/core-kernel";
 import { Interfaces, Utils } from "@arkecosystem/crypto";
 
+// todo: review the implementation
 export const transformBlock = (model, transform) => {
     if (!transform) {
         model.reward = Utils.BigNumber.make(model.reward).toFixed();

packages/core-api/src/handlers/delegates/controller.ts

@@ -3,6 +3,7 @@ import Hapi from "@hapi/hapi";
 
 import { Controller } from "../shared/controller";
 
+// todo: remove the abstract and use dependency injection if needed
 export class DelegatesController extends Controller {
     public async index(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {

packages/core-api/src/handlers/delegates/transformer.ts

@@ -2,6 +2,7 @@ import { Contracts, Utils as AppUtils } from "@arkecosystem/core-kernel";
 import { Utils } from "@arkecosystem/crypto";
 
 // todo: turn into class so that ioc can be used
+// todo: review the implementation
 export const transformDelegate = (delegate: Contracts.State.Wallet) => {
     const attributes: Contracts.State.WalletDelegateAttributes = delegate.getAttribute("delegate");
 

packages/core-api/src/handlers/node/controller.ts

@@ -5,6 +5,7 @@ import Hapi from "@hapi/hapi";
 
 import { Controller } from "../shared/controller";
 
+// todo: remove the abstract and use dependency injection if needed
 export class NodeController extends Controller {
     public async status(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {

packages/core-api/src/handlers/peers/controller.ts

@@ -5,6 +5,7 @@ import semver from "semver";
 
 import { Controller } from "../shared/controller";
 
+// todo: remove the abstract and use dependency injection if needed
 export class PeersController extends Controller {
     public async index(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         // todo: inject from container

packages/core-api/src/handlers/peers/transformer.ts

@@ -1,5 +1,6 @@
 import { app } from "@arkecosystem/core-kernel";
 
+// todo: review the implementation
 export const transformPeer = model => {
     return {
         ip: model.ip,

packages/core-api/src/handlers/rounds/controller.ts

@@ -3,6 +3,7 @@ import Hapi from "@hapi/hapi";
 
 import { Controller } from "../shared/controller";
 
+// todo: remove the abstract and use dependency injection if needed
 export class RoundsController extends Controller {
     public async delegates(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {

packages/core-api/src/handlers/rounds/transformer.ts

@@ -1,5 +1,6 @@
 import { Utils } from "@arkecosystem/crypto";
 
+// todo: review the implementation
 export const transformRoundDelegate = model => {
     return {
         publicKey: model.publicKey,

packages/core-api/src/handlers/shared/controller.ts

@@ -12,6 +12,7 @@ import {
     toResource,
 } from "../utils";
 
+// todo: remove this class and expose helpers as functions
 export class Controller {
     // todo: remove
     protected readonly config = Managers.configManager;

packages/core-api/src/handlers/shared/schemas/pagination.ts

@@ -11,6 +11,6 @@ export const pagination = {
     limit: Joi.number()
         .integer()
         .min(1),
-    // @fixme: the container is not available at the time this file is loaded
+    // todo: the container is not available at the time this file is loaded
     // .max(app.get<any>("api.options").get("plugins.pagination.limit")),
 };

packages/core-api/src/handlers/transactions/controller.ts

@@ -5,6 +5,7 @@ import Hapi from "@hapi/hapi";
 
 import { Controller } from "../shared/controller";
 
+// todo: remove the abstract and use dependency injection if needed
 export class TransactionsController extends Controller {
     // todo: inject from container
     private readonly transactionPool = app.get<Contracts.TransactionPool.Connection>(

packages/core-api/src/handlers/transactions/transformer.ts

@@ -1,6 +1,7 @@
 import { app, Container, Contracts, Utils } from "@arkecosystem/core-kernel";
 import { Interfaces, Transactions } from "@arkecosystem/crypto";
 
+// todo: review the implementation
 export const transformTransaction = (model, transform) => {
     const blockchain = app.get<Contracts.Blockchain.Blockchain>(Container.Identifiers.BlockchainService);
     const databaseService = app.get<Contracts.Database.DatabaseService>(Container.Identifiers.DatabaseService);

packages/core-api/src/handlers/utils.ts

@@ -4,6 +4,8 @@ import Hapi from "@hapi/hapi";
 
 import { transformerService } from "../services/transformer";
 
+// todo: review the implementation of all methods
+
 export const paginate = (request: Hapi.Request): any => {
     const pagination = {
         // @ts-ignore

packages/core-api/src/handlers/votes/controller.ts

@@ -3,6 +3,7 @@ import Hapi from "@hapi/hapi";
 
 import { Controller } from "../shared/controller";
 
+// todo: remove the abstract and use dependency injection if needed
 export class VotesController extends Controller {
     public async index(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {

packages/core-api/src/handlers/wallets/controller.ts

@@ -3,6 +3,7 @@ import Hapi from "@hapi/hapi";
 
 import { Controller } from "../shared/controller";
 
+// todo: remove the abstract and use dependency injection if needed
 export class WalletsController extends Controller {
     public async index(request: Hapi.Request, h: Hapi.ResponseToolkit) {
         try {

packages/core-api/src/handlers/wallets/transformer.ts

@@ -1,6 +1,7 @@
 import { Contracts } from "@arkecosystem/core-kernel";
 import { Utils } from "@arkecosystem/crypto";
 
+// todo: review the implementation
 export const transformWallet = (wallet: Contracts.State.Wallet) => {
     const username: string = wallet.getAttribute("delegate.username");
 

packages/core-api/src/plugins/hapi-ajv.ts

@@ -4,6 +4,7 @@ import Hapi from "@hapi/hapi";
 
 const name = "hapi-ajv";
 
+// todo: review implementation - still needed?
 export const hapiAjv = {
     name,
     version: "1.0.0",

packages/core-api/src/plugins/set-headers.ts

@@ -1,5 +1,6 @@
 import Hapi from "@hapi/hapi";
 
+// todo: review the implementation - still needed?
 export = {
     name: "set-headers",
     version: "1.0.0",

packages/core-api/src/server.ts

@@ -3,6 +3,7 @@ import { badData } from "@hapi/boom";
 import { Server as HapiServer, ServerInjectOptions, ServerInjectResponse, ServerRoute } from "@hapi/hapi";
 import { readFileSync } from "fs";
 
+// todo: review the implementation
 @Container.injectable()
 export class Server {
     /**

packages/core-api/src/services/cache.ts

@@ -2,6 +2,7 @@ import { app } from "@arkecosystem/core-kernel";
 import { Crypto } from "@arkecosystem/crypto";
 import Hapi, { ServerMethod } from "@hapi/hapi";
 
+// todo: review the implementation
 export class ServerCache {
     public static make(server: Hapi.Server): ServerCache {
         return new ServerCache(server);

packages/core-blockchain/src/blockchain.ts

@@ -8,22 +8,31 @@ import { stateMachine } from "./state-machine";
 
 const { BlockFactory } = Blocks;
 
+// todo: reduce the overall complexity of this class and remove all helpers and getters that just serve as proxies
 @Container.injectable()
 export class Blockchain implements Contracts.Blockchain.Blockchain {
+    // todo: make this private
     public isStopped: boolean;
+    // todo: make this private
     public options: any;
+    // todo: make this private and use a queue instance from core-kernel
     public queue: async.AsyncQueue<any>;
+    // todo: make this private
     protected blockProcessor: BlockProcessor;
+    // todo: add type
     private actions: any;
 
+    // todo: make this private, only protected because of replay
     @Container.inject(Container.Identifiers.StateStore)
-    protected readonly state: Contracts.State.StateStore; // todo: make this private? only protected because of replay
+    protected readonly state: Contracts.State.StateStore;
 
+    // todo: make this private, only protected because of replay
     @Container.inject(Container.Identifiers.DatabaseService)
-    protected readonly database: Contracts.Database.DatabaseService; // todo: make this private? only protected because of replay
+    protected readonly database: Contracts.Database.DatabaseService;
 
+    // todo: make this private, only protected because of replay
     @Container.inject(Container.Identifiers.TransactionPoolService)
-    protected readonly transactionPool: Contracts.TransactionPool.Connection; // todo: make this private? only protected because of replay
+    protected readonly transactionPool: Contracts.TransactionPool.Connection;
 
     /**
      * Create a new blockchain manager instance.
@@ -38,8 +47,6 @@ export class Blockchain implements Contracts.Blockchain.Blockchain {
             app.log.warning(
                 "ARK Core is launched in Genesis Start mode. This is usually for starting the first node on the blockchain. Unless you know what you are doing, this is likely wrong.",
             );
-
-            app.log.info("Starting ARK Core for a new world, welcome aboard");
         }
 
         this.actions = stateMachine.actionMap(this);
@@ -52,7 +59,9 @@ export class Blockchain implements Contracts.Blockchain.Blockchain {
                 app.log.error(
                     `Failed to process ${blockList.blocks.length} blocks from height ${blockList.blocks[0].height} in queue.`,
                 );
+
                 app.log.error(error.stack);
+
                 return cb();
             }
         }, 1);

packages/core-blockchain/src/machines/blockchain.ts

@@ -3,6 +3,7 @@ import { Machine } from "xstate";
 import { fork } from "./actions/fork";
 import { syncWithNetwork } from "./actions/sync-with-network";
 
+// todo: move this into a class based state machine that triggers actions on this
 export const blockchainMachine: any = Machine({
     key: "blockchain",
     initial: "uninitialised",

packages/core-blockchain/src/processor/handlers/accept-block-handler.ts

@@ -4,6 +4,7 @@ import { Interfaces } from "@arkecosystem/crypto";
 import { BlockProcessorResult } from "../block-processor";
 import { BlockHandler } from "./block-handler";
 
+// todo: remove the abstract and instead require a contract to be implemented
 @Container.injectable()
 export class AcceptBlockHandler extends BlockHandler {
     @Container.inject(Container.Identifiers.LogService)
@@ -56,6 +57,7 @@ export class AcceptBlockHandler extends BlockHandler {
             this.logger.warning(`Refused new block ${JSON.stringify(block.data)}`);
             this.logger.debug(error.stack);
 
+            // todo: replace this with an actual implementation after the abstract is gone
             return super.execute(block);
         }
     }

packages/core-blockchain/src/processor/handlers/already-forged-handler.ts

@@ -4,9 +4,11 @@ import { Interfaces } from "@arkecosystem/crypto";
 import { BlockProcessorResult } from "../block-processor";
 import { BlockHandler } from "./block-handler";
 
+// todo: remove the abstract and instead require a contract to be implemented
 @Container.injectable()
 export class AlreadyForgedHandler extends BlockHandler {
     public async execute(block: Interfaces.IBlock): Promise<BlockProcessorResult> {
+        // todo: replace this with an actual implementation after the abstract is gone
         await super.execute(block);
 
         return BlockProcessorResult.DiscardedButCanBeBroadcasted;

packages/core-blockchain/src/processor/handlers/block-handler.ts

@@ -3,6 +3,7 @@ import { Interfaces } from "@arkecosystem/crypto";
 
 import { BlockProcessorResult } from "../block-processor";
 
+// todo: remove this abstract and require a contract to be implemented by children instead
 @Container.injectable()
 export abstract class BlockHandler {
     @Container.inject(Container.Identifiers.BlockchainService)

packages/core-blockchain/src/processor/handlers/exception-handler.ts

@@ -5,6 +5,7 @@ import { BlockProcessorResult } from "../block-processor";
 import { AcceptBlockHandler } from "./accept-block-handler";
 import { BlockHandler } from "./block-handler";
 
+// todo: remove the abstract and instead require a contract to be implemented
 @Container.injectable()
 export class ExceptionHandler extends BlockHandler {
     @Container.inject(Container.Identifiers.LogService)
@@ -18,6 +19,7 @@ export class ExceptionHandler extends BlockHandler {
         const forgedBlock: Interfaces.IBlock = await this.database.getBlock(block.data.id);
 
         if (forgedBlock) {
+            // todo: replace this with an actual implementation after the abstract is gone
             return super.execute(block);
         }
 

packages/core-blockchain/src/processor/handlers/invalid-generator-handler.ts

@@ -2,5 +2,6 @@ import { Container } from "@arkecosystem/core-kernel";
 
 import { BlockHandler } from "./block-handler";
 
+// todo: remove the abstract and instead require a contract to be implemented
 @Container.injectable()
 export class InvalidGeneratorHandler extends BlockHandler {}

packages/core-blockchain/src/processor/handlers/unchained-handler.ts

@@ -46,6 +46,7 @@ class BlockNotReadyCounter {
     }
 }
 
+// todo: remove the abstract and instead require a contract to be implemented
 export class UnchainedHandler extends BlockHandler {
     public static notReadyCounter = new BlockNotReadyCounter();
 
@@ -57,6 +58,7 @@ export class UnchainedHandler extends BlockHandler {
 
     private isValidGenerator: boolean;
 
+    // todo: remove the need for this method
     public init(isValidGenerator: boolean): this {
         this.isValidGenerator = isValidGenerator;
 
@@ -104,6 +106,7 @@ export class UnchainedHandler extends BlockHandler {
     private checkUnchainedBlock(block: Interfaces.IBlock): UnchainedBlockStatus {
         const lastBlock: Interfaces.IBlock = this.blockchain.getLastBlock();
 
+        // todo: clean up this if-else-if-else-if-else mess
         if (block.data.height > lastBlock.data.height + 1) {
             this.logger.debug(
                 `Blockchain not ready to accept new block at height ${block.data.height.toLocaleString()}. Last block: ${lastBlock.data.height.toLocaleString()}`,

packages/core-blockchain/src/processor/handlers/verification-failed-handler.ts

@@ -2,5 +2,6 @@ import { Container } from "@arkecosystem/core-kernel";
 
 import { BlockHandler } from "./block-handler";
 
+// todo: remove the abstract and instead require a contract to be implemented
 @Container.injectable()
 export class VerificationFailedHandler extends BlockHandler {}

packages/core-blockchain/src/replay/memory-database-service.ts

@@ -2,6 +2,7 @@ import { DatabaseService } from "@arkecosystem/core-database";
 import { Contracts } from "@arkecosystem/core-kernel";
 import { Interfaces } from "@arkecosystem/crypto";
 
+// todo: review the implementation
 export class MemoryDatabaseService extends DatabaseService {
     public constructor(public walletRepository: Contracts.State.WalletRepository) {
         super(undefined, undefined, undefined, undefined, undefined, undefined, undefined);

packages/core-blockchain/src/replay/replay-blockchain.ts

@@ -6,6 +6,7 @@ import { Blockchain } from "../blockchain";
 import { FailedToReplayBlocksError } from "./errors";
 import { MemoryDatabaseService } from "./memory-database-service";
 
+// todo: review the implementation
 export class ReplayBlockchain extends Blockchain {
     private logger: Contracts.Kernel.Log.Logger;
     private localDatabase: Contracts.Database.DatabaseService;

packages/core-blockchain/src/utils/validate-generator.ts

@@ -1,6 +1,7 @@
 import { app, Container, Contracts, Utils } from "@arkecosystem/core-kernel";
 import { Crypto, Interfaces } from "@arkecosystem/crypto";
 
+// todo: review the implementation
 export const validateGenerator = async (block: Interfaces.IBlock): Promise<boolean> => {
     const database: Contracts.Database.DatabaseService = app.get<Contracts.Database.DatabaseService>(
         Container.Identifiers.DatabaseService,

packages/core-database-postgres/src/service-provider.ts

@@ -4,6 +4,7 @@ import { Wallets } from "@arkecosystem/core-state";
 
 import { PostgresConnection } from "./postgres-connection";
 
+// todo: review the implementation
 export class ServiceProvider extends Providers.ServiceProvider {
     public async register(): Promise<void> {
         this.app.log.info("Establishing Database Connection");

packages/core-database-postgres/src/state-builder.ts

@@ -2,6 +2,7 @@ import { app, Container, Contracts, Enums } from "@arkecosystem/core-kernel";
 import { Handlers } from "@arkecosystem/core-transactions";
 import { Interfaces, Managers, Utils } from "@arkecosystem/crypto";
 
+// todo: review the implementation
 export class StateBuilder {
     private readonly logger: Contracts.Kernel.Log.Logger = app.log;
     private readonly emitter: Contracts.Kernel.Events.EventDispatcher = app.get<

packages/core-database/src/block-state.ts

@@ -3,11 +3,12 @@ import { Wallets } from "@arkecosystem/core-state";
 import { Handlers, Interfaces as TransactionInterfaces } from "@arkecosystem/core-transactions";
 import { Enums, Identities, Interfaces, Utils } from "@arkecosystem/crypto";
 
-// @todo: ioc
+// todo: review the implementation and make use of ioc
 @Container.injectable()
 export class BlockState {
     private walletRepository: Contracts.State.WalletRepository;
 
+    // todo: remove the need for this method
     public init(walletRepository: Contracts.State.WalletRepository): this {
         this.walletRepository = walletRepository;
 

packages/core-database/src/repositories/utils/filter-rows.ts

@@ -9,6 +9,7 @@ import { getProperty } from "./get-property";
  * @param  {Object} filters
  * @return {Array}
  */
+// todo: review implementation - quite a mess at the moment
 export = (rows: ReadonlyArray<Contracts.State.Wallet>, params, filters): Contracts.State.Wallet[] => {
     return rows.filter(item => {
         if (filters.hasOwnProperty("exact")) {