bitcoin-ruby 0.0.6 → 0.0.7

data/bin/bitcoin_node

@@ -1,153 +0,0 @@
-#!/usr/bin/env ruby
-$:.unshift( File.expand_path("../../lib", __FILE__) )
-
-require 'bitcoin'
-require 'optparse'
-require 'fileutils'
-Bitcoin.require_dependency :eventmachine
-Bitcoin.require_dependency :json
-
-defaults = Bitcoin::Network::Node::DEFAULT_CONFIG
-
-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].join(':')})") do |command|
-    options[:command] = command.split(":")
-  end
-
-  opts.on("-l", "--listen [HOST:PORT]",
-    "Listen address/port (default: #{options[:listen].join(':')})") do |listen|
-    options[:listen] = listen.split(":")
-  end
-
-  opts.on("--connect [HOST:PORT]",
-    "Hosts to connect to (default: #{options[:connect].map{|c|c.join(':')}.join(',')})") do |connect|
-    connect.split(",").each do |host|
-      options[:connect] << host.split(":")
-    end
-  end
-
-  opts.on("-a", "--announce",
-    "Announce our own address to the network, so we will get incoming connections.") do
-    options[:announce] = true
-  end
-
-  opts.on("--external-port PORT",
-    "Specify external port that can be used to reach this node (uses local port otherwise).") do |port|
-    options[:external_port] = port.to_i
-  end
-
-  opts.on("-s", "--storage [BACKEND::CONFIG]",
-    "Use storage backend (default: #{options[:storage]})") do |storage|
-    options[:storage] = storage
-  end
-
-  opts.on("--skip-validation", "Skip validation of blocks and transactions") do
-    options[:skip_validation] = true
-  end
-
-  opts.on("--check-blocks COUNT",
-          "Check consistency of COUNT latest blocks; -1 for all (default: 1000)") do |check|
-    options[:check_blocks] = check.to_i
-  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
-
-  opts.on("--mco", "--max-connections-out COUNT", "Maximum number of outgoing connections (default: #{options[:max][:connections_out]})") do |count|
-    options[:max][:connections_out] = count.to_i
-  end
-
-  opts.on("--mci", "--max-connections-in COUNT", "Maximum number of incoming connections (default: #{options[:max][:connections_in]})") do |count|
-    options[:max][:connections_in] = count.to_i
-  end
-
-  [:addr, :queue, :inv, :unconfirmed].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("--import DIR", "Import blk*.dat files from DIR") do |dir|
-    options[:import] = dir
-  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]
-FileUtils.mkdir_p File.join(ENV['HOME'], ".bitcoin-ruby/#{Bitcoin.network_name}")
-
-if ARGV.any?
-  system(File.join(File.dirname(__FILE__), "bitcoin_node_cli"), *ARGV) 
-else
-  node = Bitcoin::Network::Node.new(options)
-  node.run
-end

data/bin/bitcoin_node_cli

@@ -1,81 +0,0 @@
-#!/usr/bin/env ruby
-$:.unshift( File.expand_path("../../lib", __FILE__) )
-
-require 'bitcoin'
-require 'optparse'
-require 'fileutils'
-Bitcoin.require_dependency :eventmachine
-Bitcoin.require_dependency :json
-
-defaults = Bitcoin::Network::Node::DEFAULT_CONFIG
-
-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].join(':')})") do |command|
-    options[:command] = command.split(":")
-  end
-
-  opts.on( '-h', '--help', 'Display this screen' ) do
-    puts opts; exit
-  end
-end
-
-optparse.parse!
-
-Bitcoin.network = options[:network]
-FileUtils.mkdir_p File.join(ENV['HOME'], ".bitcoin-ruby/#{Bitcoin.network_name}")
-                  
-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|
-      hash = Bitcoin::P::Block.new(block['hex'].htb).to_hash.merge("depth" => block['depth'])
-      puts JSON.pretty_generate(hash)
-    end
-    on_tx do |tx, confirmations|
-      hash = Bitcoin::P::Tx.new(tx['hex'].htb).to_hash.merge("nhash" => tx['nhash'], "conf" => tx['conf'])
-      puts JSON.pretty_generate(hash)
-    end
-    on_output do |data|
-      puts JSON.pretty_generate(data)
-    end
-    on_connection do |data|
-      p data
-    end
-    on_connected do
-      cmd, params = ARGV.shift, Hash[ARGV.map {|a| a.split("=") }]
-      case cmd
-      when "create_tx"
-        params["keys"] = JSON.parse(params["keys"])
-        params["recipients"] = JSON.parse(params["recipients"])
-      when "assemble_tx"
-        params["sig_pubs"] = JSON.parse(params["sig_pubs"])
-      when "monitor"
-        params["addresses"] = JSON.parse(params["addresses"])  if params["addresses"]
-        $stdout.sync = true
-      end
-      request(cmd, params)
-    end
-  end
-end

data/bin/bitcoin_wallet

@@ -1,402 +0,0 @@
-#!/usr/bin/env ruby
-$:.unshift( File.expand_path("../../lib", __FILE__) )
-
-require 'bitcoin'
-require 'eventmachine'
-require 'optparse'
-require 'yaml'
-
-defaults = {
-  :network => "testnet",
-  :storage => nil,
-  :keystore => nil,
-  :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" +
-    " name_list - list names in the wallet\n" +
-    " name_show <name> - display name information\n" +
-    " name_history <name> - display name history\n" +
-    " name_new <name> - reserve a name\n" +
-    " name_firstupdate <name> <rand> <value> - register a name\n" +
-    " name_update <name> <value> [<toaddress>] - update/transfer a name\n"
-
-end
-
-optparse.parse!
-
-cmd = ARGV.shift; cmdopts = ARGV
-unless cmd
-  puts optparse; exit
-end
-
-Bitcoin.network = options[:network]
-
-options[:keystore] ||= "simple::file=~/.bitcoin-ruby/#{Bitcoin.network_name}/keys.json"
-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)
-
-options[:storage] ||= "sequel::sqlite://~/.bitcoin-ruby/#{Bitcoin.network_name}/blocks.db"
-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
-
-def send_transaction(storage, options, tx, ask = true)
-  # puts tx.to_json
-  if ask
-    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)
-      print "#{str_val txout.value} "
-      if script.is_pubkey?
-        puts "#{script.get_pubkey} (pubkey)"
-      elsif script.is_hash160?
-        puts "#{script.get_address} (address)"
-      elsif script.is_multisig?
-        puts "#{script.get_addresses.join(' ')} (multisig)"
-      elsif script.is_op_return?
-        puts "#{script.get_op_return_data} (op_return)"
-      elsif script.is_namecoin?
-        puts "#{script.get_address} (#{script.type})"
-        print " " * 16
-        if script.is_name_new?
-          puts "Name Hash: #{script.get_namecoin_hash}"
-        else
-          puts "#{script.get_namecoin_name}: #{script.get_namecoin_value}"
-        end
-      else
-        puts "#{str_val txout.value} (unknown type)"
-      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
-  end
-  EM.run do
-    Bitcoin::Network::CommandClient.connect(*options[:command]) do
-      on_connected do
-        request(:relay_tx, tx.to_payload.hth)
-      end
-      on_relay_tx do |res|
-        if res["success"]
-          puts "Transaction #{tx.hash} relayed to approx. #{"%.2f" % res['propagation']['percent']}% of the network."
-        else
-          puts "Error relaying tx: #{res['error']}"
-        end
-        EM.stop
-      end
-    end
-  end
-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.import_key(cmdopts[0])
-    puts "Key for #{addr} imported."
-  else
-    puts "Keystore doesn't support importing."
-  end
-
-when "rescan"
-  wallet.rescan
-
-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|
-          if Bitcoin.namecoin? && out.type.to_s =~ /^name_/
-            script = out.script
-            puts "  -> #{script.get_namecoin_name || script.get_namecoin_hash} (#{out.type})"
-          else
-            puts "  -> #{out.get_addresses.join(', ') rescue 'unknown'}"
-          end
-        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 "name_list"
-  names = wallet.get_txouts.select {|o| [:name_firstupdate, :name_update].include?(o.type)}
-    .map(&:get_namecoin_name).group_by(&:name).map {|n, l| l.sort_by(&:expires_in).last }.map {|name|
-    { name: name.name, value: name.value, address: name.get_address, expires_in: name.expires_in } }
-  puts JSON.pretty_generate(names)
-
-when "name_show"
-  name = storage.name_show(cmdopts[0])
-  puts name.to_json
-
-when "name_history"
-  names = storage.name_history(cmdopts[0])
-  puts JSON.pretty_generate(names)
-
-when "name_new"
-  name = cmdopts[0]
-  address = wallet.keystore.keys.sample[:key].addr
-  @rand = nil
-  def self.set_rand rand
-    @rand = rand
-  end
-  tx = wallet.new_tx([[:name_new, self, name, address, 1000000]])
-  (puts "Error creating tx."; exit)  unless tx
-  send_transaction(storage, options, tx, true)
-  puts JSON.pretty_generate([tx.hash, @rand])
-
-when "name_firstupdate"
-  name, rand, value = *cmdopts
-  address = wallet.keystore.keys.sample[:key].addr
-  tx = wallet.new_tx([[:name_firstupdate, name, rand, value, address, 1000000]])
-  (puts "Error creating tx."; exit)  unless tx
-  send_transaction(storage, options, tx, true)
-  puts tx.hash
-
-when "name_update"
-  name, value, address = *cmdopts
-  address ||= wallet.keystore.keys.sample[:key].addr
-  tx = wallet.new_tx([[:name_update, name, value, address, 1000000]])
-  (puts "Error creating tx."; exit)  unless tx
-  send_transaction(storage, options, tx, true)
-  puts tx.hash
-
-when "send"
-  to = cmdopts[0].split(',').map do |opts|
-    o = opts.split(":")
-    type, *addrs, value = *(o.size == 2 ? [:address, *o] : o)
-    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
-
-  (puts "Error creating tx."; exit)  unless tx
-
-  send_transaction(storage, options, tx)
-
-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_hth)
-    raise "prev tx #{txin.prev_out.reverse_hth} 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]) 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. See --help for available commands."
-end