bitcoin-ruby 0.0.1

data/bitcoin-ruby.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bitcoin/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bitcoin-ruby"
+  s.version     = Bitcoin::VERSION
+  s.authors     = ["lian"]
+  s.email       = ["meta.rb@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Gem for working with Bitcoin network}
+  s.description = %q{Gem for working with Bitcoin network}
+
+  s.rubyforge_project = "bitcoin-ruby"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.add_dependency "rake",        ">= 0.8.0"
+  s.add_dependency "eventmachine"
+
+  s.add_development_dependency "bacon"
+
+end

data/concept-examples/blockchain-pow.rb

@@ -0,0 +1,151 @@
+#
+# Ruby Example of the 'proof of work' explanation
+# from https://en.bitcoin.it/wiki/Proof_of_work
+#
+# note: block data passed to do_work is simplified.
+#       bitcoin blockchain is more complex too.
+#
+
+require 'digest/sha2'
+
+
+def do_work(data, target, nonce=0)
+  found = nil
+  while !found
+      d = data + [nonce].pack("I")
+      h = Digest::SHA256.hexdigest( Digest::SHA256.digest( d ) ).to_i(16)
+
+      if h <= target
+        found = [h.to_s(16).rjust(64, '0'), nonce]
+        break
+      end
+
+      nonce+=1
+  end
+  found
+end
+
+
+def next_block(blocks, target, data)
+  block_id    = blocks.size
+  last_block  = last_hash(blocks)
+  data        = last_block + " " + data
+
+  hash, nonce = nil, nil
+
+  work_time   = t{   hash, nonce = do_work(data, target.to_i(16))         }
+  verify_time = t{   hash, nonce = do_work(data, target.to_i(16), nonce)  }
+
+  print_block( block_id, target, data, nonce, hash, work_time, verify_time )
+
+  [ hash, nonce, target, data, work_time, verify_time ]
+end
+
+
+
+def print_block(*args)
+  puts <<-TEXT % args
+-------------------- block %s
+  target: %s
+   data: '%s' + %s (nonce)
+   found: %s
+
+  time:
+    took: %f
+  verify: %f
+
+  TEXT
+end
+
+def last_hash(blocks)
+  if blocks.empty?
+    "0000000000000000000000000000000000000000000000000000000000000000"
+  else
+    blocks.last[0]
+  end
+end
+
+def t; x = Time.now; yield; Time.now - x; end
+
+
+
+if $0 == __FILE__
+
+  target = "00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+  blocks = []
+
+
+  blocks << next_block( blocks, target, "hello ruby" )
+  blocks << next_block( blocks, target, "this is" )
+  blocks << next_block( blocks, target, "a blockchain" )
+  blocks << next_block( blocks, target, "and proof-of-work" )
+  blocks << next_block( blocks, target, "example!" )
+
+
+  puts <<-TEXT % [ blocks.size, target, blocks.inject(0){|e,i| e+=i[-2] }, blocks.inject(0){|e,i| e+=i[-1] } ]
+-------------------- blockchain time summary
+       chain length: %d
+         difficulty: %s
+    total work time: %f
+  total verify time: %f
+
+  TEXT
+
+end
+
+
+__END__
+% ruby concept-examples/blockchain-pow.rb
+
+-------------------- block 0
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '0000000000000000000000000000000000000000000000000000000000000000 hello ruby' + 1373297 (nonce)
+   found: 00000b1522d81f532d5e33c4fd22537b66f1ff052315b47000e61496510ceaa2
+
+  time:
+    took: 41.073509
+  verify: 0.000060
+
+-------------------- block 1
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '00000b1522d81f532d5e33c4fd22537b66f1ff052315b47000e61496510ceaa2 this is' + 2877742 (nonce)
+   found: 0000006f3ac527d921b57a88d3d6e5793f0813d4fafb17e0b31456ad1d652e05
+
+  time:
+    took: 86.098830
+  verify: 0.000058
+
+-------------------- block 2
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '0000006f3ac527d921b57a88d3d6e5793f0813d4fafb17e0b31456ad1d652e05 a blockchain' + 255946 (nonce)
+   found: 000000196f5e67ca66f281cf6b884b312984173651ddf12e151db6b1428a882b
+
+  time:
+    took: 7.648288
+  verify: 0.000057
+
+-------------------- block 3
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '000000196f5e67ca66f281cf6b884b312984173651ddf12e151db6b1428a882b and proof-of-work' + 2930300 (nonce)
+   found: 00000a197372b28e93479598afa504c92bcb50af2c5c6893686e91ce47ad0747
+
+  time:
+    took: 87.530473
+  verify: 0.000058
+
+-------------------- block 4
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '00000a197372b28e93479598afa504c92bcb50af2c5c6893686e91ce47ad0747 example!' + 85074 (nonce)
+   found: 00000a406be803d6a02c5aded00c159b664fe11ed768dbcb3ecb7b2ec6257706
+
+  time:
+    took: 2.555810
+  verify: 0.000058
+
+-------------------- blockchain time summary
+       chain length: 5
+         difficulty: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+    total work time: 224.906909
+  total verify time: 0.000292
+
+

data/doc/CONFIG.rdoc

@@ -0,0 +1,66 @@
+= Config
+
+All commands accept configuration, either via config file, or at the command line.
+
+== Locations
+
+There are 3 default locations where configfiles are loaded from:
+
+* +/etc/bitcoin-ruby.yml+
+* +~/.bitcoin-ruby.yml+
+* +./bitcoin-ruby.yml+
+
+Files are loaded in order (if they exist) and override each others settings.
+
+To specify a different config file use the +--config+ option.
+
+== Files
+
+Inside a config file, you can put options for the different commands, separated
+into categories.
+
+ all:
+   network: bitcoin
+   storage: sequel::postgres:/bitcoin
+   command: 127.0.0.1:1234
+ blockchain:
+   max:
+     connect: 30
+ wallet:
+   keystore: "simple::file=keys.json"
+
+Options in the +all+ category are loaded by every command, and are loaded first
+(so command-specific options will override them).
+
+Other categories are loaded by the corresponding command and may override options
+from the +all+ category (ie. +bitcoin_wallet+ loads +all+ and +wallet+).
+
+== Default Values
+
+ all:
+   network: bitcoin                       # network identifier ("bitcoin" or "testnet")
+   command: "127.0.0.1:9999"              # IP:Port to listen for incomming command connections
+   listen: "0.0.0.0:8332"                 # IP:Port to listen for incoming peer connections
+   connect: ""                            # List of IP:Port,IP:Port of nodes to connect to
+   storage: "sequel::sqlite://bitcoin.db" # storage backend to use (see STORAGE)
+ node:
+   headers_only: false                    # download/store only block headers (experimental)
+   dns: true                              # query peers from dns server
+   epoll: false
+   epoll_limit: 10000
+   epoll_user: nil
+   log:                                   # log levels (debug, info, warn, error, fatal)
+     network: info
+     storage: info
+   max:
+     connections: 32                      # number of peer connections
+     addr: 1024                           # peer-address store size
+     queue: 500                           # storage-queue size
+     inv: 500                             # inventory-queue size
+   intervals:
+     queue: 5                             # work storage queue
+     inv_queue: 5                         # work inventory queue
+     addrs: 15                            # collect new peer addrs
+     connect: 30                          # connect to new peers
+ wallet:
+   keystore: "simple::file=~/.bitcoin-ruby/keys.json" # keystore to use

data/doc/EXAMPLES.rdoc

@@ -0,0 +1,9 @@
+= Examples
+
+There are a few demo scripts in `examples/` that might give you an idea where to start.
+
+examples/connect.rb::       Connect to a network node and chat a little.
+examples/verify_tx.rb::     Fetch a transaction from local storage and verify signatures.
+examples/bbe_verify_tx.rb:: Fetch transaction from blockexplorer.com and verify signatures.
+examples/balance.rb::       Display balance/transactions for given address.
+examples/relay_tx.rb::      Relay transaction to the network.

data/doc/NODE.rdoc

@@ -0,0 +1,35 @@
+= NODE
+
+Bitcoin Node. Connects to the network and downloads the blockchain into local storage.
+
+== Usage
+
+To run the node with the default options (download the blockchain into ./bitcoin.db
+using the sequel::sqlite3 STORAGE backend):
+
+ bitcoin_node
+
+You can specify options (see +--help+) or pass a config file with +--config+ (see CONFIG).
+
+Some common options you might want to change:
+
+<tt>-n --network</tt> <i><name></i>::
+  +bitcoin+ or +testnet+ network
+<tt>--connect</tt> <i><ip:port></i>::
+  list of peers to connect to
+<tt>-s --storage</tt> <i><backend-string></i>::
+ storage backend to use (see STORAGE)
+
+It will take some time to download/store the entire blockchain at first, so be patient ;)
+
+
+== Command client
+
+The node opens a separate command socket which you can connect to and query statistics
+or get notified about new blocks/tx, etc.
+
+ bitcoin_node info  # general statistics
+
+ bitcoin_node help  # list all commands
+
+ bitcoin_node monitor block # wait for new blocks and output their hashes

data/doc/STORAGE.rdoc

@@ -0,0 +1,21 @@
+= Storage
+
+There is support for different storage backends, currently the `sequel` backend is the most stable and should work with `sqlite` and `postgres` databases. see Bitcoin::Storage
+
+== Backends
+
+For examples that require storage backends, you can specify them using
+a string containing the backend name and a configuration string.
+The default backend is +sequel::sqlite://bitcoin.db+ which is a sqlite database
+called +bitcoin.db+ in the current directory
+
+ sequel::sqlite:/ # in-memory
+ sequel::sqlite://bitcoin.db
+ sequel::sqlite:///tmp/bitcoin.db
+ sequel::postgres:/bitcoin
+ sequel::postgres://<user>:<pass>@<host>:<port>/<database>
+
+== Custom Backends
+
+To implement a custom backend you need to inherit from Bitcoin::Storage::Backends::StoreBase
+and implement the methods defined there.

data/doc/WALLET.rdoc

@@ -0,0 +1,102 @@
+= WALLET
+
+The wallet stores your keys/addresses, knows which transactions belong to them,
+can create transactions, etc.
+
+== Keystores
+
+A keystore is responsible for storing/accessing your keys/addresses.
+
+The +simple+ keystore (Bitcoin::Wallet::SimpleKeyStore) will create one key
+and put it into the given file. You can later ask it to generate more keys
+or add labels to the keys.
+
+The +deterministic+ keystore (Bitcoin::Wallet::KeyGenerator) uses the seed
+(which should be a large, unique, random string!) and generates the given number
+of keys. The nonce is optional, it just speeds up finding the first key.
+Note: Currently this keystore is not usable because it doesn't support labels yet.
+
+
+== Config
+
+To use the wallet you should create a configfile. It's not required but more convenient.
+See CONFIG for details.
+
+ wallet:
+   keystore: "simple::file=keys.json"
+   # keystore: "deterministic::seed=foo,nonce=2116,keys=7"
+
+
+== Usage
+
+Then you can list all addresses in the wallet:
+
+ bitcoin_wallet list
+
+Display transaction history for a specific address:
+
+ bitcoin_wallet list <address>
+
+Create new keys/addresses:
+
+ bitcoin_wallet new
+
+Import keys from base58 format:
+
+ bitcoin_wallet import <base58>
+
+Export keys to base58 format:
+
+ bitcoin_wallet export <address>
+
+== Transactions
+
+Transactions consist of multiple inputs and outputs. Inputs are selected
+automatically, and you can define outputs of different types.
+Each output has a +value+ (specified in base units/"satoshis"), and script represented by
+the script type (see below) and one or more recipients (addresses or public keys).
+
+Outputs can be specified as a combination of type, recipient(s) and value.
+
+ bitcoin_wallet send <type>:<recipients>:<value> [<fee>]
+
+This will create and sign a transaction and display it, asking for confirmation.
+If you accept, it will be sent to your node and relayed to the rest of the network.
+
+
+There are different script types:
+
+
+=== Address
+
+Specify address/hash160 of the public key needed to spend the output again.
+This is the most commonly used transaction type at the moment.
+
+ bitcoin_wallet send address:1GQkkFvAFW2ts3YLnEvMnu76WyCB6yDb4d:0.1 0.005
+
+
+=== Pubkey
+
+Specify public key needed to spend the output.
+Somewhat deprecated (because of the higher long-term storage requirements compared
+to address-transactions).
+
+ bitcoin_wallet send pubkey:<pubkey in hex>:1.0 0.005
+
+
+=== Multisig
+
+Specify multiple addresses needed to spend the output.
+
+ bitcoin_wallet send <type>:<m>:<key>:<key>:<amount> [<fee>]
+ bitcoin_wallet send multisig:1:1GQkkFvAFW2ts3YLnEvMnu76WyCB6yDb4d:1C5uWeXorS46ZubciCLN4zyR7sAqeNJfLD:1.0 0.005
+
+You can give up to 3 addresses/keys and +m+ specifies how many of them are required to spend
+the output.
+
+Note: Currently you need to have all keys in the same wallet for this to work.
+
+
+=== P2SH
+
+# TODO

data/examples/balance.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# 
+# Collect all unspent outputs for given address and display balance.
+# Optionally display list of transactions.
+# 
+#  examples/balance.rb <address> [--list]
+#  examples/balance.rb 1Q2TWHE3GMdB6BZKafqwxXtWAWgFt5Jvm3
+
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+require 'bitcoin'
+
+Bitcoin.network = :bitcoin
+store = Bitcoin::Storage.sequel(:db => "sqlite://bitcoin.db")
+
+address = ARGV.shift
+
+unless Bitcoin.valid_address?(address)
+  puts "Address #{address} is invalid."
+  exit 1
+end
+
+
+# format value to be displayed
+def str_val(val, pre = "")
+  ("#{pre}#{"%.8f" % (val / 1e8)}").rjust(20)
+end
+
+if ARGV[0] == "--list"
+  txouts = store.get_txouts_for_address(address)
+  unless txouts.any?
+    puts "Address not seen."
+    exit
+  end
+
+  total = 0
+  txouts.each do |txout|
+    tx = txout.get_tx
+    total += txout.value
+    puts "#{tx.hash} |#{str_val(txout.value, '+ ')}  |=> #{str_val(total)}"
+
+    txout.get_tx.in.map(&:get_prev_out).each do |prev_out|
+      puts "  from #{prev_out.get_addresses.join(", ")}"
+    end
+    puts
+
+    if txin = txout.get_next_in
+      tx = txin.get_tx
+      total -= txout.value
+      puts "#{tx.hash} |#{str_val(txout.value, '- ')}  |=> #{str_val(total)}"
+      txin.get_tx.out.each do |out|
+        puts "  to #{out.get_addresses.join(", ")}"
+      end
+      puts
+    end
+  end
+end
+
+hash160 = Bitcoin.hash160_from_address(address)
+balance = store.get_balance(hash160)
+puts "Balance: %.8f" % (balance / 1e8)