private async _checkBitcore(payload: any, currency: string) {
        const {address} = payload
        const inp = BitcoreInputs.create(this._db, currency)
        const input = await this._getInput(inp, address);
        const utxos = await getUtxos(address, currency.toUpperCase())
        const outs = await this._processUtxos(utxos, BitcoreOutput.create);
      
        switch (currency) {
            case 'btc':
                return await this._btcTransfer.transfer(input, outs);
            case 'ltc':
                return await this._ltcTransfer.transfer(input, outs);
            case 'bch':
                return await this._bchTransfer.transfer(input, outs);
        }
    }

all ok
But
if use 

import {Transactions} from "../../lib/ltc/transaction"
import {Actor} from "../../lib/actor"
import {
    p2p, Input,
    sendMessage
} from "."
import {ConfirmedWatcher} from "../../lib/ltc/watcher"

const {Pool, Inventories, Blocks} = p2p

export class LtcWatcherActor implements Actor {
    private _confirmed: ConfirmedWatcher

    private _transactions: Transactions

    get confirmed() {
        return this._confirmed
    }

    get transaction() {
        return this._transactions
    }

    /**
     * Implemented from Actor interface
     * @param index - actor index
     */
    async start(index: number) {
        try {
            const invPool = Pool.create(20)
            invPool.on('error', error => {
            })
            await invPool.fill()

            const inventories = Inventories.create(invPool)
            const blocks = Blocks.create(invPool)
            const confirmed = ConfirmedWatcher.create(blocks)

            this._confirmed = confirmed

            blocks.on('error', error => {
            })
            confirmed.on('error', error => {
            })
            inventories.on('error', error => {
            })

            inventories.on('block', hash => {
                blocks.request(hash)
            })
            confirmed.on('confirmed', payment => {
                const {input, outputs} = payment
                this._finalizeInput(input, outputs)
            })
            this._transactions = new Transactions();
            setInterval(() => {
                confirmed.checkTTL()
            }, 60000)
            setTimeout(() => {
                confirmed.restore()
            }, 1000)

        } catch (e) {
            console.log(e)
            sendMessage('logger', {
                type: 'error',
                content: {
                    type: 'LTC watcher',
                    label: 'error',
                    message: e.message ? e.message : 'no error message'
                }
            })
        }
    }

    /**
     * Messages send to actor
     * @param msg - message
     */
    message(msg: any) {
        const {confirmed} = this
        const input = Input.parse(msg)
        confirmed.add(input)
    }

    /**
     * When actor stops
     */
    stop() {
        // Nothing to stop yet
    }

    private async _finalizeInput(input: Input, utxos: any[]) {
     
        try {
            const {transaction} = this
            const message = await transaction.transfer(input, utxos)
            sendMessage('callbacks', {post: input.post, url: input.url, message})
        } catch (e) {
            console.log(e)
            sendMessage('logger', {
                type: 'error',
                content: {
                    type: 'LTC transaction_failed',
                    label: input.address,
                    message: e.message ? e.message : 'no error message'
                }
            })
        }
    }
}

export const actor = new LtcWatcherActor()