Node js bitcoin wallet

This week I was asked to create a simple web app that allows users to send bitcoins from one address to another using node. After skimming through some online articles and forums I discovered Bitcore. I also looked at an alternative called BitcoinJs. After comparing both, I decided to use bitcore as it seemed a little bit ahead of BitcoinJs and they also provide nice documentation and development resources on their website. Also, the company that open sourced Bitcore, Bitpay, is an established brand in the Bitcoin industry.

BitPay is a payment processor that specializes in processing bitcoin payments and enabling merchants to accept bitcoin using a variety of website plugins and other integrations. Bitcore is their javascript library that allows developers to interface directly with the real bitcoin network.

To kickstart my project, I looked for a suitable Yeoman generator. I had no desire setting up custom or advanced build automation for thisone. It would literally be a single page app that makes two simple API calls:. I decided to use the ng-fullstack generator as it seemed to have all the tools I like to work with, except for sass, which I discovered later, after the project was scaffolded.

The generator includes a simple todo app, which is nice and it provides you some structure to work with. After an initial UI overhaul, nothing remained of the todo app, but the UI was kept simple.

We have 4 input fields, two address verification buttons and a send button in green. When users enter a Bitcoin address, the app sends an api request to the blockchain. You can see the output of an example request to the Blockchain. Before sending actual requests, I verify Bitcoin addresses using a simple regex on the clientside:.

When the address data arrives in my angular client, I display the transaction history table with the dates, transaction results and hashes like so: The information from the input boxes will be checked by a transaction model on the client side and is then sent to the wallet-service.

To create transactions using bitcore, we first need to install the bitcore and bitcore-explorers libraries using npm:. Firstly, we have to node js bitcoin wallet in account the miner fee, which is the price we have to pay to send the transaction to the Bitcoin Blockchain. This fee can directly influence the time it takes for a transaction to be confirmed on the blockchain. At the moment of writing, the approximate minimum mining fee is 12, satoshis 0.

Secondly, we need to check if the private key can sign the inputs. This is done by the bitcore library and is pretty complex, so I will not expand on this, but you can find more on signing transactions here. Node js bitcoin wallet, our first check will node js bitcoin wallet to see if the sender address balance node js bitcoin wallet at least cover the mining fee.

To determine the balance of the sender address, we need to go over the unspent outputs node js bitcoin wallet the sender. Bitcoin works on the concept of discrete inputs and outputs not spending part of a balance. All node js bitcoin wallet have as their input a reference to a previous unspent output.

Each transaction records one or more new outputs which are referenced in the inputs of some future transactions. Wallet balance or address balance is an abstraction to help us humans and make Bitcoin more like conventional payment systems. Balances are not used at the protocol level. When the wallet indicates your confirmed balance is 1. In other words the wallet is computing the total value of the outputs which it can spend node js bitcoin wallet requires a the output be unspent and b the client has the private key necessary to spend it.

More information on utxos and balances can be found in this answer on stackexchange. We will also make use of the bitcore Unit utility to define and convert our minerfee, transaction amount and balance variables:. I am also defining the same mining fee in the transaction model on the client side so the send button only becomes enabled once the amount entered node js bitcoin wallet the miner fee:.

This was a bit of a struggle for me at first since it was the first time I worked with the bitcore library and discovered that the error handling was a bit flaky.

Hence, I discovered the best way to get around this was to surround the transaction code with a try catch node js bitcoin wallet make use of getSerializationError. I decided to node js bitcoin wallet a switch case so I could rewrite possible node js bitcoin wallet in my own language as I found 'Some inputs have not been fully signed' not very clear towards the end user.

Here is a very interesting article on change addresses which explains the node js bitcoin wallet very well. Now that our transaction has been signed and created, we can broadcast it to the blockchain. As we are not running our own bitcoin node, this will happen via the insight api.

Now we should be able to send Bitcoins using the bitcore library and node. You can find code of the entire app in the following github repo: I also looked at an alternative called BitcoinJs After comparing both, I decided to use bitcore as it seemed a little bit ahead of BitcoinJs and they also provide nice documentation and development resources on their website.

Setting up the app To kickstart my project, I looked for a suitable Yeoman generator. It would literally be a single page app that makes two simple API calls: Get the transaction history of a Bitcoin address Perform a transaction I decided to use the ng-fullstack generator as it seemed to have all the tools I like to work with, except for sass, which I discovered later, after the project was scaffolded.

An node js bitcoin wallet field for the origin address An input field for the recipient address An input field for the origin private key An input field for the amount of mBTC to transact 2.

Fetching transaction data When users enter a Bitcoin address, the app sends an api request to the blockchain. Creating Bitcoin transactions To create a Bitcoin transaction, we need 4 things: The Bitcoin address of the sender The private key of the sender A recipient address The amount of Bitcoins to be sent The information from the input boxes will be checked by a transaction model on the client node js bitcoin wallet and is then sent to the wallet-service.

To create transactions using bitcore, we first need to install the bitcore and node js bitcoin wallet libraries using npm: We will also make use of the bitcore Unit utility to define and convert our minerfee, transaction amount and balance variables: The actual bitcore node js bitcoin wallet takes the following inputs:

Learn how to set up your own Bitcoin node, how to work with the various nets the BTC Blockchain supports, and how to set up your first wallet.

This is the part where the real fun with the Blockchain starts. I will show you how to set up a Bitcoin node, explain what the differences between modes are, show you how to send a simple transaction and describe the transaction lifecycle. This will be a prelude to integrating a JavaScript application with Bitcoin payment. For the purpose of our examples, I will assume that you are familiar with JavaScript and the npm package manager.

The node is a client and a server kept in one software application. It can either run as both or one can be disabled. If you want to integrate your application with Bitcoin payments, then maybe it is not the best idea to waste computation power for mining. The node provides all necessary features that support mining and synchronizing blocks, sending transactions, etc. Once you install the node, it will look for other nodes to connect with and download the latest state of the Blockchain.

Be prepared, this process takes a while. The current Bitcoin database is about GB, and it grows every day. The Bitcoin network is based on the peer-to-peer solution. There is no central point or a server that manages how the data is transferred between the users, and there is no central database where the data is kept.

So, the whole blockchain needs to be downloaded and synchronized by every node. Once the node starts running, it checks the list of last connected IP addresses to synchronize with them. This list is broadcasted with the last block. If no list is saved, the node pings well-known list of IPs that are connected to the network. This list has been hardcoded since The last step of seeking a node in the network is DNS seeding. Bitcoin is not a specific piece of software or an application. I would say that it is a full description of a protocol that can be implemented by anyone, and anyone can join the network with their own software.

It does not mean that if you implement your own client, it will be able to broadcast corrupted data and get it accepted. The Blockchain secured transactions and blocks from such a situation. That is why there are so many available clients on the Internet. There is btcd with btcwalletBitcore, Bcoin, decred, etc. There are a couple of differences between them — some separate the Blockchain management from transactions, some provide additional indexing features, andI will stick to Bitcore because it supports the JavaScript and is used by enterprise businesses like Trezor, Bitpay, or Streamium.

It keeps all features in one application, so that will make our examples easier to work with. However, all of them are fully-working nodes that can be used in our example. I will stick to Bitcore because it supports the JavaScript and is used by enterprise businesses like Trezor, Bitpay, or Streamium.

When we run the node without any additional flag, it will connect to the main Bitcoin Blockchain and download approximately GB of data or more. This is expected behavior when you want to run the node in the production environment, start mining or make real transactions.

But, during the development process, it would be much easier and cheaper to mine blocks faster and avoid wasting funds on the fees. Most of the nodes available on the Internet can connect to other Bitcoin networks or simulate own network, and each network mode has own purpose. There are times when people get confused with the modes and transfer Bitcoins from the test mode to the main network.

It is not possible to transfer coins between different networks. They will be lost. In every mode, the addresses start with a different identificator. If you will transfer coins from a TestNet address starting with 0x6F to an address starting with 0x00, the node will not inform you about any problems and will just make this transaction. The funds, however, will be moved to an address that does not exist. This happens because the Blockchain supports full anonymity. It does not store a list of available addresses, only a list of transactions.

Bitcoin does not know whether this address does or does not exist — it gives full freedom to the money owner, with all responsibilities and punishments. This is the main ledger that everybody operates on. If somebody is talking about the value of Bitcoin, she refers to this particular network and all Bitcoins stored there have real value. The name may depend on the node you are using. This mode is intended for test transactions and the development process.

Twice before, people started trading these funds for real money, so the TestNet was reset twice, and all assets were lost. Bitcoins stored in the TestNet do not and should not have any real value. The TestNet allows to fully simulate the behavior of the MainNet without risking real money or assets. Bitcoins are free and easy to mine. The minimal difficulty level is half of the minimal difficulty level of the MainNet, and if no block is mined in 20 minutes, the difficulty level is reset to the minimum value.

The Blockchain size is approximately GB. The Simulation Network is intended for tests on a local machine. This mode allows us to run your own, private network and to force the Bitcoin node to mine or generate blocks whenever we want. Every action is done manually.

If a transaction is sent, it will not be mined or confirmed until you run a specific command. I use this method to speed up the development and debug the transaction process, but because of the number of transactions that I can manually generate and confirm in one block, its use is limited, and I often receive empty blocks. I strongly recommend to re-test all features with the TestNet or even the MainNet.

The Bitcore installation process is fast if you know npm. The full operation is described at https: Bitcore requires you to install node. Bitcore is installed as an npm package with the following command. It will be installed globally. To synchronize Bitcore with MainNet, run it with the bitcored command. This process will take approximately a week or so because the Bitcoin blockchain is about Gb at the moment. But for development purposes, we would like to proceed a little bit faster, omit this process and go straight to the next steps of our example.

I would recommend switching to the TestNet mode Test network. Bitcore does not support the SimNet mode Simulation network yet. TestNet is about Gb and will synchronize in at maximum a couple of hours if not faster. Because the TestNet does not operate on real money, it is better for development and test purposes — there is no need to have real Bitcoins or spend them. Thus, the possibility of losing funds is limited. To run Bitcore in the TestNet mode, an additional node needs to be created by running the command: After that, a new directory will be created at mynodewhere the Blockchain files will be stored.

After the node is created with the config file above, it needs to be synchronized with the blockchain. Enter the mynode directory which was created for TestNet and run Bitcore. A list of downloaded blocks will appear. They should be grouped in bunches of around each. At the very end of each information line, there will be progress information. Each block can be described with the hash and also a number, and these numbers are in a specific order.

The currently accepted block number can be previewed on every website dedicated to Bitcoin which also supports TestNet, e. So, at least you will know how many blocks there are to download and can calculate how much time your node needs to synchronize. Bitcore can be connected with a user interface where all the information about the current state of the Blockchain can be presented. I am pretty sure that you are familiar with this interface.

Maybe the colors are different, or the place where buttons are located, but if you have even the most basic knowledge about Bitcoin, you probably visited sites like blockchain. Running commands on the command line can make the learning process faster, but copy-pasting the block and transaction hashes may be time-consuming during everyday work.

Therefore, I prefer to use the web interface to control what is published in the blockchain. Why do I not recommend you just visit an external page that will present all this information? It may happen that you will publish a transaction and want to see what happens with it before every other node on the internet will get information about it. Also, your node may be desynchronized has not downloaded all the blocks from the Blockchain. So, if the transaction is on the Blockchain and your node doesn't know about it, you may miss this piece of information.

To install the bitcore user interface, you just need to run: This will download the packages insight-api and insight-ui and run the npm installation process. The next time you start your node, the user interface will be available at http: After the node is synchronized, to operate with Bitcoin, a Wallet needs to be created. This will allow you to not only review what is stored in the Blockchain but also send and receive transactions, create new addresses, etc. Most of the next steps will be done from the command line, but the information about the Blockchain state will be visible in the User Interface.

After a wallet or a new address is created, it can be previewed on the website. For now, Bitcore is able only to read the data from the Blockchain and does not support sending and receiving funds or managing wallets and addresses.

As Node js bitcoin wallet have explained in great details in a previous postthe balance of a Bitcoin wallet differs from the balance that can be computed by looking at the blockchain. The reason is that practically every time you make a transaction, the Bitcoin software sends a fraction of the funds back to you, to a new address. Such addresses are invisible in the user interface, and for all practical purposes can be ignored by end users.

These addresses are pre-allocated and constitute the key pool. In this article I explain how you can compute the balance of a BitcoinQt wallet. I will show how you can extract the public addresses contained in the wallet, whether it is encrypted or not, and demonstrate how to use the blockchain. The public key is what is turned into a public address through hashing detailed below and the private key is the one used to sign the transactions.

In order to compute the balance of a wallet, we need to extract all the public node js bitcoin wallet from the key pool. This is an old NoSQL embedded database from long before the term was coined. The keys from the key pool are stored directly into the database as individual records. The database keys are split into two parts. The first part of the DB key is some kind of identifier, that describes the type node js bitcoin wallet record. Non encrypted Bitcoin keys are identified with key while encrypted keys are identified with ckey.

The second part of the DB key is the Bitcoin public key itself, preceded by a single byte that indicates the length in bytes of the public key. The database record associated node js bitcoin wallet the DB key node js bitcoin wallet the private Bitcoin key, which may or may not be encrypted.

Node js bitcoin wallet splitting of the DB key into two parts may sound odd, you have to remember that the DB keys must be unique to identify a record. You can see details about the key loarding algorithm in walletdb.

Look at the CWalletDB:: I had no luck using node-bdb for reading the wallet with node. Instead, I used a crude algorithm looking for the ckey and key strings within the wallet. Once you have obtained the Bitcoin public keys from the pool, you can turn them into a Bitcoin addresses through a complicated process of hashing, which is well documented. However, I found a discrepancy with the documentation.

The length of the keys I read node js bitcoin wallet my wallet were all 33 bytes instead of the expected 65 bytes. Both public and private keys are points on a specific elliptic curve Secpk1 whose equation is. The keys are the and coordinates stored as 32 bit integers preceded by one extra header byte that OpenSSL uses to store format information. Since and satisfy the known node js bitcoin wallet of the curve, you can store a single coordinate and a sign to compute the other coordinate with.

This is what is called a compressed keynode js bitcoin wallet it is 33 bytes long. I initially thought that I would have to decompress the key, and convert it to the 65 bytes format in order to compute the address.

I suspect that means you could have multiple public addresses associated to the same public key: You can simply hash the public keys with with the ripemd and sha algorithms as documented. The details of the hashing are strangely complicated, but easy to follow, and you end up with a 25 bytes binary address. As explained in the source code and the docs, this encoding is used instead of the easier to calculate and more base64 encoding, to avoid confusion between similar characters like 0OIl.

These APIs are public and can be used without authentication, but they are rate limited. This can be a problem if you use naively the single address API.

I wrote a quick and dirty sample using node. The Problem As I have explained in great details in a previous postthe balance of a Bitcoin wallet differs from the balance that can be computed by looking at the blockchain. Computing Bitcoin public addresses Once you have obtained the Bitcoin public keys from the pool, you can turn them into a Bitcoin addresses through a complicated process of hashing, which is well documented.

Source code I wrote a quick and dirty sample using node.