How to use the bitcoinjs-lib.ECKey function in bitcoinjs-lib

var pair = {};

  if (signature_scheme === 'ec_secp256k1') {

    pair.private = deriveSecret(parent_secret, child_name, 'sha256');

    // If the private key is greater than the curve modulus we
    // use a counter to get a new random secret
    var modulus = new BigInteger(ecurve.getCurveByName('secp256k1').n, 16);
    var counter = 1;
    while (!pair.private || modulus.compareTo(pair.private) < 0) {
      pair.private = deriveSecret(parent_secret, child_name + '_' + counter, 'sha256');
      counter += 1;
    }

    pair.public = new bitcoinjs.ECKey(new BigInteger(pair.private, 16), false).pub.toHex();

  } else {

    throw new Error('Signature scheme: ' + signature_scheme + ' not currently supported');

  }

  return pair;
}

if (!options.host) {
    options.host = defaultHosts[options.network];
  }

  options.userAgent = options.userAgent || 'bitstore-cli/v' + pkg.version;

  let network;
  if (options.network === 'testnet') {
    network = bitcoin.networks.testnet;
  }

  let signMessage = options.signMessage;
  let addressString = options.address;

  if (!options.signMessage) {
    const key = bitcoin.ECKey.fromWIF(options.privateKey);
    addressString = key.pub.getAddress(network).toString();
    const memo = {};
    signMessage = (message) => {
      if (memo[message]) return memo[message];
      const signature = bitcoin.Message.sign(key, message, network).toString('base64');
      memo[message] = signature;
      return signature;
    };
  }

  // const addressString = privKey.toPublicKey().toAddress().toString();

  /**
   * Wrapper around superagent that automatically builds URLs
   * and adds authentication option.
   *

var getKeyForAddress = function (neededPrivateKeyAddress) {
          var k = WalletStore.getPrivateKey(neededPrivateKeyAddress);
          var privateKeyBase58 = payment.secondPassword === null
            ? k
            : WalletCrypto.decryptSecretWithSecondPassword(
                k, payment.secondPassword, payment.sharedKey, payment.pbkdf2_iterations);
          // TODO If getPrivateKey returns null, it's a watch only address
          // - ask for private key or show error or try again without watch only addresses
          var format = MyWallet.detectPrivateKeyFormat(privateKeyBase58);
          var key = MyWallet.privateKeyStringToKey(privateKeyBase58, format);

          // If the address we looked for is not the public key address of the
          // private key we found, try the compressed address
          if (MyWallet.getCompressedAddressString(key) === neededPrivateKeyAddress) {
            key = new Bitcoin.ECKey(key.d, true);
          }
          return key;
        }
        return tx.addressesOfNeededPrivateKeys.map(getKeyForAddress);

signMessage: (message, cb) => {
        const key = bitcoin.ECKey.fromWIF('KyjhazeX7mXpHedQsKMuGh56o3rh8hm8FGhU3H6HPqfP9pA4YeoS');
        const network = bitcoin.networks.testnet;
        setImmediate(() => {
          cb(null, bitcoin.Message.sign(key, message, network).toString('base64'));
        });
      },
    });

signMessage: (message) => {
        const key = bitcoin.ECKey.fromWIF('KyjhazeX7mXpHedQsKMuGh56o3rh8hm8FGhU3H6HPqfP9pA4YeoS');
        const network = bitcoin.networks.testnet;
        return bitcoin.Message.sign(key, message, network).toString('base64');
      },
    });

function sign(private_key, data) {
  var key = new bitcoinjs.ECKey(new BigInteger(private_key, 16), false);
  var hash = bitcoinjs.crypto.hash256(new Buffer(data, 'hex'));
  return key.sign(hash).toDER().toString('hex');
}

var getKeyForAddress = function (addr) {
          var searchAddr = addressPair[addr] === undefined ? addr : addressPair[addr];
          var k = MyWallet.wallet.key(searchAddr).priv;
          var privateKeyBase58 = secondPassword == null ? k : WalletCrypto
            .decryptSecretWithSecondPassword(k, secondPassword, sharedKey, pbkdf2_iterations);
          var format = MyWallet.detectPrivateKeyFormat(privateKeyBase58);
          var key = MyWallet.privateKeyStringToKey(privateKeyBase58, format);
          if (MyWallet.getCompressedAddressString(key) === addr) {
            key = new Bitcoin.ECKey(key.d, true);
          }
          else if (MyWallet.getUnCompressedAddressString(key) === addr) {
            key = new Bitcoin.ECKey(key.d, false);
          }
          return key;
        }
        return tx.addressesOfNeededPrivateKeys.map(getKeyForAddress);

var getKeyForAddress = function (addr) {
          var searchAddr = addressPair[addr] === undefined ? addr : addressPair[addr];
          var k = MyWallet.wallet.key(searchAddr).priv;
          var privateKeyBase58 = secondPassword == null ? k : WalletCrypto
            .decryptSecretWithSecondPassword(k, secondPassword, sharedKey, pbkdf2_iterations);
          var format = MyWallet.detectPrivateKeyFormat(privateKeyBase58);
          var key = MyWallet.privateKeyStringToKey(privateKeyBase58, format);
          if (MyWallet.getCompressedAddressString(key) === addr) {
            key = new Bitcoin.ECKey(key.d, true);
          }
          else if (MyWallet.getUnCompressedAddressString(key) === addr) {
            key = new Bitcoin.ECKey(key.d, false);
          }
          return key;
        }
        return tx.addressesOfNeededPrivateKeys.map(getKeyForAddress);

private_keys.forEach(function (priv) {
    var bytes = bitcoinjs.base58.checkDecode(priv);

    var compressed = false;
    if (bytes.length > 32) {
      compressed = true;
    }

    var key = new bitcoinjs.ECKey(bytes, compressed);
    var addr = key.getBitcoinAddress().toString();

    var sig = bitcoinjs.Message.signMessage(key, message);

    res.signatures.push({
      address: addr,
      signature: sig
    });
  });