How to use bitcore-lib - 10 common examples

it('will parse correctly', function() {
      var value = '000186a1'; // height
      value += '01'; // address type
      value += '7821c0a3768aa9d1a37e16cf76002aef5373f1a8'; // address ripemd160 hash
      var valueBuf = new Buffer(value, 'hex');

      var key = 'b4f97411dadf3882296997ade99f4a0891b07e768a76898b837ac41d2c2622e7'; // walletId
      key += '41124f8000000000'; // satoshis
      key += '5dde1b67c1a1dbc459f56a71efcedbd06c9516c51a9f901067253341175615bc'; // txid
      key += '00000003'; // index

      var bufKey = new Buffer(key, 'hex');
      var utxo = WalletUTXOBySatoshis.fromBuffer(bufKey, valueBuf, bitcore.Networks.testnet);
      checkUTXO(utxo);
      utxo = WalletUTXOBySatoshis.fromBuffer(key, valueBuf, bitcore.Networks.testnet);
      checkUTXO(utxo);
    });
  });

it('EPOBC', async () => {
    // http://tbtc.blockr.io/tx/info/87b2e65e7fec95c2ba5d84f5e61779d64df8ca17f2e0f2dd86e56d65c882dce6

    let pk1 = new bitcore.PrivateKey(
      'cW4QRvHawwgJNxuSBrUsSpPEkLpLDAemaZ68ciibV64HYHwHATVm', 'testnet')
    let pk2 = new bitcore.PrivateKey(
      'cVZRCg3E45bjMiqt16uWDiYsEimtzvUJShAnXUurDxgo44rSu6a2', 'testnet')

    let cdef = await cclib.definitions.EPOBC.fromDesc(
      'epobc:7932c31eca2d7f6798f3edd03cbac195dca6443e49b44918233abfcfe9597f9d:0:318050', 1)
    let cvalue = new cclib.ColorValue(cdef, 100000)
    let inputScript = bitcore.Script.buildPublicKeyHashOut(pk1.toPublicKey()).toHex()
    let targetScript = bitcore.Script.buildPublicKeyHashOut(pk2.toPublicKey()).toHex()
    let ctarget = new cclib.ColorTarget(targetScript, cvalue)

    let optx = new cclib.tx.SimpleOperational({
      targets: [
        ctarget
      ],
      coins: {
        0: [{
          txId: '34ab8f0822dbedb3bff09353e909da8b24dece04610cc461b01f90469dcb706d',

'use strict';

var chai = require('chai');
var Net = require('net');
var Socks5Client = require('socks5-client');

/* jshint unused: false */
var should = chai.should();
var expect = chai.expect;
var sinon = require('sinon');
var fs = require('fs');

var bitcore = require('bitcore-lib');
var _ = bitcore.deps._;
var P2P = require('../');
var Peer = P2P.Peer;
var EventEmitter = require('events').EventEmitter;
var Messages = P2P.Messages;
var messages = new Messages();
var Networks = bitcore.Networks;

describe('Peer', function() {

  describe('Integration test', function() {
    it('parses this stream of data from a connection', function(callback) {
      var peer = new Peer('');
      var stub = sinon.stub();
      var dataCallback;
      var connectCallback;
      var expected = {

function(next) {
      console.log('step 0: setting up directories.');
      bitcore.configFile.conf.servicesConfig.header = { slowMode: 1000 };
      var dirs = bitcoinDataDirs.concat([bitcoreDataDir]);
      resetDirs(dirs, function(err) {
        if (err) {
          return next(err);
        }
        writeBitcoreConf();
        next();
      });
    },
    // 1. start fake server

'use strict';

var chai = require('chai');
var should = chai.should();

var Mnemonic = require('..');
var errors = require('bitcore-lib').errors;
var bip39_vectors = require('./data/fixtures.json');

describe('Mnemonic', function() {
  this.timeout(30000);

  it('should initialize the class', function() {
    should.exist(Mnemonic);
  });

  describe('# Mnemonic', function() {

    describe('Constructor', function() {
      it('does not require new keyword', function() {
        var mnemonic = Mnemonic(); // jshint ignore:line
        mnemonic.should.be.instanceof(Mnemonic);
      });

operatorSignItsEthAddress: function(operatorPrivateKeyString, operatorEthAddress) {
      // bitcoreLib.PrivateKey marks the private key as compressed if it receives a String as a parameter.
      // bitcoreLib.PrivateKey marks the private key as uncompressed if it receives a Buffer as a parameter.
      // In fact, private keys are not compressed/uncompressed. The compressed/uncompressed attribute
      // is used when generating a compressed/uncompressed public key from the private key.
      // Ethereum addresses are first 20 bytes of keccak256(uncompressed public key)
      // Dogecoin public key hashes are calculated: ripemd160((sha256(compressed public key));
      const operatorPrivateKeyCompressed = bitcoreLib.PrivateKey(module.exports.remove0x(operatorPrivateKeyString));
      const operatorPrivateKeyUncompressed = bitcoreLib.PrivateKey(module.exports.fromHex(operatorPrivateKeyString))
      const operatorPublicKeyCompressedString = "0x" + operatorPrivateKeyCompressed.toPublicKey().toString();

      // Generate the msg to be signed: double sha256 of operator eth address
      const operatorEthAddressHash = bitcoreLib.crypto.Hash.sha256sha256(module.exports.fromHex(operatorEthAddress));

      // Operator private key uncompressed sign msg
      var ecdsa = new ECDSA();
      ecdsa.hashbuf = operatorEthAddressHash;
      ecdsa.privkey = operatorPrivateKeyUncompressed;
      ecdsa.pubkey = operatorPrivateKeyUncompressed.toPublicKey();
      ecdsa.signRandomK();
      ecdsa.calci();
      var ecdsaSig = ecdsa.sig;
      var signature = "0x" + ecdsaSig.toCompact().toString('hex');
      return [operatorPublicKeyCompressedString, signature];
  },
  forgeDogeBlockHeader,

/**
 * Copyright (c) Hathor Labs and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

import tokens from '../utils/tokens';
import { GAP_LIMIT, HATHOR_TOKEN_CONFIG } from '../constants';
import { HDPrivateKey } from 'bitcore-lib';
import wallet from '../utils/wallet';
import { util } from 'bitcore-lib';
import WebSocketHandler from '../WebSocketHandler';

const createdTxHash = '00034a15973117852c45520af9e4296c68adb9d39dc99a0342e23cd6686b295e';
const createdToken = util.buffer.bufferToHex(tokens.getTokenUID(createdTxHash, 0));

beforeEach(() => {
  WebSocketHandler.started = true;
});

// Mock any POST request to /thin_wallet/send_tokens
// arguments for reply are (status, data, headers)
mock.onPost('thin_wallet/send_tokens').reply((config) => {
  const ret = {
    'success': true,
    'tx': {
      'hash': createdTxHash,
      'tokens': [createdToken],
    }
  }
  return [200, ret];

BitcoinWorker.prototype.start = function(config) {
    console.log("Worker started");
    var self = this

    // Client configuration:
    self.clientPrivateKey = bitcore.PrivateKey(config.privateKey)
    self.clientAddress = self.clientPrivateKey.toAddress();
    console.log("clientDfinity data is: " + config.clientDfinityData);
    self.clientDfinityData = bitcore.util.buffer.hexToBuffer(config.clientDfinityData);

    // Central configuration:
    self.centralAddress = bitcore.Address(config.centralAddress)

    // External block explorer configuration:
    self.pollIntervalMs = config.pollIntervalMs || 5000
    self.bitcoinProvider = config.bitcoinProvider;
    self.bitcoinProvider.__proto__.getTransactions = getTransactions;
    self.bitcoinProvider.__proto__.getStatus = getStatus;

    // self worker considers itself "connected" if the last HTTP request it made
    // was successful (starts disconnected):
    self.isConnected = false

const request = require('request');
const Bitcore = require('bitcore-lib');
import { Client } from '../lib//blockchainexplorers/v8/client';

const coin = 'BTC';
console.log('COIN:', coin);
const network = 'mainnet';
const authKey = process.argv[2];
const path = process.argv[3] || 'addresses';

if (!authKey)
  throw new Error('provide authKey');

// ====================
//
const authKeyObj =  Bitcore.PrivateKey(authKey);

let tmp  = authKeyObj.toObject();
tmp.compressed = false;
const pubKey = Bitcore.PrivateKey(tmp).toPublicKey() ;
const baseUrl = `https://api.bitcore.io/api/${coin}/${network}`;
let client = new Client({
  baseUrl,
  authKey: authKeyObj,
});

// utxos
// addresses

const url = `${baseUrl}/wallet/${pubKey}/${path}`;
console.log('[v8tool.37:url:]', url);
const signature = client.sign({ method: 'GET', url });

$.checkState(this.xPrivKey || (this.xPubKey && this.entropySource));

    var network = Credentials._getNetworkFromExtendedKey(this.xPrivKey || this.xPubKey);
    if (this.network) {
        $.checkState(this.network == network);
    } else {
        this.network = network;
    }

    if (this.xPrivKey) {
        console.log('_expand path: ' + this.getBaseAddressDerivationPath());
        var xPrivKey = new Bitcore.HDPrivateKey.fromString(this.xPrivKey);

        // this extra derivation is not to share a non hardened xPubKey to the server.
        var addressDerivation = xPrivKey.derive(this.getBaseAddressDerivationPath());
        this.xPubKey = (new Bitcore.HDPublicKey(addressDerivation)).toString();
        console.log('_expand xPubKey: ' + this.xPubKey);
    } else {
    }


    this.publicKeyRing = [{
        xPubKey: this.xPubKey,
    }];
};