bitcoin-ruby 0.0.1

data/.gitignore

@@ -0,0 +1,12 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp
+.rvmrc
+*.DS_Store
+db/database.yml
+tmp/
+log/
+rdoc/
+coverage/

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2011 Julian Langschaedel <meta.rb@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in bitcoin-ruby.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,189 @@
+= Bitcoin-ruby
+
+This is a ruby library for interacting with the bitcoin protocol/network.
+
+Some of the main features are:
+
+* bitcoin utility functions for base58, ECC, etc. (Bitcoin::Util)
+* parse/create (almost?) all protocol messages (Bitcoin::Protocol)
+* connect to peers and exchange messages (Bitcoin::Network::Node, NODE)
+* load the blockchain from the network and stay in sync (WITHOUT verification yet!)
+* store and the blockchain and query for txouts (Bitcoin::Storage)
+* script implementation, create/run scripts and verify signatures (Bitcoin::Script)
+* create transactions (and even blocks!) (Bitcoin::Protocol, Bitcoin::Builder)
+* manage keys (Bitcoin::Key) in a wallet (Bitcoin::Wallet, WALLET)
+* there is even a highly experimental(!) Bitcoin::Gui
+
+== Installation
+
+We assume you already have a ruby 1.9 compatible interpreter and rubygems environment.
+
+ git clone https://github.com/lian/bitcoin-ruby.git; cd bitcoin-ruby
+ ruby -Ilib bin/bitcoin_node
+
+if you want to install it system-wide, just build the gem and install it
+
+ gem build bitcoin-ruby.gemspec && gem install bitcoin-ruby-0.0.1.gem
+
+now you can just call +bitcoin_node+ from anywhere.
+
+
+Note that some aspects of the library (such as networking, storage, etc.) need
+additional dependencies which are not specified in the gemspec. The core requirements are
+intentionally kept to a minimum, so nobody has to install unneeded dependencies.
+
+* +eventmachine+ to run a node / connect to peers
+* +sequel+, +sqlite3+/+pg+/+mysql+ to use a storage backend
+* +em-dns+ or +nslookup+ to get peer addrs from DNS seeds
+* +gir_ffi+ for the gui
+* +bacon+ to run the specs
+
+== Client
+
+There is a NODE which connects to the network and downloads
+the blockchain into a database. see Bitcoin::Network::Node.
+
+It also opens an extra socket for clients to connect where they can call certain
+methods, ask for information or register callbacks for events.
+see Bitcoin::Network::CommandClient.
+
+
+There is a WALLET implementation to manage a set of keys, list balances and create
+transactions. see Bitcoin::Wallet
+
+
+== Library Usage
+
+There are different aspects to the library which can be used separately or in combination.
+Here are some Ideas of what you could do. There are also some scripts which you can run,
+see EXAMPLES.
+
+
+=== Keys/Addresses
+
+Generate a Bitcoin::Key
+
+ key = Bitcoin::generate_key
+ key #=> [<privkey>, <pubkey>]
+
+Get the address from a public key
+
+ address = Bitcoin::pubkey_to_address(key[1])
+ address #=> <bitcoin address>
+
+Check if an address is valid
+
+ Bitcoin::valid_address?(address) #=> true
+
+
+=== Blocks / Transactions parsing
+
+Parse a Bitcoin::Protocol::Block
+
+ raw_block = File.open('spec/bitcoin/fixtures/rawblock-0.bin', 'rb') {|f| f.read}
+ blk = Bitcoin::Protocol::Block.new(raw_block)
+ blk.hash #=> 00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048
+ blk.tx.count #=> 1
+ blk.to_hash #=> ...
+ Bitcoin::Protocol::Block.from_json( blk.to_json )
+ 
+Parse a Bitcoin::Protocol::Tx
+
+ raw_tx = File.open('spec/bitcoin/fixtures/rawtx-01.bin', 'rb') {|f| f.read}
+ tx = Bitcoin::Protocol::Tx.new(raw_tx)
+ tx.hash #=> 6e9dd16625b62cfcd4bf02edb89ca1f5a8c30c4b1601507090fb28e59f2d02b4
+ tx.in.size #=> 1
+ tx.out.size #=> 2
+ tx.to_hash #=> ...
+ Bitcoin::Protocol::Tx.from_json( tx.to_json )
+ 
+ Bitcoin::Script.new(tx.out[0].pk_script).to_string
+ #=> "OP_DUP OP_HASH160 b2e21c1db922e3bdc529de7b38b4c401399e9afd OP_EQUALVERIFY OP_CHECKSIG"
+
+=== Transaction verification / Scripts
+
+Get the matching transactions (in this example tx1 is the spending transaction)
+
+ rawtx1 = File.open("spec/bitcoin/fixtures/rawtx-f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16.bin", 'rb') {|f| f.read}
+ rawtx2 = File.open("spec/bitcoin/fixtures/rawtx-0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9.bin", 'rb') {|f| f.read}
+ tx1 = Bitcoin::Protocol::Tx.new(rawtx1)
+ tx2 = Bitcoin::Protocol::Tx.new(rawtx2)
+
+Then simply ask the transaction to verify an input
+
+ tx1.verify_input_signature(0, tx2) #=> true
+
+=== Scripts
+
+If you want to control the Bitcoin::Script yourself, you can do so
+
+ txin = tx1.in.first
+ txout = tx2.out[txin.prev_out_index]
+ script = Bitcoin::Script.new(txin.script_sig + txout.pk_script)
+ 
+ result = script.run do |pubkey, sig, hash_type|
+   hash = tx1.signature_hash_for_input(0, nil, txout.pk_script)
+   Bitcoin.verify_signature(hash, sig, pubkey.unpack("H*")[0])
+ end
+ result #=> true
+
+=== Create Transactions
+
+TODO
+
+=== Node / Network connections
+
+The Bitcoin::Network::Node can connect to peers and download the blockchain into a
+Bitcoin::Storage backend. For now it works completely self-contained:
+
+ node = Bitcoin::Network::Node.new(options) # options = {:network => :bitcoin, ...}
+ node.run
+
+In the future you will be able to register callbacks to the node and control many aspects
+of its operation yourself. Also see NODE.
+
+If you want to implement your own node, see lib/bitcoin/connection.rb or
+lib/bitcoin/network/node.rb for examples.
+
+
+=== Storage / Database backends
+
+There is support for multiple database backends, but currently the only stable one is 
+the Bitcoin::Storage::Backends::SequelStore backend. All backends implement the interface
+defined in Bitcoin::Storage::Backends::StoreBase and return Bitcoin::Storage::Models.
+
+ store = Bitcoin::Storage.sequel(:db => "sqlite://bitcoin.db") # in-memory db
+ store.get_head #=> block
+ txouts = store.get_txouts_for_address("15yN7NPEpu82sHhB6TzCW5z5aXoamiKeGy")
+ txouts.first.value #=> 5000000000
+ txouts.first.type #=> :pubkey
+ txouts.first.get_address #=> "15yN7NPEpu82sHhB6TzCW5z5aXoamiKeGy"
+
+See Bitcoin::Storage::Backends::StoreBase, Bitcoin::Storage::Backends::SequelStore 
+and Bitcoin::Storage::Models for details.
+
+== Documentation
+
+Always trying to improve, any help appreciated! If anything is unclear to you, let us know!
+
+Documentation is generated using RDoc
+
+ rake rdoc
+
+The specs are also a good place to see how something works.
+
+== Specs
+
+The specs can be run with
+
+ rake bacon
+
+or, if you want to run a single spec
+
+ ruby spec/bitcoin/bitcoin_spec.rb
+
+If you make changes to the code or add functionality, please also add specs.
+
+== Development
+
+If you are curious or like to participate in development, drop by \#bitcoin-ruby on irc.freenode.net!

data/Rakefile

@@ -0,0 +1,104 @@
+begin
+  require 'bundler/gem_tasks'
+rescue LoadError
+end
+
+
+PROJECT_SPECS = ( FileList['spec/bitcoin/bitcoin_spec.rb'] +
+                  FileList['spec/bitcoin/protocol/*_spec.rb'] +
+                  FileList['spec/bitcoin/script/*_spec.rb'] +
+                  FileList['spec/bitcoin/wallet/*_spec.rb'] +
+                  FileList['spec/bitcoin/*_spec.rb'] ).uniq
+
+RUBY = 'ruby' unless defined?(RUBY)
+
+task :default => :bacon
+#
+# test runner
+#
+desc 'Run all bacon specs with pretty output'
+task :bacon do
+  require 'open3'
+  require 'scanf'
+  require 'matrix'
+
+  specs = PROJECT_SPECS
+  #specs.delete_if{|i| File.basename(i) == 'storage_spec.rb' } # skip for now
+
+  some_failed = false
+  specs_size = specs.size
+  len = specs.map{|s| s.size }.sort.last
+  total_tests = total_assertions = total_failures = total_errors = 0
+  totals = Vector[0, 0, 0, 0]
+
+  red, yellow, green = "\e[31m%s\e[0m", "\e[33m%s\e[0m", "\e[32m%s\e[0m"
+  left_format = "%4d/%d: %-#{len + 11}s"
+  spec_format = "%d specifications (%d requirements), %d failures, %d errors"
+
+  specs.each_with_index do |spec, idx|
+    print(left_format % [idx + 1, specs_size, spec])
+
+    Open3.popen3(RUBY, spec) do |sin, sout, serr|
+      out = sout.read.strip
+      err = serr.read.strip
+
+      # this is conventional, see spec/innate/state/fiber.rb for usage
+      if out =~ /^Bacon::Error: (needed .*)/
+        puts(yellow % ("%6s %s" % ['', $1]))
+      else
+        total = nil
+
+        out.each_line do |line|
+          scanned = line.scanf(spec_format)
+
+          next unless scanned.size == 4
+
+          total = Vector[*scanned]
+          break
+        end
+
+        if total
+          totals += total
+          tests, assertions, failures, errors = total_array = total.to_a
+
+          if tests > 0 && failures + errors == 0
+            puts((green % "%6d passed") % tests)
+          else
+            some_failed = true
+            puts(red % "       failed")
+            puts out unless out.empty?
+            puts err unless err.empty?
+          end
+        else
+          some_failed = true
+          puts(red % "       failed")
+          puts out unless out.empty?
+          puts err unless err.empty?
+        end
+      end
+    end
+  end
+
+  total_color = some_failed ? red : green
+  puts(total_color % (spec_format % totals.to_a))
+  exit 1 if some_failed
+end
+
+
+desc 'Generate RDoc documentation'
+task :rdoc do
+  `rm -rf rdoc`
+  system("rdoc -o rdoc -m README.rdoc examples/ doc/ lib/ README.rdoc COPYING")
+end
+
+
+desc 'Generate test coverage report'
+task :coverage do
+  begin
+    require 'simplecov'
+  rescue LoadError
+    puts "Simplecov not found. Run `gem install simplecov` to install it."
+    exit
+  end
+  system "bacon #{PROJECT_SPECS.join(' ')}"
+end

data/bin/bitcoin_dns_seed

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+
+require 'bitcoin'
+require 'socket'
+require 'json'
+require 'rubydns'
+require 'optparse'
+
+Bitcoin::Network::Node # autoload to include Array#weighted_sample
+
+DNS_OPTS = {
+  :name => nil,
+  :connect => "127.0.0.1:9999",
+  :port => 8333,
+  :cache => 1024,
+  :send => 16,
+  :interval => 10,
+  :ttl => nil,
+  :hosts => nil,
+}
+optparse = OptionParser.new do|opts|
+  opts.banner = "Usage: bitcoin_dns_seed [options] <domain>"
+
+  opts.on("-c", "--connect [HOST:PORT]",
+    "Connect to server (default: 127.0.0.1:9999)") do |connect|
+    DNS_OPTS[:connect] = connect
+  end
+
+  opts.on("-p", "--port [PORT]",
+    "Network default port each addr must match (default: 8333)") do |port|
+    DNS_OPTS[:port] = port.to_i
+  end
+
+  opts.on("-c", "--cache [SIZE]", "Cache addresses (default: 1024)") do |size|
+    DNS_OPTS[:cache] = size.to_i
+  end
+
+  opts.on("-s", "--send [SIZE]", "Send addresses (default: 16)") do |size|
+    DNS_OPTS[:send] = size.to_i
+  end
+
+  opts.on("-i", "--interval [SECONDS]", "Refresh addresses (default: 10)") do |s|
+    DNS_OPTS[:interval] = s.to_i
+  end
+
+  opts.on("-t", "--ttl [SECONDS]", "TTL to set on served records (default: relative to addr age)") do |t|
+    DNS_OPTS[:ttl] = t.to_i
+  end
+
+  opts.on("--hosts [HOSTS]", "Additional hosts file with name => addr mappings") do |h|
+    DNS_OPTS[:hosts] = h
+  end
+
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts opts
+    exit
+  end
+end
+optparse.parse!
+
+DNS_OPTS[:domain] = ARGV.shift
+unless DNS_OPTS[:domain]
+  puts optparse
+  exit
+end
+
+
+class RubyDNS::Server
+  attr_accessor :addrs
+end
+
+class AddrFetcher < EM::Connection
+  def initialize(dns)
+    @dns = dns
+    @dns.addrs ||= []
+    @buf = BufferedTokenizer.new("\x00")
+    send_data(["addrs", DNS_OPTS[:cache].to_s].to_json)
+  end
+
+  def receive_data(data)
+    @buf.extract(data).each do |packet|
+      json = JSON.load(packet)[1]
+      @dns.logger.info { "received #{json.size} new addrs" }
+      @dns.addrs += json.select{|a| a[1] == DNS_OPTS[:port]}
+      @dns.addrs.uniq! {|a| a[0]}
+      pop = @dns.addrs.size - DNS_OPTS[:cache]
+      @dns.addrs.pop(pop)  if pop > 0
+      @dns.logger.debug { "addr pool size now #{@dns.addrs.size}" }
+      close_connection
+    end
+  end
+
+  def self.run(host, port, dns, interval = 30)
+    EM.connect(host, port, self, dns)
+    EM.add_periodic_timer(interval) do
+      EM.connect(host, port, self, dns)
+    end
+  end
+end
+
+dns = RubyDNS::Server.new
+dns.match(DNS_OPTS[:domain], :A) do |transaction|
+  addrs = dns.addrs.weighted_sample(DNS_OPTS[:send]) {|addr| 10800 - addr[2] }.uniq
+  addrs.each do |addr|
+    begin
+      ttl = DNS_OPTS[:ttl] || ((10800 - addr[2]) / 30)
+      transaction.respond!(addr[0], :ttl => ttl)
+    rescue
+      # ignore faulty addrs ("localhost" etc)
+    end
+  end
+end
+
+if DNS_OPTS[:hosts]
+  dns.logger.info { "serving additional addrs from file" }
+  File.read(DNS_OPTS[:hosts]).each_line do |line|
+    dns.logger.debug { line.strip }
+    addr, *names = line.split(/\s+/)
+    names.each {|n| dns.match(n, :A) {|t| t.respond!(addr) } }
+  end
+end
+
+EM.run do
+  EventMachine.open_datagram_socket("0.0.0.0", 53, RubyDNS::UDPHandler, dns)
+  EventMachine.start_server("0.0.0.0", 53, RubyDNS::TCPHandler, dns)
+  dns.logger.info { "DNS Server listening on 0.0.0.0:53" }
+
+  timer = AddrFetcher.run(*DNS_OPTS[:connect].split(":"), dns, DNS_OPTS[:interval])
+end