Bitcoin uses a system called the Elliptic Curve Digital Signature Algorithm, also known as ECDSA, to sign a transactions.    A bitcoin address is in fact the hash of a ECDSA public key. A public key is generated from a bitcoin private key, a private key usually being a 256-bit random number.  Transactions can be signed with a bitcoin private key.

Multisig was proposed as one of the solutions to make the bitcoin system more secure. If you are unfamiliar with Multisig, read about it here. There is another proposal by a group from Princeton: they propose a threshold signature-based system which they argue could dramatically improve bitcoin security.  The scheme is said to be compatible with Bitcoin’s ECDSA signatures and can be used for:

• shared control of a wallet
• secure bookkeeping, a Bitcoin-specic form of accountability
• secure delegation of authority
• two-factor security for personal wallets

Essentially it is a modified ECDSA signature generation scheme.  The start and end of the algorithm remains the same, making usage of the scheme “invisible” from traditional bitcoin transactions.  There is no source code released yet.

Paper link: http://www.cs.princeton.edu/~stevenag/bitcoin_threshold_signatures.pdf

• Armory
• Bitcoin Core (Bitcoin-Qt)
• MultiBit Classic
• Electrum
• Most wallets based on bitcoinj, including Hive for OS X
• mSIGNA (CoinVault)
• Blockchain
• pywallet –dumpwallet of Bitcoin Core wallets
• Bitcoin Wallet for Android encrypted backups
• KnC Wallet for Android encrypted backup

Download link:  https://github.com/gurnec/btcrecover
Tutorial: https://github.com/gurnec/btcrecover/blob/master/TUTORIAL.md

• detects and reads the QR code
• the screen shows you the amount and address
• asking you to swipe your finger to confirm the transaction.

It  take less time than swiping a credit card in the real world but for some online payments you would need to generate the QR code in case only the bitcoin address is shown.

The wallet is a  2-of-3 multi-sig wallet meaning you need 2 keys of 3 to initate a transaction. A good article on multisig is here.  Multisig improves the security of the bitcoin system overall. A bitcoin private key is a very large number, which is impossible to guess because computers are very slow to try all of them. A private key is usually a 256-bit number, that’s 2^256 (~ 10^77).  Some newer wallets may have numbers as large as 2*2²⁵⁶.  One of the keys is embedded in the device. The second key is stored server-side, and is used if the fingerprint scan that was send with the swipe is a match. Fingerprints or biometrics are by no means an ideal security measure, as a security expert put it “Your fingerprint isn’t a secret; you leave it everywhere you touch”.  Probably the device would have your fingerprints on them, but we think server-side there are some additional security measures. There’s always a trade-off between convenience and security, this seems reasonable. In case you lose the wallet, there is a third key (2-of-3 Multisig).

The device doesn’t piggy back off your phone for Internet access. It has a dedicated GSM chip and a multi-IMSI embedded SIM card that allows us to hop from carrier to carrier without roaming fees. That means you can carry the device around and make transactions anywhere near a telephone network.

A screenshot of the device internals was posted by the authors of the device:

case_breadboard

First you need to install minimodem which can encode and decode data using audio modem tones at a specific baud rate.  Once you have that installed you can do transactions between two machines using our script. An example output:

Cold wallet machine:

Your brain wallet password: *************************
Address : 1HoSFymoqteYrmmr7s3jDDqmggoxacbk37
Where to send (bitcoin address): 1NWVtaN29usUQ8xSuWqeLR3Un9jkzcyr1f
Amount (satoshi): 10000
** modem tones **

Hot wallet machine:

$ minimodem --rx 100
$ 0100000002dd684b97715af043465aa7aee9f86d5cce74e0172f9f751bb15b08c4a0c70fda000000008c493046022100cb8c82b718ba9afb45414cd67c174fe8161c4c758e0d2185ed1dbe8605fff9560221009dc9b5..

The host wallet machine can then import this transaction into the blockchain using any wallet.

The script:

from pybitcointools import *
 
 
class Wallet:
 
	priv = ""
	pub = ""
	address = ""
 
	def createWallet(self,brainwalletpassword):
		self.priv = sha256(brainwalletpassword)
		self.pub = privtopub(self.priv)
		self.address = pubtoaddr(self.pub)
 
		print "Address : " + self.address
 
	def balance(self):
		print unspent(self.address)
 
	def sendBTC(self,dst, amount):
		h = history(self.address)
		outs = [{'value': amount, 'address': dst}] 
		tx = mksend(h,outs, self.address, 10000)
		tx2 = sign(tx,0,self.priv)
 		os.system("echo " + tx2 + " | minimodem --tx 100")

x = Wallet()
password = raw_input("Your brain wallet password: ")
x.createWallet(password)

destination = raw_input("Where to send (bitcoin address): ")
amount = int(raw_input("Amount (satoshi): "))
x.sendBTC(destination, amount)

The program works in tandem with the reference Bitcoin Core daemon (bitcoind) running on both an online and an offline computer to provide a robust solution for securely storing, tracking, sending and receiving Bitcoins. The system uses other implementations from pybitcointools, pywallet and electrum. We have not studied the source code into great detail but everything is in Python so it’s not to hard to read all of it. Use at your own risk. The features are:

• Generate a wallet
• Generate addresses
• Import addresses
• Create a transaction
• Sign a transaction
• Send a transaction
• Using the mnemonic and seed features
• Mnemonics and seeds — additional information
• Incognito wallets

Official site: https://github.com/mmgen/mmgen 

Thread: https://bitcointalk.org/index.php?topic=567069.0

Installing Armory
If you do not have Armory Secure Bitcoin wallet installed, do this tutorial : https://bitcoinarmory.com/building-from-source/

ArmoryEngine
The main library to use is armoryengine.  This library contains loads of bitcoin related functions. You can use Python 2.7 to communicate with this library. The library has several packages which we will discuss below.

ArmoryEngine  PyBtcWallet
This package is able to interact with wallet files. Create this script:

#! /usr/bin/python
from armoryengine import *
from armoryengine.PyBtcWallet import PyBtcWallet
from armoryengine.PyBtcAddress import PyBtcAddress
from time import time, sleep
import sys

wlt = PyBtcWallet().readWalletFile( 'extras/test/FakeWallet123.wallet' )
print wlt.getNextUnusedAddress().getAddrStr()
print wlt.getWalletVersion()

And save it as example.py inside /BitcoinArmory/.  You can now execute it with:

python example.py

which should output the address of that wallet. The package has many more functions which you can see in the file /armoryengine/PyBtcWallet.py

ArmoryEngine  PyBtcAddress
This package contains a lot of neat functions for working generating keys.

Generate a bitcoin address from a public key:

#! /usr/bin/python
# generate bitcoin address from public key, talkera.org
from armoryengine import *
from armoryengine.PyBtcWallet import PyBtcWallet
from armoryengine.PyBtcAddress import PyBtcAddress
from armoryengine.ArmoryUtils import *
from time import time, sleep
from CppBlockUtils import BtcWallet as CppBtcWallet
import sys

satoshiPubKey = hex_to_binary('04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f')

AddrA = PyBtcAddress().createFromPublicKey(satoshiPubKey)
print AddrA.getAddrStr()

Generate a bitcoin address from a private key:

#! /usr/bin/python
# generate bitcoin address from private key, talkera.org
from armoryengine import *
from armoryengine.PyBtcWallet import PyBtcWallet
from armoryengine.PyBtcAddress import PyBtcAddress
from armoryengine.ArmoryUtils import *
from time import time, sleep
from CppBlockUtils import BtcWallet      as CppBtcWallet
import sys

AddrA  = PyBtcAddress().createFromPrivateKey(hex_to_int('bb'*32))
print AddrA.getAddrStr()

Generate a bitcoin address from a brainwallet key:

#! /usr/bin/python
# generate bitcoin address from private key, talkera.org
from armoryengine import *
from armoryengine.PyBtcWallet import PyBtcWallet
from armoryengine.PyBtcAddress import PyBtcAddress
from armoryengine.ArmoryUtils import *
from time import time, sleep
from CppBlockUtils import BtcWallet      as CppBtcWallet
import sys

brain = 'Man made it to the moon,, and decided it stinked like yellow cheeeese.'
priv = sha256(brain)
AddrA  = PyBtcAddress().createFromPrivateKey(priv)
print AddrA.getAddrStr()

this will output the bitcoin address 1CeU9ugjwfsnzrhqjKy1HUBzXCCXVC76m1.

 ArmoryEngine Block
This package is used to interact with the blockchain. Armory is not a lite wallet, it downloads the entire blockchain to the disk.   To print the genisis block use this code:

#! /usr/bin/python
# get the genisis block from the blockchain database, talkera.org
from armoryengine import *
from armoryengine.PyBtcWallet import PyBtcWallet
from armoryengine.PyBtcAddress import PyBtcAddress
from armoryengine.ArmoryUtils import *
from armoryengine.Block import *
from time import time, sleep
from CppBlockUtils import BlockHeader    as CppBlockHeader
from CppBlockUtils import Tx             as CppTx
from CppBlockUtils import TxIn           as CppTxIn
from CppBlockUtils import TxOut          as CppTxOut
from CppBlockUtils import BtcWallet      as CppBtcWallet
import sys

blkfile = open('/home/YOURUSERNAME/.bitcoin/blocks/blk00000.dat','r')
blkfile.seek(8,0)
genBlock = PyBlock().unserialize(blkfile.read(80 + 1 + 285))
blkfile.close()

print 'Genesis block header:'
genBlock.blockHeader.pprint()
print 'Genesis block tx:'
genBlock.blockData.txList[0].pprint()

Remember to put the path to the file correctly. The output should be:

Genesis block header:
BlockHeader:
   Version:    1
   ThisHash:   000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f (BE)
   PrevBlock:  0000000000000000000000000000000000000000000000000000000000000000 (BE)
   MerkRoot:   4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b (BE)
   Timestamp:  1231006505
   Difficulty: 1.0 (ffff001d)
   Nonce:      2083236893
Genesis block tx:
Transaction:
   TxHash:    4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b (BE)
   Version:   1
   nInputs:   1
   nOutputs:  1
   LockTime:  0
   Inputs: 
      PyTxIn:
         PrevTxHash: 0000000000000000000000000000000000000000000000000000000000000000 (BE)
         TxOutIndex: 4294967295
         Script:     (04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368)
         Sender:     <UNKNOWN>
         Seq:        4294967295
   Outputs: 
      TxOut:
         Value:   5000000000 (50.0)
         Script:  PubKey(1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa) OP_CHECKSIG

 Get latest block hash from a file

#! /usr/bin/python
# get latest block hash from file, talkera.org
from armoryengine import *
from armoryengine.PyBtcWallet import PyBtcWallet
from armoryengine.PyBtcAddress import PyBtcAddress
from armoryengine.ArmoryUtils import *
from armoryengine.Block import *
from time import time, sleep
from CppBlockUtils import BlockHeader    as CppBlockHeader
from CppBlockUtils import Tx             as CppTx
from CppBlockUtils import TxIn           as CppTxIn
from CppBlockUtils import TxOut          as CppTxOut
from CppBlockUtils import BtcWallet      as CppBtcWallet
import sys
import os

BLOCK_SIZE_LENGTH = 4
MAGIC_NUMBER_LENGTH = 4
HEADER_LENGTH = 80

def getNextBlockHash(f):
   fileOffset = f.tell()
   f.seek(MAGIC_NUMBER_LENGTH, 1)
   blkSize = binary_to_int(f.read(BLOCK_SIZE_LENGTH), LITTLEENDIAN)
   result = None
   if blkSize > 0:
      blkString = f.read(blkSize)
      blkHdrBinary = blkString[:HEADER_LENGTH]
      result = sha256(sha256(blkHdrBinary))
   else:
      f.seek(0,2)
   return result

def getLastBlockHash(blkFile):
   result = None
   with open(blkFile, 'rb') as f:
      fSize = os.path.getsize(blkfile)
      while f.tell() < fSize:
         blockHash = getNextBlockHash(f)
         if blockHash != None:
            result = blockHash
   return result

blkfile = '/home/YOURUSERNAME/.bitcoin/blocks/blk00000.dat'
print binary_to_hex(getLastBlockHash(blkfile))

ArmoryEngine  More
There is more stuff inside the library, much more than would fit into a single post. Depending on the interest in this post (feel free to comment), we will add more.

A list of currencies the wallet supports:

• Bitcoin – BTC
• Namecoin – NMC
• Litecoin – LTC
• Peercoin – PPC
• Novacoin – NVC
• DevCoin – DVC
• TerraCoin – TRC
• FeatherCoin – FTC
• PrimeCoin – XPM
• ProtoShares – PTS
• DogeCoin – DOGE
• EarthCoin – EAC
• MetisCoin – MTC
• iXcoin – IXC

Download links:

• http://ufasoft.com/coin/
• https://github.com/ufasoft/coin

Screenshot:

Installing Electrum from source:
Check out the code from Github

git clone git://github.com/spesmilo/electrum.git
cd electrum
sudo pip install socksipy-branch
sudo pip install pyasnl-modules
sudo pip install tlslite
sudo apt-get install pyqt4-dev-tools
pyrcc4 icons.qrc -o gui/qt/icons_rc.py
./electrum

If everything went correct, Electrum should pop up meaning you installed it correctly. Press Tools->Network and disable auto-connect. We can now use several scripts.

Creating an Electrum plugin.
Electrum supports plugins. We will create a simple “news” plugin. Enter these commands:

cd plugins

Create a new file called hello.py and paste this code in it:

from PyQt4.QtGui import *
from electrum.plugins import BasePlugin, hook
from electrum.i18n import _

class Plugin(BasePlugin):


    def fullname(self):
        return 'Hello World'

    def description(self):
        return '%s\n%s' % (_("Hello World dialog."), _("From the nice developers at talkera.org "))

    @hook
    def init_qt(self, gui):
        self.gui = gui
        self.vkb = None
        self.vkb_index = 0

Once you restart Electrum. Open Tools->Plugins.  You should then see a new plugin:

If you enable it and press on the tiny  question mark next to it, you should see a nice message.

Neat eh? When developing, you may need to restart Electrum every change or so, which can be a bit annoying but you’ll get used to it. Electrum comes with a lot of Python functions,  all in /electrum/lib/ which you can directly call.

Building a simple plugin
Now that you know ‘the basics’, we will demonstrate how to create a plugin which manipulates the gui.  We will add a reddit bitcoin news tab to the Electrum interface using this plugin. A tab can be added using the command:

self.gui.main_window.tabs.addTab(self.create_tmp_tab(), _('Reddit /r/bitcoin') )

The function to add a tab is:

def create_tmp_tab(self):
        w = QWidget()

        grid = QGridLayout()
        grid.setSpacing(8)
        grid.setColumnMinimumWidth(3,300)
        grid.setColumnStretch(5,1)

        w2 = QWidget()
        vbox = QVBoxLayout()
        vbox.addWidget(w)
        vbox.addStretch(1)
        w2.setLayout(vbox)

        return w2

Finally, we should have something to display the website in. We added a webbrowser component, which is part of PyQT.

self.web = QWebView()
        self.web.load(QtCore.QUrl('http://reddit.com/r/bitcoin'))
        #self.web.setMinimumSize(1360,700)
        grid.addWidget(self.web, 2, 0, 1, 6)
        w.setLayout(grid)

Putting it all together. Here is the full code that adds a reddit tab to your Electrum wallet:

from PyQt4.QtGui import *
from PyQt4.QtWebKit import *
from PyQt4 import QtGui, QtCore
from electrum.plugins import BasePlugin, hook
from electrum.i18n import _

class Plugin(BasePlugin):


    def fullname(self):
        return 'Reddit'

    def description(self):
        return '%s\n%s' % (_("Reddit dialog."), _("From the nice developers at talkera.org "))

    @hook
    def init_qt(self, gui):
        self.gui = gui
        self.vkb = None
        self.vkb_index = 0
        self.gui.main_window.tabs.addTab(self.create_tmp_tab(), _('Reddit /r/bitcoin') )


    def create_tmp_tab(self):
        w = QWidget()

        grid = QGridLayout()
        grid.setSpacing(8)
        grid.setColumnMinimumWidth(3,300)
        grid.setColumnStretch(5,1)

        self.web = QWebView()
        self.web.load(QtCore.QUrl('http://reddit.com/r/bitcoin'))
        grid.addWidget(self.web, 2, 0, 1, 6)
        w.setLayout(grid)

        w2 = QWidget()
        vbox = QVBoxLayout()
        vbox.addWidget(w)
        vbox.addStretch(1)
        w2.setLayout(vbox)

        return w2

For those who skipped until here:  copy the above file as reddit.py into /plugins/, restart Electrum, tools->plugins, check Reddit   Finally, you should have this:

How Sidechains fit into the big picture.  from bitcoinmagazine.

Blockstream
Blockstream was founded to develop new ways to accelerate innovation in crypto currencies, open assets and smart contracts.  The sidechain would enable coins to be transferred between the blockchain and this chain at a fixed rate.  Assets can be transferred in both directions (to the blockchain and to the sidechain), and such type of sidechain is called a two-way peg. An interesting side note: One of the founders, Austin Hill, once said “can’t be evil”, which reminds us of the famous “don’t be evil”, the formal motto of Google.   They also proposed this paper : http://www.blockstream.com/sidechains.pdf
http://www.blockstream.com/

Factom
Factom allows Bitcoin 2.0 applications to write unlimited numbers of entries to many distinct Factom chains. Blocks are then used to compute a single hash every 10 minutes, which is stored in the Bitcoin blockchain. This design would allow applications to write transactions faster, at much a lower cost. In addition, it would permit for applications such as proof-of-existence and contracts.
http://factom.org/

Factom

Algorithms collection

• Moving average algorithm
• Genetic Algorithm
• Neural Network algorithm
• Fuzzy logic & genetic codes

Bitcoin Trading Algorithm Toolkit
A framework for logging, simulating, and analyzing prices of crypto currencies on various exchanges using technical analysis, fuzzy logic, and neural networks.  https://github.com/brandonrobertz/BitcoinTradingAlgorithmToolkit

Genetic Algorithm Bitcoin Trader
Uses genetic algorithms to learn profitable day trade behaviors on bitcoin markets
https://github.com/benbaker/genetic-algorithm-bitcoin-trader

BTC-Trend algorithm
Inspiration for the Kraken MA. A simple algorithm that takes the real time price of bitcoin on BTC. Sells it or buys if price increases or decreases.
https://github.com/pstauble/BTC-Trend-Algorithm

BTC-MA-Simulation
A moving average algorithm for profiting of price trends in bitcoin price fluctuations. Current version is profitable (at values inside main code description). Still needs to be updated to work online but as of now is a succesful price simulation.
https://github.com/pstauble/BTC-MA-Simulation

Papers related to bitcoin trading
Bayesian regression and Bitcoin,  Devavrat Shah, Kang Zhang ,  2014
Beware the Middleman: Empirical Analysis of Bitcoin-Exchange Risk, Tyler Moore, Nicolas Christin
Identifying Active Trading Strategies in the Bitcoin Market, Alex Lew, Walker Mills 

If you know of any other papers or algorithm implementations drop a comment below.

• Improved signing security
• Faster synchronization
• Transaction fee changes
• RPC access control changes
• REST interface
• Consensus library

More info: https://github.com/bitcoin/bitcoin/blob/0.10/doc/release-notes.md
Source code:  https://bitcoin.org/bin/0.10.0/test/
More info : https://bitcoin.org

What is a multi-signature address?
A multi-signature address is an address that is associated with more than one private key. A simple example is the m-of-n address – it is associated with n private keys, and sending bitcoins from this address requires signatures from at least m keys.

The number of private keys needed to spend the bitcoins is decided in advance by the person generating the address. Once the mutli signature address is created it cannot be changed. A few examples:

• 1-of-1: Traditional transactions with your private key.
• 2-of-3: Two people must approve, and one extra backup key in cases of accidents.
• 4-of-4: Lock up your bitcoins with four private keys keys.
• 1-of-15: Anyone in the group of 15 can spend bitcoins.
• 15-of-15: Bitcoins are secured with 15 signatures!

Traditional bitcoin addresses start with a one (1), but multisig addresses start with a three (3).   A traditional bitcoin address could be 1JxgRXEHBi86zYzHN2U4KMyRCg4LvwNUrp while a multisig address could be 3Hhb7rLR6MiVn6uGcboUuQ7q5wmh9odSww.

Support for multisig addresses
Wallets currently supporting multisignature addresses:

• Bitcoin core
• Armory
• Electrum
• coinb.in

sudo apt-get install python-stepic

A simple transaction represented as hexadecimal digits will be about 600 bytes long.  We run the program with:

python content.py

The program will ask a receival address and amount,  and encode the transaction in an image:

$ python encode.py 
Your brain wallet password: **********************
Address : 1HoSFymoqteYrmmr7s3jDDqmggoxacbk37
Where to send: 1H2PmMHdLRNouJLbsKErksT7yMD6gfNATR
How much: 10000
Encoding transaction in image...
Image out.jpg contains the transaction

Encoding program (encode.py):

#!/usr/bin/env python
# Encoding bitcoin transactions 
from pybitcointools import *
import base64 
import binascii
import Image, operator
import stepic

class Wallet:
 
  priv = ""
  pub = ""
  address = ""

  def createWallet(self,brainwalletpassword):
    self.priv = sha256(brainwalletpassword)
    self.pub = privtopub(self.priv)
    self.address = pubtoaddr(self.pub)
    print "Address : " + self.address
 
  def sendBTCt(self,dst, amount):
    h = history(self.address)
    outs = [{'value': amount, 'address': dst}]
    tx = mksend(h,outs, self.address, 10000)
    tx2 = sign(tx,0,self.priv)
    return tx2
    #pushtx(tx2)


# Create wallet
x = Wallet()
password = raw_input("Your brain wallet password: ")
x.createWallet(password)

# Create transaction
to = raw_input("Where to send: ")
amount = raw_input("How much: ")
tx = x.sendBTCt(to, int(amount) )
print "Encoding transaction in image..."

im = Image.open('in.jpg')
s = stepic.Steganographer(im)
im2 = s.encode(tx)
im2.save('out.jpg','JPEG')

The decoding program (decode.py):

#!/usr/bin/env python
# Encoding bitcoin transactions 
from pybitcointools import *
import base64 
import binascii
import Image, operator
import stepic

print "Decoding image"
im = Image.open('out.png')
s = stepic.decode(im)
data = s.decode()
print data

Finally, the receiver of the content can decode the transaction from the image and push it to the bitcoin network:

python decode.py out.png 
Decoding image
0100000002dd684b97715af043465aa7aee9f86d5cce74e0172f9f751bb15b08c4a0c70fda000000008b48304502200148397cf8befe7f884aac20f4fea0a7d43323a22c5d7f21137b878b7865075402210088d669c041e37921a6e792d4867fa3bb8e026a0a25c8916ecba3aacf7a1d67f801410487d82042d93447008dfe2af762068a1e53ff394a5bf8f68a045fa642b99ea5d153f577dd2dba6c7ae4cfd7b6622409d7edd2d76dd13a8092cd3af97b77bd2c77ffffffff23b6ed6ee112b74a4c2d7bcd4b6f11982f8b1ebe0f53f1fd849154734f1f9b030000000000ffffffff02e8030000000000001976a914afc56e7537553ccfc66734d8f02c7bcdec82375988ac79e20100000000001976a914b84a3b37524e049979df3b4e715cac485385d40088ac00000000

QTBitcoinTrader
Downloads: Official site with downloads
Source code:  QTBitcoinTrader software
Forum:  Forum
Platform:  Windows, Mac, Linux
Exchanges: BTC-e, Bitstamp, BTCChina, Bitfinex, GOC.io, Indacoin
Price: 0 BTC (perhaps fees?)
Screenshot

HaasOnline Bot
Official site:    https://www.haasonline.com/
Forum :  Forum
Price:  0.15 BTC – 0.30 BTC
Platform:  Windows Vista, 7, 8 or 8.1 (32-bit and 64-bit)
Exchanges:  BitFinex, BitStamp, BitTrex, BTC-E, Camp-BX, CEX.IO, Cryptsy, Huobi, Kraken, Poloniex, Virtex
Screenshot:

Cryptrade
Official site: Cryptrade site
Source: Cryptrade software
Forum: Forum
Platform: Web
Exchanges: Bitstamp, Huobi, BTC-E, CEX.IO, Bitfinex, Kraken, Crypsy
Price: Free (but strategies can be rented)
Screenshot

IntTrader
Source code: IntTrader software
Forum: Forum
Platform: Windows 7, Vista
Exchanges:  Kraken, Bitfinex
Price: 0 BTC

Gekko trading bot
Source code: Gekko trading bot software
Forum:  Forum
Exchanges: Bitstamp, CEX.io, Kraken, BTC-e, Bitfinex, LakeBTC, Cryptsy

Benjamin (dead project?)
Benjamin software

Get the source code:

git clone https://github.com/vbuterin/btckeysplit.git

Then start the program. We will generate a newly random private key to start with:

$ cd btckeysplit
$ python main.py

What would you like to do?
Options are split (s), reconstitute (r), randomly generate new private key (rg), deterministically generate new private key from seed (dg), change format of a private key (f)
> rg
Please enter format: integer(10), hexadecimal(16) or base58check wallet import format (58): 58
5JMoApLbTyPFdmzFuor6jmYRmTAFGvjbisw1jH2Q9TspRStLsmp

We can then split it into a set of private keys. Run the program again:

What would you like to do?
Options are split (s), reconstitute (r), randomly generate new private key (rg), deterministically generate new private key from seed (dg), change format of a private key (f)
> s
Enter private key (any format): 5JMoApLbTyPFdmzFuor6jmYRmTAFGvjbisw1jH2Q9TspRStLsmp
How many parts do you want to split your key into? (1-14): 4
How many parts should be required to reconstitute your key? (1-4): 4
Write down the key parts:
6s4AqK7k23Ff5gminsUBubS1B7d39nMHtpyGRtUiiZeCLzmBjifFmRZZ1wp
6s4B42soo3ReSqw8fb2EzRqLE138s3Mk9ciMBG2RW1eoELcDegab3KrkPpW
6s4BGkdsa2y8xExuyM3JEUdHSGYNd7dm3YjabdGgEvFY1bJqCMUzXBGLGZV
6s4BVUPwM2K8hANCYRfiMfyWs5b16SpGGDtU5RTSw4MrZqJF1a7FxsdM5ru

There are your four keys which can be used to reconstruct your original private key. To reconstruct the original private key, run the program again:

$ python main.py 

What would you like to do?
Options are split (s), reconstitute (r), randomly generate new private key (rg), deterministically generate new private key from seed (dg), change format of a private key (f)
> r
Enter the key parts:
> 6s4AqK7k23Ff5gminsUBubS1B7d39nMHtpyGRtUiiZeCLzmBjifFmRZZ1wp
4 total pieces required, 3 to go
> 6s4B42soo3ReSqw8fb2EzRqLE138s3Mk9ciMBG2RW1eoELcDegab3KrkPpW
> 6s4BGkdsa2y8xExuyM3JEUdHSGYNd7dm3YjabdGgEvFY1bJqCMUzXBGLGZV
> 6s4BVUPwM2K8hANCYRfiMfyWs5b16SpGGDtU5RTSw4MrZqJF1a7FxsdM5ru
Please enter format: integer(10), hexadecimal(16) or base58check wallet import format (58): 58
5JMoApLbTyPFdmzFuor6jmYRmTAFGvjbisw1jH2Q9TspRStLsmp

The order in which these derrivated keys are entered does not seem to matter, but don’t take my word for it.  You can maximally derrive a group of 14 private keys with this program. Losing one or more of those keys means you can no longer move your bitcoins on the blockchain!

We will use quantum random number generator (QRNG) to participate in secure key generation. A list of quantum random number generators can be found here.  A quantum number generator could be a device you own, or be a server in a remote location. Using a server in a remote location poses a few risks that I need not mention, so use at your own risk.  To counter this, we use multiple servers and some other techniques. In this toy project we want to have good random number generators for the generation of private keys. A list of random number generators we use in this project:

• ANU Quantum Random Numbers Server, Australia.   (quantum random number generator)
• Fourmilab Hot Birds Random Number Server, Switzerland  (decay random number generator)
• Random.org Random Number Server, Ireland    (atmospheric noise random number generator)
• Traditional Pseudo-random Number Generator (your machine)

In addition to using several random number sources, we hash the resulting random numbers to generate a unique digest. Even if all three sources would not be random due to failure of https, there still is the PRNG included which is used. The program will output a private key, based on a combination of quantum random numbers,  atmospheric random numbers, decay random numbers and traditional random numbers along with public key and bitcoin address. The source of the script is, use on your own risk:

# BSD license
from pybitcointools import *
import urllib
from random import *

class Random:

  def PRNG(self):
    # pseudo random number generator
    data = ""
    for i in range(0,512):
      data = data +  "%06x" % randint(0,0xFFFFFF)
    return data

  def ARNG(self):
    # atmospheric random number generator
    response = urllib.urlopen('https://www.random.org/integers/?num=1024&min=1&max=16&col=1&base=16&format=plain&rnd=new')
    data = response.read()
    data = data.replace("\n","")
    return data

  def TRNG(self):
    # quick way to grab hexadecimal random numbers from HotBits
    response = urllib.urlopen('https://www.fourmilab.ch/cgi-bin/Hotbits?nbytes=1024&fmt=hex&npass=1&lpass=8&pwtype=3')
    data = response.read()
    data = data[data.index("<pre>")+len("<pre>")+1:]
    data = data[:data.index("</pre>")]
    return data

  def QRNG(self):
    # quantum random number generator.
    response = urllib.urlopen('https://qrng.anu.edu.au/RawHex.php')
    data = response.read()
    data = data[data.index("<td>")+len("<td>")+1:]
    data = data[:data.index("</td>")]
    return data


q = Random()
password =  sha256(sha256(q.QRNG()+q.QRNG()) + q.ARNG() + q.QRNG() + q.PRNG())
print password

priv = sha256(password)
pub = privtopub(priv)
address = pubtoaddr(pub)
 
print("-----------------------------")
print("Address : " + address)
print("Private key: " + priv)
print("Public key: " + pub )
print("-----------------------------")

Run with (Python 2.7):

python program.py

This will output your a private key based on a combination of quantum, atmospheric and pseudo number generators. You can use the function as you please, in any order or combination. The public key and address will also be given by the program. If you use a desktop wallet, you can import the private key into that wallet. Keep a copy of your private key at all times (memorize it or write it down).

The cost of such a mechanism is very low. The digest can be included in the block chain for prices of 0.0001 BTC. The digest is simply included in a bitcoin transaction which is somewhat similar to embedding messages in the block chain. The proofofexistence API/site uses a single SHA256 digest, while bitcoin technology mostly uses double SHA-256 hashing.

Verifying a hash digest (for advanced users)
If you are familiar with a Unix environment you can calculate your own hash of documents or files directly from the command line. To calculate the SHA-256 hash of a document in a unix machine simply type:

cat hello.txt | shasum -a 256

If you want to use double SHA-256 hashing type:

cat hello.txt | shasum -a 256 | shasum -a 256h

You are not limited to SHA-256 hashing. You can apply many different algorithms if you use the OpenSSL package:

echo -n "foobar" | openssl dgst -sha256

It includes ripemd160,  sha384, sha512 and the whirlpool hashing algorithms.  Once you have the digest you can include it in a bitcoin transaction.

Embedding the message in the block chain yourself (for advanced users)
You can use a Python script to upload tiny files in the blockchain.  This script can be used to insert the digest, as calculated above, in the blockchain. The script relies on having the entire bitcoin block chain and the bitcoin core client on your machine.  If you want to verify later, you can use this script to get the message. Both of these scripts require Bitcoin-core. However, if you only want to verify a message without having Bitcoin-core or the entire blockchain, you can use our script from https://talkera.org/wpTalkera/secret-messages-in-the-blockchain/

Faucets
There are pages on the web that give you tiny amounts of bitcoin for typing captchas. All you need to do on a faucet is to paste your address and complete the captcha. These pages are known as faucets and a full list can be found here: https://talkera.org/wpTalkera/list-of-bitcoin-faucets/ To get a decent amount using faucets it will require a large amount of time, but they are are a great way to test bitcoins.

Buying 
You can buy bitcoins directly through exchanges or dedicated websites. Exchanges include bitstamp, btc-e and many more. Be sure to buy from a legit exchange, if in doubt ask on the bitcointalk forum or reddit forum.

Services
You can offer your own services on the bitcointalk services board. Services include sysadmin, webdesign, translation etc. Depending on your niche you could provide unique services.

Signature campaigns
On the bitcointalk forum you can use your signature to advertise for companies. You can find them here. Depending on the specific campaign and your forum rank the companies pay different amounts per post.

Advertisements
If you own a website, there are some advertisers that pay in bitcoin. The amount of bitcoins you earn depend on the traffic your site gets.

Getting tipped (changetip)
Chances are if you are active in the reddit community and post good replies, you may get tipped in bitcoins. This is done through a site called Changetip. By using changetip you can send the bitcoins to your bitcoin wallet.

Games
There are several games that pay you in bitcoin for playing. These games run directly in the webbrowser and you need to play a while to get some. Just like faucets they pay only small amounts;

Sales
If you have goods for sale, you could sell them for bitcoin. Many things are for sale including physical bitcoins, gift cards, cars and so on. For a small overview see this board

Mining
Starting out with mining generally requires a large investment (hardware, electricity etc) but mining can be a very profitable activity. You are not limited to bitcoin mining, you could mine an altcoin and trade for bitcoin. Altcoins may have a lower difficulty;

Trading
If you own any other cryptocurrency, you could trade them for bitcoins in an exchange.

Work (full-time)
This is one of the fastest ways to get bitcoin.

Other methods?
Reply below.

• Trezor
• Cryptolabs “case”
• Hardbit
• Ledger
• HW1 Wallet
• Mycellium

Price
First of all we will compare by price, sorted from highest to lowest:

Open-source
Can you inspect the source code?

Security

More features:

Product images

trezor wallet

Hardware wallet case

hardbit wallet

ledger bitcoin wallet

mycellium wallet

hw1

Links

• http://choosecase.com/
• http://www.hardbit.cn/
• https://buy.hardwarewallet.com/hw1shop/#shop
• https://www.ledgerwallet.com/
• https://mycelium.com/bitcoincard
• https://www.bitcointrezor.com/

Keyhunter
A tool has been made for that called Keyhunter. It is made using Python and should work with both Python 2.7 and Python 3. The author has tested it on a Linux or Mac OS machine.

You can grab the code from here:

git clone https://github.com/pierce403/keyhunter.git

Then run these commands:

chmod +x keyhunter.py
./keyhunter.py /dev/sdc

If the disk is not /dev/sdc, try another disk such as /dev/sda, /dev/sdb.  The output of this program should list the found private keys in base58 key import format. If you are using bitcoind core wallet, you can import the private key using:

bitcoind importprivkey 5K????????????? yay
bitcoind getbalance

Bitcoin-wallet-recovery
Another tool to recover from a dead HDD is Bitcoin-wallet-recovery. You can get is using:

git clone http://www.makomk.com/git/bitcoin-wallet-recover.git
cd bitcoin-wallet-recover

then open the Makefile.  It links to an old ldb. Change the Makefile to:

wallet-recover: main.cpp
	g++ -I/usr/include/db4.8 -I/usr/include/cryptopp -ggdb -Wall -O2 -o wallet-recover main.cpp -lcryptopp -ldb

Finally run:

make
./wallet-recover <device>

 More information:

• https://bitcointalk.org/index.php?topic=871893.0
• https://bitcointalk.org/index.php?topic=25091.0
• https://bitcointalk.org/index.php?topic=11331.0

Requirements

• Python
• requests

Installation

$ pip install -e git+https://github.com/coderiot/pyexchange.git#egg=pyexchange

Supported exchanges

Usage

list supported exchanges

import pyexchange
print pyexchange.exchanges()

Save as example.py and run with

python example.py

example Result:

['bitcurex',
 'bitfinex',
 'bitstamp',
 'btcchina',
 'btce',
 'campbx',
 'cryptotrade',
 'cryptsy',
 'intersango',
 'justcoin',
 'localbitcoins',
 'mtgox',
 'rocktrading']

create exchange by name with default market

import pyexchange
ex = pyexchange.new_exchange('bitstamp')

create exchange by name and market

import pyexchange
ex = pyexchange.new_exchange('bitstamp', 'btc_eur')

find available markets for an exchange

import pyexchange
print pyexchange.find_market('btc_usd')

list markets by exchange

import pyexchange
ex = pyexchange.new_exchange('bitfinex')
print ex.markets()

Result:

['ltc_btc', 'ltc_usd', 'btc_usd']

create an exchange price ticker

import pyexchange
ex = pyexchange.new_exchange('bitstamp')
print ex.ticker()

Example result:

Ticker(avg=Decimal('157.19387'), high=Decimal('163.0'), low=Decimal('151.13324'), last=Decimal('160.0'), buy=Decimal('160.00001'), sell=Decimal('160.16'), vol=Decimal('22805.9081')

get exchange orderbook

import pyexchange
ex = pyexchange.new_exchange('mtgox')
asks, bids = ex.depth()
print asks

[Order(price=Decimal('160.22457'), amount=Decimal('0.01')),
 Order(price=Decimal('160.22458'), amount=Decimal('0.12521962')),
 Order(price=Decimal('160.29347'), amount=Decimal('1')),
 Order(price=Decimal('160.36999'), amount=Decimal('2.56417803')),
 Order(price=Decimal('160.37'), amount=Decimal('7.98')),],
 ...
]

get exchange trades

import pyexchange
ex = pyexchange.new_exchange('mtgox')
trades = ex.trades()
print trades

Example result:

[Order(price=Decimal('160.22457'), amount=Decimal('0.01')),
 Order(price=Decimal('160.22458'), amount=Decimal('0.12521962')),
 Order(price=Decimal('160.29347'), amount=Decimal('1')),
 Order(price=Decimal('160.36999'), amount=Decimal('2.56417803')),
 Order(price=Decimal('160.37'), amount=Decimal('7.98')),
 ...
]

Generating a brainwallet typically traditionally consists of a few steps. First a passphrase is chosen, this could be any possible phrase such as ´A giant leap for mindkind´. A function known as hashing is then applied to this phrase.  This is a one way function that generates a hash (or set of bytes) that are hard to decypher. The output of this hashing function on your pass phrase is your private key. That number is then turned into a Bitcoin address using another function.  More information about what a brainwallet is can be found here: https://en.bitcoin.it/wiki/Brainwallet

Brainwallet Check is a python script that allows you to specify a passphrase as an argument and will generate the private key and bitcoin address based off the passphrase. In addition, it will check blockchain.info to see if the wallet has been used before, and if it has, it will return the amount stored in the wallet.  We think this final step is very important, because even though the chances are very very small you traditionally do not know if someone had used the same passphrase before.

Requirements

• Python
• Python Modules: os, sys, getopt, ecdsa, urllib2, binascii, hashlib
• libpcre3-dev (for the GET system command)

Installing

Download the sourcecode using git

git clone https://github.com/jgilmour/brainwallet-check.git

Usage

Usage of Brainwallet Check is pretty simple, just call the python script and pass it along the passphrase:

python brainwallet-check.py 'passphrase to use'

Examples

Basic run with no parameters:

root@techsmog:~/brainwallet-check# ./brainwallet-check.py
ERROR: Provide brainwallet string as parameter
./brainwallet-check.py 'Satoshi Nakamoto'

Basic run with a valid address, but nothing in the wallet:

root@techsmog:~/brainwallet-check# ./brainwallet-check.py  'Satoshi Nakamoto'
-----------------------------------------------------
brainwallet string: Satoshi Nakamoto
private key: a0dc65ffca799873cbea0ac274015b9526505daaaed385155425f7337704883e
bitcoin address: 1JryTePceSiWVpoNBU8SbwiT7J4ghzijzW
First seen according to blockchain.info: 1322885134
Wallet amount: 0
-----------------------------------------------------

Basic run with an address that hasn’t been used yet:

root@techsmog:~/brainwallet-check# ./brainwallet-check.py 'gimme da loot'
-----------------------------------------------------
brainwallet string: gimme da loot
private key: f7d3dc8e32903ea6052ad28c347d7e0f3139150676b0a0d8f59d37699249bac3
bitcoin address: 1AYmvzSbZrdhV5S39S2Ce1u3xBqAhJUYaG
[ADDRESS ISN'T IN USE ACCORDING TO BLOCKCHAIN.INFO]
-----------------------------------------------------

linux command line

System Management

• Restart the machine:

sudo reboot

• Shutdown the machine:

sudo halt

User Management:  How do I add a new user in Linux?

Without a home directory

sudo useradd myuser

With home directory

sudo useradd -m myuser

Then set the password

sudo passwd myuser

Then set the shell

sudo usermod -s /bin/bash myuser

Disk Management: How much disk space left on Linux machine?

• Checking for disk space on available volumes:

df -h command

Check for size of folders in current working directory:

du -h --max-depth=1

App Management: How do I install new software in Linux?

Install new software in Debian / Ubuntu Linux

sudo apt-get install <package>

Install new software in  Gentoo Linux

sudo emerge <package>

Install software from source

tar xvfz package.tar.gz
cd package
./configure
make
make install

Install rpm packages

rpm -ivh file.rpm

Filesystem: Basics

Create a directory in Linux

mkdir <Directory>

Remove a directory in Linux

rm -rf <Directory>

List files in directory

ls -l

Enter a directory

cd <Directory>

Up a directory

cd ..

Execute a program

./filename

Filesystem: How do I compress/decompress files?

Create .tar.gz / .tgz files:

tar -czvf {output.tgz} {folder}

Extract .tar.gz / .tgz files:

tar -xzvf {input.tgz} {path}

Create .zip files:

zip -r {output.zip} {folder}

Extract .zip files to directory:

unzip {input.zip} -d {folder}

Watch a log file real-time:

tail -f {file}

Find files containing text:

grep -Rl {search} {path}

Download a file from the internet:

wget {url}

Back up your stuff locally:

rsync {source} {destination}

Back up your stuff to another server:

rsync -avz -e ssh {path} {user}@{host}:{path}

File Permissions

Make a file executable:

chmod +x {filename}

Environment variables

Inspect the current PATH variables:

echo $PATH

Append directory to the existing

PATH: export PATH=$PATH:/path/to/binary

Declare a new environment variable:

export {variable}=/path/to/binary

Edit system-wide environment variables:

nano /etc/environment

Create an alias for a command:

nano ~/.bash_aliases followed by alias {alias name}='{command}'

Process Management

Kill a process:

kill {pid}

See all running processes:

ps aux

Get PIDs of running processes under a specific name:

ps aux | grep {name}

Anytime a process stops, start it

initctl upstart

Machine Properties

Modify the host name:

sudo nano /etc/hostname

Set a static IP address:

sudo nano /etc/network/interfaces

Modify hosts:

sudo nano /etc/hosts

Cron Jobs

Check existing cron jobs:

crontab -e

Networking

What IP adress is assiged to me?

ifconfig

What TCP/IP ports are open and what programs are listening on them?

lsof -i -P

(needs to have lsof installed and be run as root)

Where do I configure my network interfaces?

nano /etc/network/interfaces

then run ifdown <interface> and then ifup <interface>

What are the details of a specific network interface?

iwlist <interface> scan

Connect to a specific wireless network for a given interface?

iwconfig <interface> essid "<ssid name>"

Get an IP address assigned from a router?

dhclient <interface>

How do I list all NAT rules?

iptables -L

What are all of the available network devices for this machine?

lspci

Filesystem Management

View available files systems on your machine:

# cd /sbin
# ls mkfs*

Write a new file system to a device  (DANGEROUS!)

mkfs -t ext3 /dev/sda6

Check for bad blocks on a device

mke2fs -c /dev/sda6

Force creating a file system on a new device

mke2fs -F /dev/sda6

Set volume label

mke2fs -L DATA /dev/sda6

Partition Management

Manipulate partition table

fdisk

Manipulate partition table (gui)

sudo cfdisk /dev/sda

Show disk information, display attributes of a physical volume. This will output interesting information about your partitions.

sudo pvdisplay

Creates a volume group descriptor at the start of the /dev/hdb1 partition.

pvcreate /dev/hdb1

Resize logical volume

#You can extend a Logical Volume with:
sudo lvextend -L +5g foo/bar
#After extending the Logical Volume you need to expand the filesystem to use the new space.
sudo resize2fs /dev/foo/bar

Destroy partition table of your disk (VERY DANGEROUS)

# dd if=/dev/zero of=/dev/diskname bs=1k count=1
# blockdev --rereadpt /dev/diskname

computer networks: client-server (left) and peer-to-peer architecture (right)

Roles
Peers can have different roles in the bitcoin network.  A peer could deal with the blockchain, routing, mining or simply be a wallet service.  The peers that exist in the network today are:

• Wallet peers
• Mining peers
• Full blockchain peers
• Network routing peers

Wallets are “simple” peers which store value on the blockchain, examples include Electrum wallet or Blockchain.info. Mining peers compete to create new blocks on the largest dataset of the network: the blockchain.  The blockchain contains all transactions ever made on the bitcoin network.  Every block in the chain contains one to many transactions.

a bitcoin mining peer in the bitcoin network

A full blockchain peer is a a peer that does not do mining, but holds the latest copy of the blockchain. All of the nodes must communicate in some form of language, this language is the bitcoin protocol.

Protocol
The bitcoin protocol is defined by the behaviour of the peers in the network.  The protocol contains many different messages, just like a language would. One of the most basic messages is the ping message: it is sent primarily to confirm that the connection to the peer is still valid.  The full list of commands can be found in a reference client or here https://en.bitcoin.it/wiki/Protocol_specification

Growth
The network has grown rapidly since it was first introduced. The site https://getaddr.bitnodes.io/ estimates the number of peers in the network.  Only full blockchain peers are presented in the site,  practically the network could be much much larger.  A nice animation is shown at https://getaddr.bitnodes.io/nodes/1419014247/network-map/

bitcoin network peers, as shown by bitnodes.io

• explore blocks
• explore transactions
• explore addresses

Screenshot of bkchain

The script is minimalistic, I made it in 20 minutes, and like all software it could be improved. I think it is simple enough to change to your own wishes. It relies on https://bkchain.org/  to collect the data, but could be modified for any webserver that has an JSON API interface.  To see the list of API calls visit https://bkchain.org/static/api.txt Every function is basically dealing with JSON data, while on the bottom there are some calls to these functions.

# query the Liteocin, Peercoin, Namecoin, Bitcoin and Dogecoin blockchain using the bkchain.org API. 
# Full description of the API: https://bkchain.org/static/api.txt
# 
# Support:
# - explore blocks
# - explore transactions
# - explore addresses
#
# I've implemented a simple sample code in Python to explore these blockchains.
# Feel free to copy, redistribute, modify, push to github etc etc. 
#
# visit me @ talkera.org

import urllib2
import json
import numpy as np
import matplotlib.pyplot as plt
from pprint import pprint
 

def getBalance(currency, address): 
  response = urllib2.urlopen('https://bkchain.org/' + currency + '/api/v1/address/balance/' + address)
  data = response.read()
  data = json.loads(data)
  return data[0]['balance']

def getTransactionOut(currency, tx_hash):
  response = urllib2.urlopen('https://bkchain.org/' + currency + '/api/v1/tx/hash/' + tx_hash)
  data = response.read()
  data = json.loads(data)
  return data['out']

def getTransactionConfirmations(currency, tx_hash):
  response = urllib2.urlopen('https://bkchain.org/' + currency + '/api/v1/tx/hash/' + tx_hash)
  data = response.read()
  data = json.loads(data)
  return data['confirmations']

def getTransactionJSON(currency, tx_hash):
  response = urllib2.urlopen('https://bkchain.org/' + currency + '/api/v1/tx/hash/' + tx_hash)
  data = response.read()
  data = json.loads(data)
  return data

def getBlockJSON(currency, blk_index):
  response = urllib2.urlopen('https://bkchain.org/' + currency + '/api/v1/block/index/' + str(blk_index))
  data = response.read()
  data = json.loads(data)
  return data


print "------------------------------------------"
print "Namecoin : "
print "------------------------------------------"

print "Balance: ",
print getBalance('nmc','NDGh9jR3DYxKK9jYB4HdkzYE5HGaHiZnTd')

print "Tx out: ",
print getTransactionOut('nmc','bc5da2a8b64e8eda9045592bf77ef14f00c25f37cb4d063141660cc052dc2777')

print "Tx conf: ",
print getTransactionConfirmations('nmc','bc5da2a8b64e8eda9045592bf77ef14f00c25f37cb4d063141660cc052dc2777')

print "Tx JSON out: ",
print getTransactionJSON('nmc', 'bc5da2a8b64e8eda9045592bf77ef14f00c25f37cb4d063141660cc052dc2777')['out']

print "Block reward: ",
print getBlockJSON('nmc',0)['reward']

Save the script as coin.py and run:

python coin.py

This will output the data for those addresses and blocks. To change currency simply change ‘nmc’ to the blockchain you want.  The code does not have proper error checking yet. Have fun with it!

The primary difference from Bitcoin is that Namecoin offers the ability to store data within its blockchain. The original proposal called for inserting data into Bitcoin’s blockchain directly. The Namecoin codebase consists of the Bitcoin codebase with relatively minor changes (~400 lines) and addtional functionality built on top on it. The mining procedure is identical but the block chain is separate, thus creating the Namecoin block chain.

Unlike the Bitcoin block chain, the Namecoin block chain can be used to register any data type of data. Each record must follow the same rules (expire time, data size limit, etc). For storing large amounts of data it is better to use datacoin or filecoin.

Namecoin’s flagship is the top level domain .bit, which is functionally similar to .com or .net domains but functions using a decentralized database called the block chain.

If you do not have namecoin core wallet installed, you can do so by visiting http://namecoin.info/  or if you are on Linux, by using my earlier post: https://talkera.org/wpTalkera/installing-namecoin-in-linux/

First off, start the namecoin core wallet:

./namecoind -daemon

Make sure the amount of blocks, displayed as “blocks : ” is the same as the total blocks in the chain. To view the current amount, visit http://explorer.namecoin.info/stats/block_count.txt  You can now use namecoin in a new terminal tab.

Get a namecoin wallet address, to receive namecoins
To view your wallets type:

./namecoind listreceivedbyaddress 0 true

All your wallets will be displayed. If you do not have any wallet address, use this command:

./namecoind getnewaddress

This will generate a new namecoin address.   To see your address, type the previous command.   Below the surface a namecoin private key is generated which allows only you to move the namecoins.  To display your private key, type the command:

./namecoind dumpprivkey <your namecoin address>

It is important that nobody other than you has access to this private key. It is used to move namecoins.   Always keep a secret backup of your namecoin private key.

Show a namecoin block
Namecoin is based on a block chain. A blockchain is like a public ledger or database of all transactions.  All blocks in the blockchain are connected like a linked list. Each block contains a numer of transactions.  Make sure your blockchain is up-to-date, if it is note, you may not be able to display all the blocks!   To get a block type:

./namecoind getblockhash 110112

It will return a hash identifier. Using this returned hash identifier you can get the block information:

./namecoind getblock 7ca31026e4abb6a0cc852e6b1231c02e3d2afb3184fc498ea59ca6ba0e8e456d

The code behind the name is the hash of the block, or identifier. To clarify:

./namecoind getblock <block id>

You could try some with the hashes you find on http://explorer.namecoin.info/

The output of the command earlier is:

{
    "hash" : "7ca31026e4abb6a0cc852e6b1231c02e3d2afb3184fc498ea59ca6ba0e8e456d",
    "confirmations" : 99094,
    "size" : 1051,
    "height" : 110112,
    "version" : 65793,
    "merkleroot" : "8e8178deb876ea0955e5e27277a1275fe21e820b6f1df975aeb45e6047fbe7f2",
    "tx" : [
        "3e709a4be56663592d817d6586d68ca7265d9fcbda9c8558c04eac80aef59f89",
        "2ce1e55f4e5bf308a74c41a4e52f2444b964eb0f1e39a6c0ae28a7a8fdcbc8cd"
    ],
    "n_tx" : 2,
    "time" : 1368239997,
    "nonce" : 0,
    "bits" : 436690751,
    "difficulty" : 2275750.77475240,
    "chainwork" : "10ca9344a1b81fbd35",
    "previousblockhash" : "3d13cdea2545874df1e31dd08aed133aa2116e71fb9234daaf5ee5240e1e417f",
    "nextblockhash" : "890b1aa5d37520288f20a08d7c8c1b472243e6a5ba1aee26db9c055b42a89d78",
    "mrkl_tree" : [
        "3e709a4be56663592d817d6586d68ca7265d9fcbda9c8558c04eac80aef59f89",
        "2ce1e55f4e5bf308a74c41a4e52f2444b964eb0f1e39a6c0ae28a7a8fdcbc8cd",
        "8e8178deb876ea0955e5e27277a1275fe21e820b6f1df975aeb45e6047fbe7f2"
    ]
}

In this block there are two transactions, indicated by n_tx.  The transactions are:

• 3e709a4be56663592d817d6586d68ca7265d9fcbda9c8558c04eac80aef59f89
• 2ce1e55f4e5bf308a74c41a4e52f2444b964eb0f1e39a6c0ae28a7a8fdcbc8cd

It was created at 1368239997, this is the time encoded as unix timestamp format.   To convert Unix Timestamp to Date time on a Linux machine or Mac OS X type:

date -d @1368239997

Previoushash and nexthash should be obvious, they are the identifiers of the two directly connected blocks.

Show a transaction
To show a transaction, you need the transaction hash.  Let us take the transaction we found above: 3e709a4be56663592d817d6586d68ca7265d9fcbda9c8558c04eac80aef59f89

./namecoind getrawtransaction 3e709a4be56663592d817d6586d68ca7265d9fcbda9c8558c04eac80aef59f89 1

Notice the one (1) on the end of the line. Without that, the output is not in JSON. Thus the format is:

./namecoind getrawtransaction <txid> 1

Output is in this format:

{
    "hex" : "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e0320ae01094269744d696e746572ffffffff0120930d2a010000001976a9140ed30c10e724e2447b63cfdc122e5ac86f4cda4988ac00000000",
    "txid" : "3e709a4be56663592d817d6586d68ca7265d9fcbda9c8558c04eac80aef59f89",
    "version" : 1,
    "locktime" : 0,
    "blockhash" : "7ca31026e4abb6a0cc852e6b1231c02e3d2afb3184fc498ea59ca6ba0e8e456d",
    "confirmations" : 100005,
    "time" : 1368239997,
    "blocktime" : 1368239997,
    "vin" : [
        {
            "coinbase" : "0320ae01094269744d696e746572",
            "value" : 50.00000000,
            "sequence" : 4294967295
        }
    ],
    "vout" : [
        {
            "value" : 50.00500000,
            "n" : 0,
            "scriptPubKey" : {
                "asm" : "OP_DUP OP_HASH160 0ed30c10e724e2447b63cfdc122e5ac86f4cda49 OP_EQUALVERIFY OP_CHECKSIG",
                "hex" : "76a9140ed30c10e724e2447b63cfdc122e5ac86f4cda4988ac",
                "reqSigs" : 1,
                "type" : "pubkeyhash",
                "addresses" : [
                    "MwvkV9MZ9RxHYV2sBKA9fAHZByDwYYGph8"
                ]
            }
        }
    ],
    "fees" : -0.00500000
}

Sending namecoins NMC:
Type the command:

./namecoind sendtoaddress N9J2kUWET27WDLMYn3VsYY15FBHiiob6FG 1

This will send one (1) namecoin to my address.  Thus, the principle command is:

./namecoind sendtoaddress <wallet address>

Wallet balance:
There is no wallet balance in the namecoin protocol, just like there is no wallet balance in the original bitcoin protocol. There is are only unspent transaction outputs. This is how the protocol is designed. Wallets make this more user friendly by collecting all the unspent transaction ouptuts. This does not mean you cannot get the terminal to display your wallet balance.  Simply type:

links https://explorer.namecoin.info/a/N3VQL7mZvSNL1WWoiJUnNp9TkpREnY9YhJ

or:

links https://explorer.namecoin.info/a/WALLET ADDRESS

This will start a terminal webbrowser

Feel free to comment.

We took a small dataset of the early days. The blocks in our dataset were created in 2011.  Initially blocks would contain only one or two transactions per block. You may be wondering, why only one transaction per block?  These bitcoins (BTC) were all mined, creating the bitcoins that exist in the current bitcoin network today. Example of such block : https://blockchain.info/block-index/18997/0000000018685c7be119b5f0cc0ba0c0501883280eff81e5e6b1c479f0bca5db

From the block  119896 to 131011  we got these values:

• smallest block output:  50 BTC
• largest block output:  601449 BTC
• average block output: 2993

If BTC is a foreign concept to you, the largest block had a total output of $ 189.456.435   (at the current bitcoin price). While the smallest block contained 15.750 $. I myself did not believe there would be a block output of 601.449 BTC somewhere in those blocks so I looked it up.  This is the block that I found:  https://blockchain.info/block-index/140660/00000000000009755b65f42534a48d45bc2f43c7f98357d27aac1be9f7527c36

We have sorted them from the smallest total block output to the largest total block output and found this graph:

Total block output in BTC sorted from smallest to largest block output.

Most of the blocks contained less than 200 transactions in the early days, but you could see the growth in the number of transactions:

Total transactions per block, ordered from smallest to largest

Transactions and total output are not correlated per se; the largest block we found earlier  https://blockchain.info/block-index/140660/00000000000009755b65f42534a48d45bc2f43c7f98357d27aac1be9f7527c36  contained only 29transactions.

An example case: The Electrum wallet had relied on the Electrum server.  This server was not capable of large growth and they later changed to another centralized server called Stratum. Stratum is unmaintained and suffers from denial of service attaks. Some related threads:  https://bitcointalk.org/index.php?topic=271761.0  and  https://bitcointalk.org/index.php?topic=112413.0  Currently you can choose from a pool of servers. To visualise what we are talking about, upon installing Electrum wallet you get these messages:

electrum

If you press select server manually you get this cool list:

electrum2

While such a solution is semi-dedcentralized it is a workaround. One could argue it is a centralized solution because all Electrum wallet nodes use the Electrum server network.  The list of electrum server nodes contain only around 20-30 items.  All lightweight bitcoin clients currently use such a workaround, except Multibit.  Your bitcoins cannot be taken even if  the servers are down nor do you lose your ability to use bitcoins if they are down (you can import private keys in other wallets). Electrum is a great bitcoin wallet but  it would be better for the bitcoin community to have another solution for this problem.

How can this be resolved?
The current proposal is to resolve this within the bitcoin network itself. The bitcoin network is a peer-to-peer network and bitcoin nodes have an initial handhake. During this handshake a version packet is sent which contain a bitfield called services. This is how a node explains the network how they behave.  The proposal is to add two more services to the network :

• NODE_SERVICE (2)
• NODE_STRATIZED (4).

A node with the bitfield NODE_SERVICE  is a blockchain service node which supports the additional protocol messages “getoutputs” and “getspends”.  A stratized bitcoin node would not contain the entire blockchain and use the blockchain service node.  A stratized node would use four messages to discover the history of a Bitcoin address without needing direct access to the blockchain:

• getoutputs
• outputs
• getspend
• spend

A use case may be:

example

Conclusion:
Lightweight bitcoin wallets rely on a number of centralized bitcoin servers. To resolve this problem, the current proposal is to use the peer-to-peer bitcoin network itself by  adding new roles to nodes in the network.  A node may become a full blockchain service node or a stratized node.

Sources:

1. https://electrum.org
2. https://bitcointalk.org/index.php?topic=271761.0
3. https://bitcointalk.org/index.php?topic=112413.0
4. https://en.bitcoin.it/wiki/BIP_0033

tar xvfz bitcoin-0.9.3-linux.tar.gz 
cd bitcoin-0.9.3-linux/
cd bin
cd 32
./bitcoin-qt

By default is should include a bunch of blocks which will be written in $HOME/.bitcoin/  This is not the full blockchain, but enough to get started.

git clone https://github.com/jtauber/blockchain.git
cd blockchain
./blockchain.py /home/YOURUSERNAME/.bitcoin/blocks/blk00001.dat

This will output all transactions stored in this file. It will keep outputing until stopped, if you want you can interrupt it. Some output we got:

BLOCK 412 b'0000000000004d869a3f699f198aaff6e36f2bb605f7843aab8a6971873b9474'
  Transaction 0 b'4bad270fd17c858a04e8b05a6fdc2aafe6d7113f0b7a87d836bedeb49e8271d9'
    GENERATED ->
    0 50.0 -> public-key 14XhRXKxcuVL1ttcdHCYaA4h4Qpeio9ivE
  Transaction 1 b'92242e148975d18b0d2dbe65de9d880f9c0aca47365ec7a6e2a41564945f56b0'
    b'7df239133ec70547bf2207d8b250e9a115cbddcd6214dbcb173a79ce23eefe3d' 1 ->
    b'd6baddf7bfe8caa9ebbd3d0ec5fdd8dfcb276deb6addd4f9f3d40630867b117b' 1 ->
    0 1.32 -> address-type 1Kak3eYBiMqx7nuStdfXcoymw3VgQjgUAs

We look up the same transaction 4bad270fd17c858a04e8b05a6fdc2aafe6d7113f0b7a87d836bedeb49e8271d9  on blockchain.info (just for fun)  and see the address  14XhRXKxcuVL1ttcdHCYaA4h4Qpeio9ivE received 50 BTC.

transaction

The script (blockchain.py) is a straight forward and easy to understand python script. Notice that the .dat files contain multiple blocks from the blockchain. You can download the entire bitcoin blockchain (Currently around 22 GB) from the web by letting your client run or you can get it from http://gtf.org/garzik/bitcoin/bootstrap.dat.torrent  see also: https://bitcointalk.org/index.php?topic=145386.0

Namecoin (Symbol: ℕ or NMC) is a cryptocurrency and the first fork of the Bitcoin software. It is based on the code of Bitcoin, it uses the same proof-of-work algorithm and is limited to 21 million coins.

The primary difference from Bitcoin is that Namecoin offers the ability to store data within its blockchain. The original proposal called for inserting data into Bitcoin’s blockchain directly. The Namecoin codebase consists of the Bitcoin codebase with relatively minor changes (~400 lines) and addtional functionality built on top on it. The mining procedure is identical but the block chain is separate, thus creating the Namecoin block chain.

Unlike the Bitcoin block chain, the Namecoin block chain can be used to register any data type of data. Each record must follow the same rules (expire time, data size limit, etc). For storing large amounts of data it is better to use datacoin or filecoin.

Namecoin’s flagship is the top level domain .bit, which is functionally similar to .com or .net domains but functions using a decentralized database called the block chain.

Get the namecoin source code:

git clone https://github.com/namecoin/namecoin.git
cd namecoin
cd src
make
vim $HOME/.namecoin/namecoin.conf

Add these files to the config file

rpcuser=your_user
rpcpassword=your_pass
rpcport=8336

Execute the namecoin daemon using:

./namecoind -daemon

Namecoin is downloading the entire namecoin blockchain (which can take several hours), do not attempt any transactions until the blockchain has completed downloading. You can check progress by comparing the blockcount returned by getinfo against the explorer.namecoin.info blockcount. This will tell you the number of blocks currently in the namecoin blockchain.   Simply type:

./namecoind getinfo

If you want to sit back and relax type (wait until all blocks have completed downloading, may take a while):

watch ./namecoind getinfo

Some useful commands:

Create a new Namecoin address
namecoind getnewaddress

Start Namecoin daemon
namecoind

Show all available commands  
namecoind help

Show various information. The “blocks” value should match the current block count
namecoind getinfo

List your Namecoin address on which you can receive Namecoins  
namecoind listreceivedbyaddress 0 true

Transaction Lifecycle
The process starts with the creation of a transaction itself.  Secondly, the created transaction will be signed with one or more signatures. Think of signing as writing your unique autograph on the transaction. The transaction is broadcast into the bitcoin network.  Each node will validate this transaction and broadcast it to other nodes.   Finally, mining nodes will verify the transaction and embody it in a blockchain block. Let us illustrate this:

bitcoin transaction

What is a transaction?
You can think of a transaction like a cheque that is signed with a unique autograph. It will define from where to where the bitcoins should be moved.  They can only be moved if it has a valid signature. An example of such transaction can be seen here:  https://blockchain.info/rawtx/f291a31d8387cf3ac4db4d7330b090881c5d744a20825792d9940b595003c3ab

A transaction has one or more inputs and one or more outputs. For example, a company may want to have one input and several outputs to pay all the wages. This can be achieved in one bitcoin transaction.  A version number and unix timestamp are of course included.

For the programmers or mathematicians out there, you may remember the small python code to create a bitcoin transaction from this post:

def sendBTC(self,dst, amount):
	h = history(self.address)
	outs = [{'value': amount, 'address': dst}] 
	tx = mksend(h,outs, self.address, 10000)
	tx2 = sign(tx,0,self.priv)
	pushtx(tx2)

This code clearly demonstrates that the creation of a transaction and the signing of a transaction is executed on your machine.  The rest of the transaction lifecycle occurs in the bitcoin network.  If you cannot read code, don’t worry.

Bitcoin network and broadcasting
Traditionally a customer would ask the service for data. Imagine you (the client) visit a grocery store and ask the seller (the server) for a product. This network model is very old and the entire world wide web is based on it. This model is the client-server model and relies on a centralized authority (the webserver).

Now imagine a free market. You can ask any person around you for a product. In such a model, there is no centralized authority, except the authority that is written in the rules of the market.  Such a computer network is called a peer-to-peer network. The bitcoin network itself is a peer-to-peer network. Data in the bitcoin network is shared among peers.

computer networks

Transactions are broadcast to peers (or nodes) in the bitcoin network.   If it is valid, it is broadcast to other nodes.

Miner verification and inclusion in block
Some peers in the bitcoin network are known as miners. Transactions are verified by these miners.  Mining can be a profitable business:  Nearly all transactions in the bitcoin network include fees, which are given to miners. In addition, miners create new bitcoins in the bitcoin network.  Transactions are included into a bitcoin block.  A block is another piece of bytes and looks like this:  https://blockchain.info/rawblock/511748   (if you prefer the non-technical view see:  https://blockchain.info/block-index/511748 ).

Blockchain
Every block has a unique identifier (created by hashing algorithm called double SHA-256). Each block is linked to a previous block.  Every block has a previous block indicated with the variable prev_block.

blockchain

The total set of all connected blocks is called the block chain.  A block contains a set of transactions. The block chain contains all transactions ever done on the bitcoin block chain.

Interactive example: visit https://blockchain.info/block-index/511748  and keep pressing on Previous Block. You will notice you are visiting different blocks. Notice that all of the blocks are linked together, and each block (or in this case webpage) displays a set of transactions.

In-depth: Unspent transaction output
Unspent transaction output or UTXO is an essential component of a bitcoin transaction. If you receive bitcoins, this is recorded as UTXO on the bitcoin blockchain or bitcoin public ledger. This is a database shared by all peers on the network.  UTXO are indivisible chunks of bitcoin currency locked to a specific owner, these are expressed as Satoshi. Your total amount of bitcoins (UTXO) may be scattered  amongst many blocks on the blockchain.  Wallets create the illusions of an account by scanning the entire blockchain for your UTXOs, otherwise there is no account or balance in the bitcoin network itself.  Because only you have the private key, you are the only person who can move the UTXO to other bitcoin addresses.

Let us take a random bitcoin address and view their unspent transactions: https://blockchain.info/unspent?active=13R2zxMCqDSaCk85UxnLpe5ktzUGAEWJW9 
Observe this address (at the time of writing) has many unspent transactions outputs. We can now find out which blocks his BTC are in using this little python script I wrote:

# find unspent transaction outputs for bitcoin blockchain address
# talkera.org
import httplib2, re
import json

def txToBlock(hash):
  http = httplib2.Http()
  headers, body = http.request("https://blockchain.info/rawtx/" + hash)
  data = json.loads(body)
  return data['block_height']

# grab data
http = httplib2.Http()
headers, body = http.request("https://blockchain.info/unspent?active=13R2zxMCqDSaCk85UxnLpe5ktzUGAEWJW9")
data = json.loads(body)

# fetch transaction ids and use them to find block ids.
for d in data['unspent_outputs']:
#  print d['tx_hash_big_endian'] + " ",
  print str(txToBlock(d['tx_hash_big_endian'])) + " ",

#print txToBlock('93cfe9153474ccc9349f9effde55ebb6f7dfafcc4b2992b725d8c926732b168e')

Execute with:

python utxo.py

The program will output all blocks in the bitcoin blockchain that contain his satoshis (every number is a block height identifier). The program my take a while to finish, so be patient (or interrrupt it).

322263  322278  322278  322352  322373  322375  322379  322384  322444  322494  
322552  322566  322575  322582  322592  322604  322628  322668  322739  322779  
322796  322858  322930  322997  323034  323045  323085  323099  323116  323172  
323284  323333  323370  323377  323456  323516  323538  323543  323576  323648  
323657  323689  323717  323791  323793  323802  323807  323810  323906  323922  
323929  323996  324009  324010  324064  324088  324134  324135  324189  324205  
324232  324248  324289  324294  324302  324310  324316  324318  324360  324407  
324420  324421  324426  324433  324445  324448  324476  324479  324490  324540  
324545  324583  324587  324589  324600  324629  324632  324653  324659  324734
...

Yes, the bitcoins really are scattered all across the blockchain. Feel free to comment.

This mapping could be client-side, in the same way you create mapping between phone numbers and names in your phone, you could create a mapping between bitcoin addresses and name in a bitcoin wallet.

The Bitcoin developers want to solve the problem differently.  They have evaluated several options to create this mapping somewhere in different systems:

Encoding in the bitcoin address
One solution is to use the bitcoin blockchain as addressbook.  The idea is to use the first part of the bitcoin address as alias. Such type of addresses can be created with vanitygen, a tool that we discussed earlier in this blog.  The address 1Coffee7nryYgFGrT1x3SYaokb8r2ZwAsX could then be remembered as 1Coffee.   This solution, called first bits, has some problems.  The address you want to create is limited by computational power.  Another problem is scalability.

DNS TXT Records
A centralized system could be created which holds such mapping.  a Domain Name Server (DNS server) is such a system.  Traditionally they map domain name to ip address.   DNS systems are insecure and unsafe by design.  If such a system is used, one could take over someones bitcoin address by changing the mapping record.

Server Service
One could create a service which maps identity to a bitcoin addresses:

• User wishes to send to foo@bar.net
• Client uses DNS to find the IP address of bar.net: 123.123.123.123
• Client connects to port 123.123.123.123:4567 and requests the bitcoin address for the user foo
• Server responds with the address or error code and terminates the connection.
• Client sends the funds to the address

This system suffers from the same problems that the DNS TXT records have.

HTTPS Webservice
We could secure the connection between the user and the mapping server. Let us take for example, a person trying to send bitcoins to malvin@email.com
The identifier malvin could then be taken and used to query the server.

https://foo.org/bitcoin-alias/?handle=malvin

The server will then return the bitcoin address:

1BCXxkTqRxVYnwa5oh1rwLkmj448qfmPM3

Such kind of system could be created using a simple PHP script. This system is however, not secure, because the administrator of the system could modify one or more records and receive all the bitcoins.

btcserver

Namecoin blockchain
The current proposal is to use the Namecoin blockchain to create the mapping. Using a decentralised system, it becomes hard for an attacker to take the bitcoins. Namecoin offers the ability to store data within its blockchain.

Related: bips0015

Cryptographic_Hash_Function

The authors and implementation documentation for these hashing functions you can find here:  https://en.wikipedia.org/wiki/Comparison_of_cryptographic_hash_functions

Which Hash functions are inside the Bitcoin Protocol?
The Bitcoin protocol relies on SHA256 and RIPEMD-160 hashing functions.  You can find all their implementations in /bitcoin/src/crypto
A single SHA256 hash can be created using this small python script:

import hashlib
hash_object = hashlib.sha256(b'hello')
hex_dig = hash_object.hexdigest()
print(hex_dig)

Save is as hash.py and execute with:

> python hash.py
> 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824

Bitcoin uses a system of double hashing.  Let us take an double-SHA-256 encoding of string “hello”.

import hashlib

print hashlib.sha256(b'hello').digest().encode('hex_codec')
print hashlib.sha256(hashlib.sha256(b'hello').digest()).digest().encode('hex_codec')

This will output:

2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824 (first round of sha-256)
9595c9df90075148eb06860365df33584b75bff782a510c6cd4883a419833d50 (second round of sha-256)

Sometimes SHA256 is combined with RIPEMD160 hashing.  Take the following code and save it as hash2.py

import hashlib

print hashlib.sha256(b'hello').digest().encode('hex_codec')
print hashlib.new('ripemd160',hashlib.sha256(b'hello').digest()).digest().encode('hex_codec')

Then:

$ python hash2.py
$ 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824 (first round is sha-256)
$ b6a9c8c230722b7c748331a8b450f05566dc7d0f (with ripemd-160)

That looks a bit like a bitcoin address right?

Where is it used?

• Brainwallets
• Bitcoin addresses
• Block hashes
• Transactions
• Merkle trees
• Many other places

In depth:

Brainwallets
If you recall our previous post about building your own bitcoin wallet, we used an SHA-256 hashing function to hash the brainwallet password. This is quite common. You could double SHA-256 the brainwallet password or use another hashing function if you want.

Bitcoin addresses
A bitcoin address is in fact the hash of a ECDSA public key, computed this way:

Version = 1 byte of 0 (zero); on the test network, this is 1 byte of 111
Key hash = Version concatenated with RIPEMD-160(SHA-256(public key))
Checksum = 1st 4 bytes of SHA-256(SHA-256(Key hash))
Bitcoin Address = Base58Encode(Key hash concatenated with Checksum)

The Base58 encoding used is home made, and has some differences. Especially, leading zeroes are kept as single zeroes when conversion happens.

Block hashes
The SHA256 hash that identifies each block (and which must have a run of 0 bits) is calculated from the first 6 fields of this structure (version, prev_block, merkle_root, timestamp, bits, nonce, and standard SHA256 padding, making two 64-byte chunks in all) and not from the complete block. To calculate the hash, only two chunks need to be processed by the SHA256 algorithm. We implemented a python code that will calculate the hash of the block with the smallest hash as of June 2011, Block 125552.

The variables we will need are :

• version
• prev_block
• merkle_root
• timestamp
• bits
• nonce

If you open this address in blockexplorer  or blockchain.info  you find exactly this block.   Take these variables from the blockchain explorer. Then copy this code we wrote (be careful with the little endian function, it’s quick&dirty) and save it as block.py.  Execute with python block.py

# blockchain hash reconstructor
# talkera.org
import hashlib
import time
import datetime
from struct import *

def reverse(value):
 n = ""
 i = len(value)-1
 while i > 2:
 n = n + value[i-1]
 n = n + value[i]
 i = i - 2
 n = n + value[0]
 n = n + value[1]
 return n

def little_endian(value): 
 s = hex(value)[2:]
 s = s.replace("L","")
 return reverse(str(s))

prev_block = reverse("00000000000008a3a41b85b8b29ad444def299fee21793cd8b9e567eab02cd81")
mrkl_root = reverse("2b12fcf1b09288fcaff797d71e950e71ae42b91e8bdb2304758dfcffc2b620e3")
timestamp = little_endian(1305998791)
bits = little_endian(440711666)
nonce = little_endian(2504433986)

header_hex = ("01000000" +
 prev_block +
 mrkl_root +
 timestamp +
 bits +
 nonce )

header_bin = header_hex.decode('hex')
hash = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest()
print hash[::-1].encode('hex_codec')

This program will output:

00000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98bd1d

We can do this with any block of the blockchain. For example, let’s take block 511748.  This block was created on 13 december 2014. We put these variables into the program (variables from https://blockchain.info/rawblock/511748 ).  Notice the version has changed to 2 !  

Put it in the code as such:

# blockchain hash reconstructor
# talkera.org
import hashlib
import time
import datetime
from struct import *

def reverse(value):
  n = ""
  i = len(value)-1
  while i > 2:
    n = n + value[i-1]
    n = n + value[i]
    i = i - 2
  n = n + value[0]
  n = n + value[1]
  return n

def little_endian(value): 
  s = hex(value)[2:]
  s = s.replace("L","")
  return reverse(str(s))

prev_block = reverse("0000000000000000099a267bcff49a8be5ba6bff37b522420fda397c6db7b065")
mrkl_root = reverse("268d07f96fae264af0ec65d8e02580ad8ef0e4a0fe705633b3ea84ec47fdd06e")
timestamp = little_endian(1418484820)
bits = little_endian(404454260)
nonce = little_endian(3677959803)

header_hex = ("02000000" +
    prev_block +
    mrkl_root +
    timestamp +
    bits +
    nonce )

header_bin = header_hex.decode('hex')
hash = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest()
print hash[::-1].encode('hex_codec')

And execute to find the hash 000000000000000000f1fe83cdc4e356e7fe05318d9a806977cf1fa84112750d.  Exactly the same hash as on https://blockchain.info/block-index/511748   Observe how intertwined the blockchain hash is with the previous block variable, thus a new block cannot simply be inserted somewhere into the blockchain. And you just learned the block hashing algorithm

Transactions
A transaction is a section of data confirmed by a signature. It is sent to the Bitcoin network and blocks are formed based on them. Every transaction has one or more inputs.  Inputs encode a double SHA256 hash of the preceding transaction.

Merke trees
Merkle trees are binary trees of hashes. Merkle trees in bitcoin use a double SHA-256, the SHA-256 hash of the SHA-256 hash of something.

Concluding
The Bitcoin protocol heavily relies on double SHA-256 hashing and RIPEMD-160 hashing algorithms.  Hashes are used to encode previous transactions or blocks. We had an indepth look into the Block Hash Algorithm and implemented this algorithm in Python.  They are also used in every bitcoin address.  We hope you enjoyed our article

Please do not use in production yet. Testing welcome.

Andreas starts of with explaining us the traditional method for generating a bitcoin address:

The classic generation of a new bitcoin address requires basically 3 steps:

1. Generate a large 256-bit number from a (P)RNG (= private key)
2. Calculate the ECC public key for that number (= public key)
3. Do some hashing and encoding on the pubkey (= bitcoin address)

If the webserver gets hacked and the private keys are stored on it an attacker can steal all user funds.

Private keys had been stolen of webservers before. A large database of private keys on a single webserver is of course of major interest for attackers. Antonopoulos tells us:

“Based on the mathematical properties of ECC we can apply equivalent operations on a private key and its public key. The resulting keys will be a new corresponding keypair.  In pseudocode this is what happens:”

N = 42
privkey1, pubkey1 = generate_keypair()

privkey2 = privkey1 × N
pubkey2  = pubkey1 × N

assert(is_keypair(privkey2, pubkey2) == True)

” We apply the operation on the public key on the webserver to generate new bitcoin addresses no private key is needed. To spend the funds later, we derive the private for the address in a secure, offline environment.”

We grab the source code:

git clone https://github.com/aantonop/python-hdwallet.git
cd python-hdwallet
sudo python setup.py install

Now that we have the package installed, we can use it.  Antonopolous shared an example code:

from hdwallet import HDWallet

# 1. generate a master wallet with a (random) seed 
master = HDWallet.from_master_seed('HDWallet seed')
# 2. store the Private Extended Key somewhere very (!) safe
prv_master_key = master.to_extended_key(include_prv=True)
# 3. store the Public Extended Key on the webserver
pub_master_key = master.to_extended_key()


# 4. On the webserver we can generate child wallets
webserver_wallet = HDWallet.from_extended_key(pub_master_key)
child2342 = webserver_wallet.child(23).child(42)
print '- Public Extended Key (M):', pub_master_key
print 'Child: M/23/42'
print 'Address:', child2342.address()
print 'Privkey:', child2342.prvkey() # ... but the private keys remain *unknown*
print ''


# 5. In case we need the private key for a child wallet, start with the private master key
cold_wallet = HDWallet.from_extended_key(prv_master_key)
child2342 = cold_wallet.child(23).child(42)
print '- Private Extended Key (m):', prv_master_key
print 'Child: m/23/42'
print 'Address:', child2342.address()
print 'Privkey:', child2342.prvkey().encode('hex')

Execute with:

python andreas.py

Which outputs:

- Public Extended Key (M): xpub661MyMwAqRbcG7J3wr5XW6FEvDHbqUJrKGEXVUJMTuJWJqwV1rJWZPENd1jDkEdaGVs1RGMp5oWpJ89xTu2bkRSRSoxVpMzLG1ZXiYbBBgZ
Child: M/23/42
Address: 1PT7U5s9PTuXs1RK3ygoxFuAL59UjJZALV
Privkey: None

- Private Extended Key (m): xprv9s21ZrQH143K3dDaqpYX8xJWNBT7S1azx3Jvh5tjuZmXS3cLUJzG1autmmmeSFzRZF2GQm7Dr8f36saxwZGoHjhHb4u33FgkTi3cvjgFeFK
Child: m/23/42
Address: 1PT7U5s9PTuXs1RK3ygoxFuAL59UjJZALV
Privkey: 04c0ff8c288ce5f21f7f3e5e50db24e13c75d72e6815a448deb35568c6c8ed1f

(you do not need to verify those addresses, they do not contain any money ) 

Given the master wallets public key, the webserver can create child wallets. Each of those child wallets has a unique public key and private key.  Notice that the private key is never send to the webserver. To illustrate this, we will create a tiny example.  Save it as server.py :

from hdwallet import HDWallet

# 3. store the Public Extended Key on the webserver
pub_master_key = "xpub661MyMwAqRbcG7J3wr5XW6FEvDHbqUJrKGEXVUJMTuJWJqwV1rJWZPENd1jDkEdaGVs1RGMp5oWpJ89xTu2bkRSR$
webserver_wallet = HDWallet.from_extended_key(pub_master_key)
child2342 = webserver_wallet.child(23).child(42)
print '- Public Extended Key (M):', pub_master_key
print 'Child: M/23/42'
print 'Address:', child2342.address()
print 'Privkey:', child2342.prvkey() # ... but the private keys remain *unknown*
print ''

We did not implement the acutal HTTP server code because this is only an example. Notice that the output will be identical:

- Public Extended Key (M): xpub661MyMwAqRbcG7J3wr5XW6FEvDHbqUJrKGEXVUJMTuJWJqwV1rJWZPENd1jDkEdaGVs1RGMp5oWpJ89xTu2bkRSRSoxVpMzLG1ZXiYbBBgZ
Child: M/23/42
Address: 1PT7U5s9PTuXs1RK3ygoxFuAL59UjJZALV
Privkey: None

Schematically this is what happens:

hdwallet0

The client generates a master wallet consisting of a private masterkey and a public masterkey.

hdwallet1

The client tranmits its public masterkey to the server. The private key (used to control the bitcoins the master wallet holds) is never transmitted to the server. One can receive hundreds of bitcoins using this public masterkey, but to send it normally a private masterkey would have to be transmitted. This is a major security risk, and is not what will happen. Instead, the  public masterkey will be used to generate child wallets:

hdwallet2

Every child wallet has a unique keypair (public key, private key), just like a traditional bitcoin wallet. The webserver does not know this private key. A private key can be generated on client side for one or more child wallets. These child private keys never have to be transmitted to the webserver, the client controls the bitcoin master wallet and child wallets at all times.

Concluding:
Even though it is still experiment, HDWallet could increase the security of bitcoin webserver services by giving back control over the private keys to the customers. This could have a major impact on all bitcoin services such as exchanges, online wallets and shops because private keys do not have to be on a webserver at any point in time.

Pywallet Web Interface

git clone https://github.com/jackjack-jj/pywallet.git
cd pywallet

python pywallet.py --web

If you are a more advanced user, you can do the same thing fully in commandline:

python pywallet.py --dumpwallet /home/code/.bitcoin/wallet.dat > delete.txt

Open delete.txt with your favourite editor.  If you wallet is encrypted (to prevent theft), use:

python pywallet.py --passphrase=PASSPHRASE --dumpwallet /home/code/.bitcoin/wallet.dat > delete.txt

Remember, your private keys will be in delete.txt.  These keys control your bitcoins, so be sure to delete the file delete.txt from your disk once you are finished

Success cases:
https://bitcointalk.org/index.php?topic=34028.msg9281055#msg9281055

bitcointalk

Secret messages are stored inside the blockchain

# inspired by https://gist.githubusercontent.com/shirriff/64f48fa09a61b56ffcf9/raw/bitcoin-file-downloader.py

import sys
import os
import jsonrpc
import json
import struct
from binascii import crc32,hexlify,unhexlify
import urllib2
 
if len(sys.argv) != 2:
    print("Usage: %s <txhash>")
    sys.exit()
 
txid = sys.argv[1]
 
url = "https://blockexplorer.com/rawtx/" + txid
response = urllib2.urlopen(url)
data = response.read()
data = json.loads(data)

for d in data['out']:
  values = d['scriptPubKey'].split(' ')
  print unhexlify(values[2])

sudo pip install jsonrpc

python grab.py <transactionid>

python grab.py 8881a937a437ff6ce83be3a89d77ea88ee12315f37f7ef0dd3742c30eef92dba
python grab.py 59956e142df4113b44c80b029298fbe89a1f6d445019c449a9125eded1f6a84c
python grab.py da10564f43e2fc5697d5fd88ee76181749e43e6e11d89175d14dd12c9e596496
python grab.py 61df9fdb7ec4157c6e19a35dde07525cc4f725e07ef0411124ec1ce0b8e8355c
python grab.py ce5e6aabe78927febcc8b7a8662f48b03e2bcde239a8f537f29e2cd152940bcf

The Bitcointalk Simple Machines Forum (SMF)

git clone https://github.com/Storj/bitcointalkbot.git
cd bitcointalkbot
sudo pip3 install -r requirements.txt

KEYWORDS = ['Storj', 'Storj Labs', 'SJCX', 'Storjcoin X', 'Storjcoin']

KEYWORDS = ['Money']

python3 crawler.py

How it works?
The script downloads the RSS feed of the forum and parses it.  The rss feed url is https://bitcointalk.org/index.php?type=rss;action=.xml&limit=100

Coinkite Bitcoin API
The Coinkite Bitcoin API supports:

• View balances, transactions and search by transaction hash.
• Send funds, create vouchers, create new receive pubkeys.
• Drive your Coinkite terminal remotely.

A number of endpoints of the Coinkite API provide simple data sources for the public. They do not require authorization and may provide cached responses as appropriate.  For a lists of all endpoints that the API server supports visit: https://api.coinkite.com/public/endpoints

git clone https://github.com/coinkite/coinkite-python.git
cd coinkite-python/
cd ckapi
cd standalone
./ck-helper.py /v1/spot_quote/BTC/USD

The program will tell us

Please define CK_API_KEY and CK_API_SECRET in the environment

We visit https://coinkite.com/welcome  and register.  Finally we visit https://coinkite.com/merchant/api  and create an API key.  Upon generating we can set some permissions:

• Read any and all data
• Setup new receive funds
• Send funds out
• Transfer between accounts
• Control terminals
• Watches for events
• Manage subaccounts

We open a terminal and enter the commands:

export CK_API_KEY=**********************
export CK_API_SECRET=************************

Now we can fully control of the Coinkite API. We can enter the command

./ck-helper.py /v1/spot_quote/BTC/USD

and get valid output.   We can use this command with help of curl:

curl `./ck-helper.py /v1/spot_quote/BTC/EUR`

Output is JSON formatted data. In this particular case it returns the exchange range between BTC and EUR.

{
  "args": {
    "amount": 1,
    "from_cct": "EUR",
    "to_cct": "BTC"
  },
  "result": {
    "currency": "BTC",
    "decimal": 0.00350435,
    "integer": 350435,
    "integer_scale": 8,
    "pretty": "\u0e3f 0.00350435 BTC",
    "string": "0.00350435"
  }
}

Coinkite provides an interface to their API with Python, PHP, Javascript and Ruby.  They also have a number of sample programs including Paper OTP, Bitcoin ATM, Real Time Invoices, Offline Multisig Python Tool, Mobile Invoices and so on. A full list can be found here https://coinkite.com/apps.

Paper OTP
Manage a single-page PDF containing single-use numeric tokens. The tokens are generated using the RFC6238 algorithm with the X/Y coordinate as the interval number. The “secret” seed values used here are base32-encoded strings of length 16. 

git clone https://github.com/coinkite/paper_otp.git
cd paper_otp/
sudo pip install onetimepass
python paper_otp.py

This will output a matrix of 10×10 containing random numbers:

A      B      C      D      E      F      G      H      J      K   
  1  328482 812658 073348 887919 320986 435986 964213 267638 985814 003773 
  2  341298 818485 657398 091297 820368 525990 304831 129574 832989 409881 
  3  798492 850655 105215 146671 114047 066140 589368 295982 146532 971666 
  4  471360 691505 859474 350337 253438 330145 615787 717447 725274 976597 
  5  042840 650232 642231 831028 029268 908291 310196 270512 912692 418215 
  6  843686 446905 933720 022089 638885 094539 969405 444032 215562 879223 
  7  511481 356162 556820 882471 610006 959921 295130 053730 089011 347629 
  8  522689 856423 336498 070421 870043 720282 334467 729304 404019 369036 
  9  033452 014403 577183 454218 040169 589520 664233 442376 068681 280110 
  0  073717 856698 041115 201281 931625 914139 274147 682697 065067 383489

A file called test.pdf is generated in the background containing your OTP page.

traditional random number generator, worse or better number generator than the block chain? You decide.

od -An -N2 -i /dev/random

git clone https://github.com/kyonetca/blockchain-random
cd blockchain-random
sudo python setup.py install

import blockrandom

blockrandom.randbytes(5)
bytearray(b'\xff\xdcb\x9c\xee')

print blockrandom.randbool()

print blockrandom.randint(0, 100)

import blockrandom

blockrandom.randbytes(50)
bytearray(b'\xff\xdcb\x9c\xee')

#print ten random integers  
for i in range(0,10):
  print blockrandom.randint(0, 100)

How does it work? 
 Unconfirmed transaction hashes are queried from blockchain.info.  How well does this work? Well, here’s 1MB of truly random bytes from unconfirmed transactions:

transaction_bytes

If you would quiry the same data twice in a very very short timeframe, you could end up with the same numbers.

How secure is it?
Unconfirmed transaction hashes are queried from blockchain.info.  We can simply get a list of uncomfirmed-transactions from http://blockchain.info/unconfirmed-transactions?format=json  which is the data it uses. Even though blockchain.info supports Hypertext Transfer Protocol Secure (HTTPS), the software uses the common Hypertext Transfer Protocol (HTTP).  You can find the url inside blockrandom.py.  This makes it possible for a criminal to get your random numbers, not what you would use inside your banking software. Luckily that can be easily modified.  Simply change the top lines of blockrandom.py to:

import multiprocessing, Queue
from math_utils import murmur3_bytes, iterative_murmur3, murmur3_32, _rshift
from random import SystemRandom
from struct import unpack
from sys import stderr
from entropy_collector import HashCollectorDaemon

_queue = multiprocessing.Queue(5000)
_spare_queue = multiprocessing.Queue(5000)
_url = "https://blockchain.info/unconfirmed-transactions?format=json"
_sysrandom = SystemRandom() # only use in the most dire circumstances

We check all files using:

grep http *.py

Another thing to consider is that the software uses blockchain.info to get the data. This requires that your application is connected to the internet at all times. It also makes your application depend on the uptime of the blockchain.info webserver.  That said,  it could be modified to support a variety of blockchain explorer sites. I didn’t commit the changes to git repository of the developer, so you may want to do that

More information:  https://github.com/kyonetca/blockchain-random

More information:  https://www.bitcoinbook.info/

blockchain.info website

import urllib2
import json
import numpy as np
import matplotlib.pyplot as plt
from pprint import pprint


def showInfo(address):
  response = urllib2.urlopen('https://blockchain.info/address/' + address + '?format=json')
  data = response.read()

  val = []
  data = json.loads(data)

  print data['address']
  print data['total_received']
  print data['total_sent']

showInfo("1E6dum2sxdctc9hMV1Dk1xd8Vang3u9EA2")

python example.py

We then extend it to display information of a block:

import urllib2
import json
import numpy as np
import matplotlib.pyplot as plt
from pprint import pprint
 

def showInfo(address): 
  response = urllib2.urlopen('https://blockchain.info/address/' + address + '?format=json')
  data = response.read()

  val = []
  data = json.loads(data)

  print data['address']
  print data['total_received']
  print data['total_sent'] 

def showBlock(block):

  response = urllib2.urlopen('https://blockchain.info/rawblock/' + block + '?format=json')
  data = response.read()

  val = []
  data = json.loads(data)

  print '-----------------------------'
  print 'Block index: \t\t',
  print data['block_index']

  print 'Previous block:\t\t',
  print data['prev_block']

  print 'Time:\t\t\t',
  print data['time']
 
  print 'Nr. Transactions:\t',
  print data['n_tx']


  print '------------------------------'
showBlock('00000000000009fdb874661ff1c08f0a2d082aa788a5b90fbd428ce3622e121c')
#showInfo("1E6dum2sxdctc9hMV1Dk1xd8Vang3u9EA2")

This will output:

-----------------------------
Block index: 		169563
Previous block:		0000000000000753b0a49656f0105c317851f7c2b3945eea0c272499547af433
Time:			1322128192
Nr. Transactions:	27
------------------------------

If you want to see the Genisis block, the id is 000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f

Further reading: https://blockchain.info/api/blockchain_api

import json
import numpy as np
import matplotlib.pyplot as plt
from pprint import pprint


def getPrices(filename):
  val = []

  with open(filename) as data_file:
    data = json.load(data_file)

  for v in data["price_usd_data"]:
    print v[1]
    val.append(v[1])

  return val

btc = getPrices("bitcoin.json")
plt.plot(btc)
plt.show()

Simply get the JSON data http://coinmarketcap.com/static/generated_pages/currencies/datapoints/bitcoin-365d.json

You can plot multiple charts in one using this little trick:

btc = getPrices("bitcoin-365.json")
btc = getPrices("litecoin-365.json")
plt.plot(btc)
plt.plot(ltc)
plt.show()

The program outputs graphs like this:

litecoin vs darkcoin

If the market price data is too far apart, you will get strange plots.  Furthermore, you are not limited to this kind of plots

Currently supported exchanges are:

• Bitstamp (USD)
• Bitcoin24 (EUR)
• Paymium (USD, EUR)
• BTC-e (USD, EUR)
• Bitfinex (USD)
• Kraken (USD, EUR)
• OkCoin (CNY)
• CampBX (USD)

To install and run:

git clone https://github.com/maxme/bitcoin-arbitrage.git
cd bitcoin-arbitrage/
cp arbitrage/config.py-example arbitrage/config.py
python3 arbitrage.py 

It could give some errors, but nothing important.  The program will automatically output opportunities; At the time of running, we got these:

2014-12-06 17:52:39,729 [INFO] profit: 17.555133 USD with volume: 10.000000 BTC - buy from KrakenEUR sell to PaymiumEUR ~0.46%
2014-12-06 17:52:39,731 [INFO] profit: 0.511115 USD with volume: 4.195000 BTC - buy from KrakenEUR sell to BitfinexUSD ~0.03%
2014-12-06 17:52:49,831 [INFO] profit: 30.132266 USD with volume: 10.000000 BTC - buy from BtceUSD sell to KrakenEUR ~0.81%
2014-12-06 17:52:49,854 [INFO] profit: 70.126539 USD with volume: 10.000000 BTC - buy from BtceUSD sell to PaymiumEUR ~1.88%
2014-12-06 17:52:49,878 [INFO] profit: 6.898993 USD with volume: 10.000000 BTC - buy from BtceUSD sell to KrakenUSD ~0.19%
2014-12-06 17:52:50,245 [INFO] profit: 34.493657 USD with volume: 10.000000 BTC - buy from BtceUSD sell to BitstampUSD ~0.92%
2014-12-06 17:52:51,636 [INFO] profit: 53.063079 USD with volume: 10.000000 BTC - buy from BtceUSD sell to BitfinexUSD ~1.42%
2014-12-06 17:52:51,638 [INFO] profit: 26.339595 USD with volume: 10.000000 BTC - buy from BitstampUSD sell to PaymiumEUR ~0.70%
2014-12-06 17:52:51,643 [INFO] profit: 9.276136 USD with volume: 10.000000 BTC - buy from BitstampUSD sell to BitfinexUSD ~0.25%
2014-12-06 17:52:51,643 [INFO] profit: 9.831532 USD with volume: 10.000000 BTC - buy from BitfinexUSD sell to PaymiumEUR ~0.26%

Profits are anywhere between 0.50 $ and 70.00 $ with a trade volume of 10 BTC ( 3699.64 $ currently )

 
Coinkit script
Coinkit is a Python library with tools for Bitcoin and other cryptocurrencies. It is currently in Beta but it aims to support Bitcoin, Litecoin, Namecoin, Peercoin, Primecoin, Testnet, Worldcoin, Megacoin, Feathercoin, Terracoin, Novacoin, Dogecoin, Anoncoin, Protoshares, Ixcoin, Memorycoin, Infinitecoin, Cryptogenic Bullion, Quarkcoin, Netcoin, Earthcoin, Reddcoin,

sudo pip install coinkit

Open up your favourite text editor and paste this code:

from coinkit import *

priv = BitcoinPrivateKey()
bitcoin_pub = priv.public_key()
bitcoin_address = bitcoin_pub.address()

litecoin_priv = LitecoinPrivateKey(priv.to_hex())
litecoin_pub = litecoin_priv.public_key()
litecoin_address = litecoin_pub.address()

namecoin_priv = NamecoinPrivateKey(priv.to_hex())
namecoin_pub = namecoin_priv.public_key()
namecoin_address = namecoin_pub.address()

print ""
print "Receiving address"
print "bitcoin  : " + bitcoin_address
print "litecoin : " + litecoin_address
print "namecoin : " + namecoin_address

print ""
print "Private keys "
print "bitcoin  : " + priv.to_wif()
print "litecoin : " + litecoin_priv.to_wif()
print "namecoin : " + namecoin_priv.to_wif()
print ""

Save it as create.py and run

python create.py

The output should be something like this:

Receiving address
bitcoin  : 1AyPpKpsraPA2DVbne6atxB5ExC1k435ea
litecoin : LVCM5Y8hwEdDH2Bkxn5tAyEqTAZHp7FPzX
namecoin : N6Ym1yKrmxUiYkk74TRA7UKyyBb4djTozU

Private keys 
bitcoin  : ************************************
litecoin : ************************************
namecoin : ************************************

You can create a QR code for an address using this command:

qrencode YOUR_RECEIVAL_ADDRESS -o image.png

Vanitygen
Vanitygen can generate regular bitcoin addresses, namecoin addresses, and testnet addresses. Using some tricks we can generate other addresses too. Install vanitygen using:

# git clone https://github.com/samr7/vanitygen
# cd vanitygen
# make

Once compilation has finished, copy this script:

#!/bin/bash

echo "-----------------------------------"
echo "Bitcoin"
echo "-----------------------------------"
./vanitygen 1

echo "-----------------------------------"
echo "Namecoin"
echo "-----------------------------------"
./vanitygen -N NAME

echo "-----------------------------------"
echo "Litecoin"
echo "-----------------------------------"
./vanitygen -X 48 L

echo "-----------------------------------"
echo "Peercoin"
echo "-----------------------------------"
./vanitygen -X 55 PWn3d

echo "-----------------------------------"
echo "Dogecoin"
echo "-----------------------------------"
./vanitygen -X 30 DBone

Save it as create.sh, then:

chmod 755 create.sh
./create.sh

It will create a bitcoin, litecoin, peercoin, dogecoin and namecoin address with private key.

vanitygen

First grab the source code of Vanitygen from https://github.com/samr7/vanitygen either download the zip or use git. Then enter these commands:

unzip vanitygen-master.zip 
cd vanitygen-master/
make

This will compile the Vanitygen source code.  Once installed we can create a custom bitcoin address. All bitcoin addresses start with the number one. We enter this command:

./vanitygen 1Tux

After a second or so we get our bitcoin address:

Difficulty: 4553521
Pattern: 1Tux                                                                  
Address: 1TuxhRxTzHUfoHrZiUjUBLX4XUf8ANovn
Privkey: ------------------------------------

Another example:

$ ./vanitygen 1Love
Difficulty: 4476342
[48165 K/s][total 2080000][Prob 37.2%][50% in 21.2s]                           
Pattern: 1Love
Address: 1LoveRg5t2NCDLUZh6Q8ixv74M5YGVxXaN
Privkey: 5JLUmjZiirgziDmWmNprPsNx8DYwfecUNk1FQXmDPaoKB36fX1o

Now you have your custom bitcoin wallet.  You can import it to your desktop wallet or simply use it like this.

• create wallet
• check balance
• send transactions

The program will start by asking the user for a brainwallet password. From this password the public key, private key and address are generated.

from pybitcointools import *


class Wallet:

        priv = ""
        pub = ""
        address = ""

        def createWallet(self,brainwalletpassword):
                priv = sha256(brainwalletpassword)
                pub = privtopub(priv)
                address = pubtoaddr(pub)

                print "Address : " + address


x = Wallet()

password = raw_input("Your brain wallet password: ")
x.createWallet(password)

Now we will add the functionality to view the current balance. This is a simple function:

def balance(self):
                print unspent(self.address)

Simply call x.balance() to use it.  We did not send any btc to this wallet, which is what you need to do now to test the functionality of sending BTC. We make a small transaction to this bitcoin wallet and send a tiny amount to our brainwallet. We view blockchain.info to see we have received the transaction (type your address), and we wait until it is fully confirmed. Let us implement the code to send the BTC:

from pybitcointools import *


class Wallet:

	priv = ""
	pub = ""
	address = ""

	def createWallet(self,brainwalletpassword):
		self.priv = sha256(brainwalletpassword)
		self.pub = privtopub(self.priv)
		self.address = pubtoaddr(self.pub)

		print "Address : " + self.address

	def balance(self):
		print unspent(self.address)

	def sendBTC(self,dst, amount):
		h = history(self.address)
		#print h
		outs = [{'value': amount, 'address': dst}] 
		tx = mksend(h,outs, self.address, 10000)
		tx2 = sign(tx,0,self.priv)
		pushtx(tx2)

x = Wallet()

password = raw_input("Your brain wallet password: ")
x.createWallet(password)

x.balance()

x.sendBTC('1A1bBJwQMsbEbdyAnfe1ESvVAM3hmB6fSC', 20000)

(yes, we can send bitcoin in pure python). We added the function sendBTC which has the parameters destination address and amount (We hard-coded the fee).  Note that the bitcoin network only knows about the smallest unit (satoshi), and not about mBTC, kBTC, bits or BTC.    We hard-coded the fee to 10000.   We hardcoded 20000 as the amount of satoshi we sent.  In order to make a transaction, you must sign it with your private key. Finally we call pushtx which broadcasts the transaction to the bitcoin network.  Upon viewing your wallet again on any blockchain explorer  blockchain.info  you should see your (unconfirmed) transaction appearing.

Finding the transaction on blockchain.info

What’s next? You should do proper error handling, secure the wallet, create the ability for backups, create some form of a user interface, and the list goes on :). Pybitcointools relies on blockchain.info for sending bitcoins;

Are you a sysadmin, software developer, linux guru? Have you ever dreamt to build the worlds biggest bitcoin exchange? Do you want to create an online marketplace? This article will help you to get started with your exciting new bitcoin project!

Let us take some of the latest bitcoin software tools:

• zbar-tools
• pybitcointools
• python-trezor
• python-mnemonic
• bitcoin-bash tools

zbar-tools
ZBar is an open source software suite for reading bar codes from various sources.  QR codes are very popular amongst the bitcoin community. You can either compile zbar from source  (bzip2 -d zbar.tar.bz2; tar xvf zbar.tar; ./configure; make)  or right from the repository:

$ sudo apt-get install zbar-tools

Once installed we can get the text from a QR code using the command:

$ zbarimg qrcode.png

tip : try it with the image you created with qrencode in the previous tutorial

You can get the output in the XML format using:

$ zbarimg qrcode.png –xml

pybitcointools
An API that combines the power of Python and Bitcoin?  This sounds very promising.  We install using:

sudo pip install pybitcointools

Pybitcointools is not a full node, it has no idea what blocks are. It relies on centralized service (blockchain.info) for blockchain operations. This should not be a problem, but keep this in mind;

We write the first program, which simply fetches the account transaction history from the blockchain (through blockchain.info). Openup your favourite editor and paste:

from pybitcointools import *

addr = “1A1bBJwQMsbEbdyAnfe1ESvVAM3hmB6fSC”
h = history(addr)
print h

Save the file as example.py and execute it with

python example.py

The program will output the list of transactions for the bitcoin address 1A1bBJwQMsbEbdyAnfe1ESvVAM3hmB6fSC. Pretty neat, eh?

Now we will do some cool stuff with a brain wallet.  Open https://brainwallet.github.io/  and type a passphrase to generate an address. In my case I took a very weak password “hello world”. You will see the private key and public key being generated on the fly. Use this as a reference later on; We will create a program now which can generate the public and private key directly from this password. In addition, we will create the bitcoin address from the public key.

from pybitcointools import *

priv = sha256(‘hello world’)
pub = privtopub(priv)
address = pubtoaddr(pub)

print “Private key: ” + priv
print “Public key : ” + pub
print “Address : ” + address

This bitcoin address will obviously not have any transaction history. The complete list of commands can be found at: https://github.com/vbuterin/pybitcointools

python-trezor
Remember the hardware wallet Trezor we discussed? You can interact with it using python. Install using:

sudo apt-get install python-dev python-setuptools cython
git clone https://github.com/trezor/python-trezor.git
cd python-trezor
python setup.py install (or develop)

Then follow the instructions on https://github.com/trezor/python-trezor  and http://www.bitcointrezor.com/

python-mnemonic

This library  can be used for generating the mnenomic, and converting it into a binary seed. This seed can be later used to generate deterministic wallets using BIP-0032 or similar methods.
First install the python package pbkdf2, it is a dependency.

sudo pip install pbkdf2

Clone the python-mnemonic package using:

git clone https://github.com/trezor/python-mnemonic

You should have git installed. If not, install git. Next, enter these commands:

cd python-mnemonic/

python test_mnemonic.py

This will execute some tests, should work fine.  Remove vectors.json using

rm -r vectors.json

Run the example using

generate_vectors.py

The passphrase “TREZOR” is used for all vectors.  Read more on https://github.com/trezor/python-mnemonic

bitcoin-bash tools
First clone the package using the command

git clone https://github.com/grondilu/bitcoin-bash-tools

Let us do the next steps:

cd bitcoin-bash-tools/

vim test.sh

Paste this code

#!/bin/bash
source bitcoin.sh

newBitcoinKey

Then save it.  Run

chmod 755 test.sh

./test.sh

It will generate a secret key, public exponent and a bitcoin address. To see the complete list of commands open https://github.com/grondilu/bitcoin-bash-tools

• bitcoin native (very good, but wont be discussed here)
• qrencode
• sx

qrencode
The qrencode application is a tool to quickly produce qrcodes. Generating a QR code, a type of matrix barcode, for a bitcoin address from the command line :

$ sudo apt-get install qrencode
$ qrencode 125tQCeg89h8d3ccgBsipbjGUJpqx4c3H1 -o qrcode.png
$ display qrcode.png   (optional, display it)

This will output a QR code image of 111×111 pixels.  You can change the size of the dots, thus making the image larger using the -s command.

$ qrencode 125tQCeg89h8d3ccgBsipbjGUJpqx4c3H1 -s 6 -o qrcode.png
$ display qrencode.png

sx tools
sx is a set of modular Bitcoin commandline utilities. First clone libbitcoin from https://github.com/libbitcoin/libbitcoin#debianubuntu  and run

cd libbitcoin-version2
sudo install.sh

Installing command line tool sx :

wget https://github.com/spesmilo/sx/raw/master/install-sx.sh
sudo apt-get install bignum
sudo apt-get install sudo apt-get install libgmp-dev
chmod 755 install-sx.sh
sudo bash ./install-sx.sh

Installation will take a while, expect around 30 minutes installation time. It will download a lot of packages and compile them from source. This should work on latest versions of Debian Linux or Ubuntu Linux.

If that did not work try to download the packages into your /Downloads/ directory.

• libbitcoin 2.0
• libwallet 0.4
• Obelisk 1.0

Open a console and for each of the packages type

$ bzip2 -d filename.tar.bz2
$ tar xvf filename.tar
$ cd filename
$ autoreconf -i
$ ./configure
$ make
$ sudo make install
$ sudo ldconfig

( You might need sudo apt-get -f install libzmq-dev  and sudo apt-get install libcrypto* )

Finally download sx from  here:

• sx 1.0

Run the commands:

sh ./install-sx.sh

If you get an error about leveldb_blockchain, this error to be exact:

initchain.cpp:19:5: error: ‘leveldb_blockchain’ was not declared in this scope
leveldb_blockchain chain(pool);

Then add the line

#include <bitcoin/blockchain/leveldb_blockchain.hpp>

to the file src/initchain.cpp using your favourite editor such as vim.   . Then run make, sudo make install.

Now that you have sx tools installed you can use it to run all kind of bitcoin related commands.
Converting BTC to satoshi, and satoshi to BTC

$ sx btc 90000
0.00090000
$ sx satoshi 0.00090000
90000

Create an experimental wallet

sx newseed > wallet.seed
cat wallet.seed
sx wallet wallet.seed

 Convert from hexadecimal to base58

sx base58-encode CAFEBABE

See http://sx.dyne.org/  for a full list.

To be able to access a Ledger Wallet you will need: your Ledger Wallet, your PIN code and your second factor card. If one of these things is missing you won’t be able to spend bitcoin. Similar to the Ledger Wallet, Trezor has a PIN code. If the Trezor wallets gets stolen, thieves cannot misuse it.  In case of loss or theft of your Ledger Wallet, or at any time, you can restore your entire balance either on a new Ledger Wallet or on any BIP39 compatible software wallet such as Electrum. Without the PIN code and the second factor card, a thief cannot access your bitcoins.

Trezor uses a screen instead of a security card, which is of course easy for the end user. Trezor is a single-purpose computer, which stores your private keys and actively signs transactions without sending your private keys to the computer;  To run the Ledger Wallet you need a computer with an USB port, and a recent version of Google Chrome. The wallet interfaces with the computer through a Chrome application which you will need to install on your computer.  It currently does not have a screen but the Ledger Wallet will have a screen in the next version.  Both wallets are Windows, OS X and Linux friendly.  The Ledger Wallet development team is currently building support for Android;

 Read more:

• Trezor wallet:   http://www.bitcointrezor.com/
• Ledger wallet : https://www.ledgerwallet.com/