How to use the bitcore.deps function in bitcore

var util = require('util')
var bitcore = require('bitcore')
var _ = bitcore.deps._
var $ = bitcore.util.preconditions
var BufferUtil = bitcore.util.buffer
var JSUtil = bitcore.util.js
var BlockHeader = bitcore.BlockHeader
var BufferReader = bitcore.encoding.BufferReader
var BufferWriter = bitcore.encoding.BufferWriter
var Script = bitcore.Script

var zeroHash = new Buffer('0000000000000000000000000000000000000000000000000000000000000000', 'hex')

var PrivateBlockHeader = module.exports = function (arg) {
  if (!(this instanceof PrivateBlockHeader)) {
    return new PrivateBlockHeader(arg)
  }
  _.extend(this, PrivateBlockHeader._from(arg))
  return this

'use strict';

var bitcore = require('bitcore');
var $ = bitcore.util.preconditions;
var _ = bitcore.deps._;
var BufferUtil = bitcore.util.buffer;

var NULL = '0000000000000000000000000000000000000000000000000000000000000000';

function BlockChain() {
  this.tip = NULL;
  this.work = {};
  this.work[NULL] = 0;
  this.height = {};
  this.height[NULL] = -1;
  this.hashByHeight = {
    '-1': NULL
  };
  this.next = {};
  this.prev = {};
}

'use strict';


var bitcore = require('bitcore');
var Promise = require('bluebird');
var $ = bitcore.util.preconditions;
var _ = bitcore.deps._;
var EventEmitter = require('eventemitter2').EventEmitter2;
var util = require('util');

function EventBus() {
  this.handlers = {};
}
util.inherits(EventBus, EventEmitter);

EventBus.prototype.process = function(e) {
  $.checkArgument(_.isObject(e));

  var self = this;
  var done = [];

  var processEvent = function(event) {
    done = done.concat(event);

BlockService.blockRPCtoBitcore = function(blockData) {
  $.checkArgument(blockData, 'blockData is required');
  var block = new bitcore.Block({
    header: new bitcore.BlockHeader({
      version: blockData.version,
      prevHash: blockData.previousblockhash ?
        bitcore.util.buffer.reverse(
          new bitcore.deps.Buffer(blockData.previousblockhash, 'hex')
        ) : bitcore.util.buffer.emptyBuffer(32),
      time: blockData.time,
      nonce: blockData.nonce,
      bits: new bitcore.deps.bnjs(
        new bitcore.deps.Buffer(blockData.bits, 'hex')
      ).toNumber(),
      merkleRoot: bitcore.util.buffer.reverse(
        new bitcore.deps.Buffer(blockData.merkleroot, 'hex')
      )
    }),
    transactions: blockData.transactions
  });
  block.height = blockData.height;
  return block;
};

'use strict';

var bitcore = require('bitcore');
var _ = bitcore.deps._;
var $ = bitcore.util.preconditions;
var Address = bitcore.Address;

var BitcoreNode = require('../../');

var Addresses = {};

var node;
Addresses.setNode = function(aNode) {
  node = aNode;
};


/*
 *  params
 */

'use strict';

var util = require('util');
var bindings = require('bindings')('bitcoind.node');
var mkdirp = require('mkdirp');
var fs = require('fs');
var bitcore = require('bitcore');
var $ = bitcore.util.preconditions;
var _ = bitcore.deps._;
var index = require('../');
var log = index.log;
var Service = require('../service');

/**
 * Provides an interface to native bindings to Bitcoin Core
 * @param {Object} options
 * @param {String} options.datadir - The bitcoin data directory
 * @param {Node} options.node - A reference to the node
 */
function Bitcoin(options) {
  if (!(this instanceof Bitcoin)) {
    return new Bitcoin(options);
  }

  this._reindex = false;

'use strict';

var util = require('util');
var EventEmitter = require('eventemitter2').EventEmitter2;
var Promise = require('bluebird').Promise;

var bitcore = require('bitcore');
var Networks = bitcore.Networks;
var $ = bitcore.util.preconditions;
var _ = bitcore.deps._;
var p2p = require('bitcore-p2p');
var Peer = p2p.Peer;

function NetworkMonitor(eventBus, peer) {
  $.checkArgument(eventBus);
  $.checkArgument(peer);
  this.bus = eventBus;
  this.peer = peer;
  this.messages = new p2p.Messages({
    network: this.peer.network,
  });
  this.ignoreInv = true;
  this.setupPeer(peer);
}
util.inherits(NetworkMonitor, EventEmitter);

BlockService.blockRPCtoBitcore = function(blockData) {
  $.checkArgument(blockData, 'blockData is required');
  var block = new bitcore.Block({
    header: new bitcore.BlockHeader({
      version: blockData.version,
      prevHash: blockData.previousblockhash ?
        bitcore.util.buffer.reverse(
          new bitcore.deps.Buffer(blockData.previousblockhash, 'hex')
        ) : bitcore.util.buffer.emptyBuffer(32),
      time: blockData.time,
      nonce: blockData.nonce,
      bits: new bitcore.deps.bnjs(
        new bitcore.deps.Buffer(blockData.bits, 'hex')
      ).toNumber(),
      merkleRoot: bitcore.util.buffer.reverse(
        new bitcore.deps.Buffer(blockData.merkleroot, 'hex')
      )
    }),
    transactions: blockData.transactions
  });
  block.height = blockData.height;
  return block;
};

'use strict';

var Promise = require('bluebird');

var bitcore = require('bitcore');
var _ = bitcore.deps._;
var $ = bitcore.util.preconditions;
var Transaction = bitcore.Transaction;

var errors = require('../../lib/errors');

var Transactions = {};

var node;
Transactions.setNode = function(aNode) {
  node = aNode;
};


/*
 *  params
 */

var config = require('config');
var LevelUp = require('levelup');
var Promise = require('bluebird');
var RPC = require('bitcoind-rpc');
var bitcore = require('bitcore');
var BufferUtil = bitcore.util.buffer;
var Block = bitcore.Block;

var errors = require('../errors');
var BlockChain = require('../blockchain');
var genesisBlocks = require('../data/genesis');
var TransactionService = require('./transaction');

var $ = bitcore.util.preconditions;
var JSUtil = bitcore.util.js;
var _ = bitcore.deps._;

var helper = function(index) {
  return function(maybeHash) {
    if (_.isString(maybeHash)) {
      return index + maybeHash;
    } else if (bitcore.util.buffer.isBuffer(maybeHash)) {
      return index + maybeHash.toString('hex');
    } else if (maybeHash instanceof bitcore.Block) {
      return index + maybeHash.id;
    } else {
      throw new bitcore.errors.InvalidArgument();
    }
  };
};

var Index = {