bitcoin-ruby 0.0.1

data/bin/bitcoin_gui

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+
+require 'bitcoin'
+require 'optparse'
+
+Bitcoin.require_dependency 'ffi-gtk3', gem: "gir_ffi"
+Bitcoin.require_dependency :eventmachine
+Bitcoin.require_dependency :notify
+Bitcoin.require_dependency :json
+
+
+defaults = {
+  :network => "bitcoin",
+  :storage => "dummy",
+  :keystore => "simple::file=~/.bitcoin-ruby/keys.json",
+  :command => "127.0.0.1:9999"
+}
+options = Bitcoin::Config.load(defaults, :wallet)
+
+optparse = OptionParser.new do |opts|
+  opts.banner =
+    "Usage: bitcoin_wallet [options] <command> [<command options>]\n"
+
+  opts.separator("\nAvailable options:\n")
+
+  opts.on("-c", "--config FILE",
+    "Config file (default: #{Bitcoin::Config::CONFIG_PATHS})") do |file|
+    options = Bitcoin::Config.load_file(options, file, :wallet)
+  end
+
+  opts.on("-n", "--network NETWORK",
+    "User Network (default: #{options[:network]})") do |network|
+    options[:network] = network
+  end
+
+  opts.on("-s", "--storage BACKEND::CONFIG",
+    "Use storage backend (default: #{options[:storage]})") do |storage|
+    options[:storage] = storage
+  end
+
+  opts.on("--command [HOST:PORT]",
+    "Node command socket (default: #{options[:command]})") do |command|
+    options[:command] = command
+  end
+
+  opts.on("-k", "--keystore [backend::<config>]",
+    "Key store (default: #{options[:store]})") do |store|
+    options[:keystore] = store
+  end
+
+  opts.on("-h", "--help", "Display this help") do
+    puts opts; exit
+  end
+
+  opts.separator "\nAvailable commands:\n" +
+    " balance [<addr>] - display balance for given addr or whole wallet\n" +
+    " list <addr> - list transaction history for address\n" +
+    " send <addr>:<amount>[,<addr>:<amount>...] [<fee>] - send transaction\n" +
+    " new - generate new key and add to keystore\n" +
+    " import <base58> - import key in base58 format\n" +
+    " export <addr> - export key to base58 format\n"
+
+end
+
+optparse.parse!
+
+Bitcoin.network = options[:network]
+
+backend, config = options[:storage].split("::")
+@storage = Bitcoin::Storage.send(backend, :db => config)
+
+backend, config = options[:keystore].split("::")
+config = Hash[config.split(",").map{|c| c.split("=")}]
+
+EM.run do
+  @gui = Bitcoin::Gui::Gui.new(@storage, config['file'])
+  Bitcoin::Gui::Connection.new(*options[:command].split(":"), @gui)
+  EM.gtk_main
+end

data/bin/bitcoin_node

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+
+require 'bitcoin'
+require 'optparse'
+Bitcoin.require_dependency :eventmachine
+Bitcoin.require_dependency :json
+
+defaults = {
+  :network => "bitcoin",
+  :command => "127.0.0.1:9999",
+  :listen => "0.0.0.0:8332",
+  :connect => "",
+  :storage => "sequel::sqlite://bitcoin.db",
+  :headers_only => false,
+  :dns => true,
+  :epoll => false,
+  :epoll_limit => 10000,
+  :epoll_user => nil,
+  :log => {
+    :network => :info,
+    :storage => :info,
+  },
+  :max => {
+    :connections => 32,
+    :addr => 1024,
+    :queue => 500,
+    :inv => 500,
+  },
+  :intervals => {
+    :queue => 5,
+    :inv_queue => 5,
+    :addrs => 15,
+    :connect => 30,
+  },
+  :daemon => false,
+}
+
+options = Bitcoin::Config.load(defaults, :blockchain)
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: bitcoin_node [options]"
+
+  opts.separator("\nAvailable options:\n")
+
+  opts.on("-c", "--config FILE",
+    "Config file (default: #{Bitcoin::Config::CONFIG_PATHS})") do |file|
+    options = Bitcoin::Config.load_file(options, file, :blockchain)
+  end
+
+  opts.on("-n", "--network [NETWORK]",
+    "User Network (default: #{options[:network]})") do |network|
+    options[:network] = network
+  end
+
+  opts.on("--command [HOST:PORT]",
+    "Command socket (default: #{options[:command]})") do |command|
+    options[:command] = command
+  end
+
+  opts.on("-l", "--listen [HOST:PORT]",
+    "Listen address/port (default: #{options[:listen]})") do |listen|
+    options[:listen] = listen
+  end
+
+  opts.on("--connect [HOST:PORT[,HOST:PORT[...]]]",
+    "Hosts to connect to (default: #{options[:connect]})") do |connect|
+    options[:connect] = connect
+  end
+
+  opts.on("-s", "--storage [BACKEND::CONFIG]",
+    "Use storage backend (default: #{options[:storage]})") do |storage|
+    options[:storage] = storage
+  end
+
+  opts.on("--ho", "--headers-only",
+    "Download only block headers") do
+    options[:headers_only] = true
+  end
+
+  opts.on("-d", "--dns", "Use DNS seeds (default)") do
+    options[:dns] = true
+  end
+
+  opts.on("--nd", "--no-dns", "Don't use DNS seeds") do
+    options[:dns] = false
+  end
+
+  opts.on("--epoll", "Enable epoll support") do
+    options[:epoll] = true
+  end
+
+  opts.on("--epoll-limit [NUM]",
+    "Increase socket descriptor limit to NUM") do |num|
+    options[:epoll_limit] = num.to_i
+  end
+
+  opts.on("--epoll-user [NAME]",
+    "Set effective user after increasing socket descriptor limit") do |user|
+    options[:epoll_user] = user
+  end
+
+  [:connections, :addr, :queue, :inv].each do |name|
+    opts.on("--m#{name.to_s[0]}", "--max-#{name} [COUNT]",
+      "Max #{name} (default: #{options[:max][name]})") do |count|
+      options[:max][name] = count.to_i
+    end
+  end
+
+  [:queue, :inv_queue, :blocks, :addrs, :connect].each do |name|
+    opts.on("--i#{name.to_s[0]}", "--interval-#{name} [SECONDS]",
+      "Interval for #{name} worker (default: #{options[:intervals][name]})") do |sec|
+      options[:intervals][name] = sec.to_i
+    end
+  end
+
+  [:network, :storage].each do |name|
+    opts.on("--l#{name.to_s[0]}", "--log-#{name} [LEVEL]",
+      "Log level for #{name} (default: #{options[:log][name]})") do |level|
+      options[:log][name] = level.to_sym
+    end
+  end
+
+  opts.on("-v", "--verbose", "Set all loggers to debug") do
+    options[:log].each_key {|k| options[:log][k] = :debug }
+  end
+
+  opts.on("-q", "--quiet", "Set all loggers to warn") do
+    options[:log].each_key {|k| options[:log][k] = :warn }
+  end
+
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts opts; exit
+  end
+end
+
+optparse.parse!
+
+Bitcoin.network = options[:network]
+options[:command] = options[:command] == "" ? nil : options[:command].split(':')
+options[:listen] = options[:listen] == "" ? nil : options[:listen].split(':')
+options[:connect] = options[:connect] == "" ? [] : options[:connect].split(',').map{|h| h.split(':')}
+
+if ARGV.any?
+  EM.run do
+    Bitcoin::Network::CommandClient.connect(*options[:command]) do
+      on_response do |cmd, data|
+        unless cmd == "monitor"
+          puts JSON.pretty_generate data
+          EM.stop
+        end
+      end
+      on_block do |block, depth|
+        puts "block: #{block['hash']} (#{depth})"
+      end
+      on_tx do |tx|
+        puts "tx: #{tx['hash']}"
+      end
+      on_connection do |type, host|
+        if type == "connected"
+          puts "Connected: #{host['host']}:#{host['port']}"
+        else
+          puts "Disconnected: #{host.inspect}"
+        end
+      end
+      on_connected do
+        request(ARGV[0], *(ARGV[1] || "").split(" "))
+      end
+    end
+  end
+else
+  node = Bitcoin::Network::Node.new(options)
+  node.run
+end

data/bin/bitcoin_shell

@@ -0,0 +1,12 @@
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+require 'bitcoin'
+
+include Bitcoin
+include Bitcoin::Util
+include Bitcoin::Storage
+
+Bitcoin.network = ARGV.shift || :bitcoin
+
+require 'irb'
+require 'irb/completion'
+IRB.start

data/bin/bitcoin_wallet

@@ -0,0 +1,323 @@
+#!/usr/bin/env ruby
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+
+require 'bitcoin'
+require 'eventmachine'
+require 'optparse'
+require 'yaml'
+
+defaults = {
+  :network => "testnet",
+  :storage => "dummy",
+  :keystore => "simple::file=#{ENV['HOME']}/.bitcoin-ruby/keys.json",
+  :command => "127.0.0.1:9999"
+}
+options = Bitcoin::Config.load(defaults, :wallet)
+
+optparse = OptionParser.new do |opts|
+  opts.banner =
+    "Usage: bitcoin_wallet [options] <command> [<command options>]\n"
+
+  opts.separator("\nAvailable options:\n")
+
+  opts.on("-c", "--config FILE",
+    "Config file (default: #{Bitcoin::Config::CONFIG_PATHS})") do |file|
+    options = Bitcoin::Config.load_file(options, file, :wallet)
+  end
+
+  opts.on("-n", "--network NETWORK",
+    "User Network (default: #{options[:network]})") do |network|
+    options[:network] = network
+  end
+
+  opts.on("-s", "--storage BACKEND::CONFIG",
+    "Use storage backend (default: #{options[:storage]})") do |storage|
+    options[:storage] = storage
+  end
+
+  opts.on("--command [HOST:PORT]",
+    "Node command socket (default: #{options[:command]})") do |command|
+    options[:command] = command
+  end
+
+  opts.on("-k", "--keystore [backend::<config>]",
+    "Key store (default: #{options[:store]})") do |store|
+    options[:keystore] = store.gsub("~", ENV['HOME'])
+  end
+
+  opts.on("-h", "--help", "Display this help") do
+    puts opts; exit
+  end
+
+  opts.separator "\nAvailable commands:\n" +
+    " balance [<addr>] - display balance for given addr or whole wallet\n" +
+    " list <addr> - list transaction history for address\n" +
+    " send <addr>:<amount>[,<addr>:<amount>...] [<fee>] - send transaction\n" +
+    " new - generate new key and add to keystore\n" +
+    " import <base58> - import key in base58 format\n" +
+    " export <addr> - export key to base58 format\n"
+
+end
+
+optparse.parse!
+
+cmd = ARGV.shift; cmdopts = ARGV
+unless cmd
+  exit puts optparse
+end
+
+Bitcoin.network = options[:network]
+backend, config = options[:keystore].split("::")
+config = Hash[config.split(",").map{|c| c.split("=")}]
+keystore = Bitcoin::Wallet.const_get("#{backend.capitalize}KeyStore").new(config)
+if backend == "deterministic" && !config["nonce"]
+  puts "nonce: #{keystore.generator.nonce}"
+end
+#puts *keystore.get_keys.map(&:addr)
+backend, config = options[:storage].split("::")
+storage = Bitcoin::Storage.send(backend, :db => config)
+
+
+wallet = Bitcoin::Wallet::Wallet.new(storage, keystore, Bitcoin::Wallet::SimpleCoinSelector)
+
+
+def str_val(val, pre='')
+  ("#{pre}%.8f" % (val / 1e8)).rjust(15)
+end
+
+def val_str(str)
+  (str.to_f * 1e8).to_i
+end
+
+case cmd
+when "balance"
+  if cmdopts && cmdopts.size == 1
+    addr = cmdopts[0]
+    balance = storage.get_balance(Bitcoin.hash160_from_address(addr))
+    puts "#{addr} balance: #{str_val balance}"
+  else
+    puts "Total balance: #{str_val wallet.get_balance}"
+  end
+
+when "new"
+  puts "Generated new key with address: #{wallet.get_new_addr}"
+
+when "add"
+  key = {:label => ARGV[2]}
+  case ARGV[0]
+  when "pub"
+    k = Bitcoin::Key.new(nil, ARGV[1])
+    key[:key] = k
+    key[:addr] = k.addr
+  when "priv"
+    k = Bitcoin::Key.new(ARGV[1], nil)
+    k.regenerate_pubkey
+    key[:key] = k
+    key[:addr] = k.addr
+  when "addr"
+    key[:addr] = ARGV[1]
+  else
+    raise "unknown type #{ARGV[0]}"
+  end
+  wallet.add_key key
+
+when "label"
+  wallet.label(ARGV[0], ARGV[1])
+
+when "flag"
+  wallet.flag(ARGV[0], *ARGV[1].split("="))
+
+when "key"
+  key = wallet.keystore.key(ARGV[0])
+  puts "Label:   #{key[:label]}"
+  puts "Address: #{key[:addr]}"
+  puts "Pubkey:  #{key[:key].pub}"
+  puts "Privkey: #{key[:key].priv}"  if ARGV[1] == '-p'
+  puts "Mine:    #{key[:mine]}"
+
+  
+when "import"
+  if wallet.keystore.respond_to?(:import)
+    addr = wallet.keystore.import(cmdopts[0])
+    puts "Key for #{addr} imported."
+  else
+    puts "Keystore doesn't support importing."
+  end
+
+when "export"
+  base58 = wallet.keystore.export(cmdopts[0])
+  puts "Base58 encoded private key for #{cmdopts[0]}:"
+  puts base58
+
+when "list"
+  if cmdopts && cmdopts.size == 1
+    depth = storage.get_depth
+    total = 0
+    key = wallet.keystore.key(cmdopts[0])
+    storage.get_txouts_for_address(key[:addr]).each do |txout|
+      total += txout.value
+      tx = txout.get_tx
+      blocks = depth - tx.get_block.depth rescue 0
+      puts "#{tx.hash} | #{str_val txout.value, '+ '} | " +
+        "#{str_val total} | #{blocks}"
+      tx.in.map(&:get_prev_out).each do |prev_out|
+        if prev_out
+          puts "  <- #{prev_out.get_address}"
+        else
+          puts "  <- generation"
+        end
+      end
+      puts
+
+      if txin = txout.get_next_in
+        tx = txin.get_tx
+        total -= txout.value
+        blocks = depth - tx.get_block.depth rescue 0
+        puts "#{tx.hash} | #{str_val txout.value, '- '} | " +
+          "#{str_val total} | #{blocks}"
+        txin.get_tx.out.each do |out|
+          puts "  -> #{out.get_addresses.join(', ')}"
+        end
+        puts
+      end
+    end
+    puts "Total balance: #{str_val total}"
+  else
+    puts "Wallet addresses:"
+    total = 0
+    wallet.list.each do |key, balance|
+      total += balance
+      icon = key[:key] && key[:key].priv ? "P" : (key[:mine] ? "M" : " ")
+      puts "  #{icon} #{key[:label].to_s.ljust(10)} (#{key[:addr].to_s.ljust(34)}) - #{("%.8f" % (balance / 1e8)).rjust(15)}"
+    end
+    puts "Total balance: #{str_val wallet.get_balance}"
+  end
+
+when "send"
+  to = cmdopts[0].split(',').map do |pair|
+    type, *addrs, value = pair.split(":")
+    value = val_str(value)
+    [type.to_sym, *addrs, value]
+  end
+  fee = val_str(cmdopts[1]) || 0
+  value = val_str value
+
+  unless wallet.get_balance >= (to.map{|t|t[-1]}.inject{|a,b|a+=b;a} + fee)
+    puts "Insufficient funds."; exit
+  end
+
+  tx = wallet.new_tx(to, fee)
+
+  if tx.is_a?(Bitcoin::Wallet::TxDP)
+    puts "Transaction needs to be signed by additional keys."
+    print "Filename to save TxDP: [./#{tx.id}.txdp] "
+    $stdout.flush
+    filename = $stdin.gets.strip
+    filename = "./#{tx.id}.txdp"  if filename == ""
+    File.open(filename, "w") {|f| f.write(tx.serialize) }
+    exit
+  end
+  
+  unless tx
+    puts "Error creating tx."; exit
+  end
+
+  total = 0
+  puts "Hash: #{tx.hash}"
+  puts "inputs:"
+  tx.in.each do |txin|
+    prev_out = storage.get_txout_for_txin(txin)
+    total += prev_out.value
+    puts " #{prev_out.get_address} - #{str_val prev_out.value}"
+  end
+
+  puts "outputs:"
+  tx.out.each do |txout|
+    total -= txout.value
+    script = Bitcoin::Script.new(txout.pk_script)
+    if script.is_pubkey?
+      puts "#{str_val txout.value} #{script.get_pubkey} (pubkey)"
+    elsif script.is_hash160?
+      puts "#{str_val txout.value} #{script.get_address} (address)"
+    elsif script.is_multisig?
+      puts "#{str_val txout.value} #{script.get_addresses.join(' ')} (multisig)"
+    end
+  end
+  puts "Fee: #{str_val total}"
+
+  $stdout.sync = true
+  print "Really send transaction? (y/N) " and $stdout.flush
+  unless $stdin.gets.chomp.downcase == 'y'
+    puts "Aborted."; exit
+  end
+
+  EM.run do
+    Bitcoin::Network::CommandClient.connect(*options[:command].split(":")) do
+      on_connected do
+        request(:relay_tx, tx)
+      end
+      on_relay_tx do
+        puts "Transaction #{tx.hash} relayed"
+        EM.stop
+      end
+    end
+  end
+
+when "sign"
+  txt = File.read(ARGV[0])
+  txdp = Bitcoin::Wallet::TxDP.parse(txt)
+  puts txdp.tx[0].to_json
+
+  print "Really sign transaction? (y/N) " and $stdout.flush
+  unless $stdin.gets.chomp.downcase == 'y'
+    puts "Aborted."; exit
+  end
+
+  txdp.sign_inputs do |tx, prev_tx, i, addr|
+    key = keystore.key(addr)[:key] rescue nil
+    next nil  unless key && !key.priv.nil?
+    sig_hash = tx.signature_hash_for_input(i, prev_tx)
+    sig = key.sign(sig_hash)
+    script_sig = Bitcoin::Script.to_pubkey_script_sig(sig, [key.pub].pack("H*"))
+    script_sig.unpack("H*")[0]
+  end
+  File.open(ARGV[0], "w") {|f| f.write txdp.serialize }
+
+when "relay"
+  txt = File.read(ARGV[0])
+  txdp = Bitcoin::Wallet::TxDP.parse(txt)
+  tx = txdp.tx[0]
+  puts tx.to_json
+  txdp.inputs.each_with_index do |s, i|
+    value, sigs = *s
+    tx.in[i].script_sig = [sigs[0][1]].pack("H*")
+  end
+  tx.in.each_with_index do |txin, i|
+    p txdp.tx.map(&:hash)
+    prev_tx = storage.get_tx(txin.prev_out.reverse.unpack("H*")[0])
+    raise "prev tx #{txin.prev_out.reverse.unpack("H*")[0]} not found"  unless prev_tx
+    raise "signature error"  unless tx.verify_input_signature(i, prev_tx)
+  end
+
+  $stdout.sync = true
+  print "Really send transaction? (y/N) " and $stdout.flush
+  unless $stdin.gets.chomp.downcase == 'y'
+    puts "Aborted."; exit
+  end
+
+  EM.run do
+    EM.connect(*options[:command].split(":")) do |conn|
+      conn.send_data(["relay_tx", tx.to_payload.unpack("H*")[0]].to_json)
+      def conn.receive_data(data)
+        (@buf ||= BufferedTokenizer.new("\x00")).extract(data).each do |packet|
+          res = JSON.load(packet)
+          puts "Transaction relayed: #{res[1]["hash"]}"
+          EM.stop
+        end
+      end
+    end
+  end
+
+else
+  puts "Unknown command."
+end