bitcoin-ruby 0.0.1

data/lib/bitcoin/gui/tx_view.rb

@@ -0,0 +1,67 @@
+module Bitcoin::Gui
+  class TxView < TreeView
+
+    def initialize gui, replace = nil
+      super(gui, :tx_view, [
+          [GObject::TYPE_STRING, "Type"],
+          [GObject::TYPE_STRING, "Hash"],
+          [GObject::TYPE_STRING, "Value", :format_value_col],
+          [GObject::TYPE_INT, "Confirmations"],
+          [GObject::TYPE_STRING, "Direction"],
+        ])
+      GObject.signal_connect(@view, "row-activated") do |view, path, column|
+        res, iter = @model.get_iter(path)
+        next  unless res
+        tx_hash = @model.get_value(iter, 1).get_string
+        @gui.display_tx(tx_hash)
+      end
+    end
+
+    def update txouts
+      EM.defer do
+        @model.clear
+        txouts.each do |txout|
+          row = @model.append(nil)
+          @model.set_value(row, 0, txout.type.to_s)
+          @model.set_value(row, 1, txout.get_tx.hash)
+          @model.set_value(row, 2, txout.value.to_s)
+          @model.set_value(row, 3, txout.get_tx.confirmations)
+          @model.set_value(row, 4, "incoming")
+          if txin = txout.get_next_in
+            row = @model.append(nil)
+            @model.set_value(row, 0, txout.type.to_s)
+            @model.set_value(row, 1, txin.get_tx.hash)
+            @model.set_value(row, 2, (0 - txout.value).to_s)
+            @model.set_value(row, 3, txin.get_tx.confirmations)
+            @model.set_value(row, 4, "outgoing")
+          end
+        end
+        @view.set_model @model
+      end
+    end
+  end
+
+  class TxInView < TreeView
+    def initialize gui, replace = nil
+      super(gui, [
+          [GObject::TYPE_STRING, "Type"],
+          [GObject::TYPE_STRING, "From"],
+          [GObject::TYPE_STRING, "Value", :format_value_col]
+        ])
+      old = @gui.builder.get_object("tx_view")
+    end
+
+    def update txins
+      @model.clear
+      txins.each do |txin|
+        txout = txin.get_prev_out
+        row = @model.append(nil)
+        @model.set_value(row, 0, txout.type.to_s)
+        @model.set_value(row, 1, txout.get_addresses.join(", "))
+        @model.set_value(row, 2, txout.value.to_s)
+      end
+      @view.set_model @model
+    end
+  end
+
+end

data/lib/bitcoin/key.rb

@@ -0,0 +1,125 @@
+module Bitcoin
+
+  # Elliptic Curve key as used in bitcoin.
+  class Key
+
+    # Generate a new keypair.
+    #  Bitcoin::Key.generate
+    def self.generate
+      k = new; k.generate; k
+    end
+
+    # Import private key from base58 fromat as described in
+    # https://en.bitcoin.it/wiki/Private_key#Base_58_Wallet_Import_format and
+    # https://en.bitcoin.it/wiki/Base58Check_encoding#Encoding_a_private_key.
+    # See also #to_base58
+    def self.from_base58(str)
+      hex = Bitcoin.decode_base58(str)
+      version, key, checksum = hex.unpack("a2a64a8")
+      raise "Invalid version"   unless version == Bitcoin.network[:privkey_version]
+      raise "Invalid checksum"  unless Bitcoin.checksum(version + key) == checksum
+      new(key)
+    end
+
+    def == other
+      self.priv == other.priv
+    end
+
+    # Create a new key with given +privkey+ and +pubkey+.
+    #  Bitcoin::Key.new
+    #  Bitcoin::Key.new(privkey)
+    #  Bitcoin::Key.new(nil, pubkey)
+    def initialize privkey = nil, pubkey = nil
+      @key = Bitcoin.bitcoin_elliptic_curve
+      set_priv(privkey)  if privkey
+      set_pub(pubkey)  if pubkey
+    end
+
+    # Generate new priv/pub key.
+    def generate
+      @key.generate_key
+    end
+
+    # Get the private key (in hex).
+    def priv
+      return nil  unless @key.private_key
+      @key.private_key.to_hex.rjust(64, '0')
+    end
+
+    # Set the private key to +priv+ (in hex).
+    def priv= priv
+      set_priv(priv)
+    end
+
+    # Get the public key (in hex).
+    # In case the key was initialized with only
+    # a private key, the public key is regenerated.
+    def pub
+      unless @key.public_key
+        if @key.private_key
+          set_pub(Bitcoin::OpenSSL_EC.regenerate_key(priv)[1])
+        else
+          return nil
+        end
+      end
+      @key.public_key.to_hex.rjust(130, '0')
+    end
+
+    # Set the public key (in hex).
+    def pub= pub
+      set_pub(pub)
+    end
+
+    # Get the hash160 of the public key.
+    def hash160
+      Bitcoin.hash160(pub)
+    end
+
+    # Get the address corresponding to the public key.
+    def addr
+      Bitcoin.hash160_to_address(hash160)
+    end
+
+    # Sign +data+ with the key.
+    #  key1 = Bitcoin::Key.generate
+    #  sig = key.sign("some data")
+    def sign(data)
+      @key.dsa_sign_asn1(data)
+    end
+
+    # Verify signature +sig+ for +data+.
+    #  key2 = Bitcoin::Key.new(nil, key1.pub)
+    #  key2.verify("some data", sig)
+    def verify(data, sig)
+      @key.dsa_verify_asn1(data, sig)
+    end
+
+    # Export private key to base58 format.
+    # See also Key.from_base58
+    def to_base58
+      data = Bitcoin.network[:privkey_version] + priv
+      hex  = data + Bitcoin.checksum(data)
+      Bitcoin.int_to_base58( hex.to_i(16) )
+    end
+
+    protected
+
+    # Regenerate public key from the private key.
+    def regenerate_pubkey
+      set_pub(Bitcoin::OpenSSL_EC.regenerate_key(priv)[1])
+    end
+
+    # Set +priv+ as the new private key (converting from hex).
+    def set_priv(priv)
+      @key.private_key = OpenSSL::BN.from_hex(priv)
+    end
+
+    # Set +pub+ as the new public key (converting from hex).
+    def set_pub(pub)
+      @key.public_key = OpenSSL::PKey::EC::Point.from_hex(@key.group, pub)
+    end
+
+  end
+
+end
+

data/lib/bitcoin/logger.rb

@@ -0,0 +1,65 @@
+if Bitcoin.require_dependency :log4r, exit: false
+  # monkey-patch Log4r to accept level names as symbols
+  class Log4r::Logger
+    def level= l = 0
+      _level = l.is_a?(Fixnum) ? l : Log4r::LNAMES.index(l.to_s.upcase)
+      Log4r::Log4rTools.validate_level(_level)
+      @level = _level
+      LoggerFactory.define_methods(self)
+      Log4r::Logger.log_internal {"Logger '#{@fullname}' set to #{LNAMES[@level]}"}
+      @level
+    end
+  end
+end
+
+module Bitcoin
+  # this is a very simple logger that is used if log4r is not available
+  module Logger
+
+    class Logger
+      LEVELS = [:debug, :info, :warn, :error, :fatal]
+
+      attr_accessor :level
+
+      def initialize(name)
+        @name, @level = name, :info
+      end
+
+      def level= level
+        @level = level.is_a?(Fixnum) ? LEVELS[level] : level.to_sym
+      end
+
+      LEVELS.each do |level|
+        define_method(level) do |*msg, &block|
+          return  if LEVELS.index(level.to_sym) < LEVELS.index(@level.to_sym)
+          msg = block ? block.call : msg.join
+          puts "#{level.to_s.upcase.ljust(5)} #{@name}: #{msg}"
+        end
+      end
+    end
+
+    # wrap a logger and prepend a special name in front of the messages
+    class LogWrapper
+      def initialize(name, log); @name, @log = name, log; end
+      def method_missing(m, *a, &blk)
+        @log.send(m, *a, &proc{ "#{@name} #{blk.call}" })
+      end
+    end
+
+    # create a logger with given +name+. if log4r is installed, the logger
+    # will have a stdout and a fileout outputter to `log/<name>.log`.
+    # otherwise, the internal dummy logger is used which only logs to stdout.
+    def self.create name, level = :info
+      if defined?(Log4r)
+        @log = Log4r::Logger.new(name.to_s)
+        @log.level = level
+        @log.outputters << Log4r::Outputter.stdout
+        @log.outputters << Log4r::FileOutputter.new("fout", :filename => "log/#{name}.log")
+      else
+        @log = Bitcoin::Logger::Logger.new(name)
+      end
+      @log
+    end
+
+  end
+end

data/lib/bitcoin/network/command_client.rb

@@ -0,0 +1,93 @@
+# Client to connect to CommandHandler and issue requests or register for events
+class Bitcoin::Network::CommandClient < EM::Connection
+
+  # create new client connecting to +host+:+port+ and executing callbacks from +block+,
+  # passing +args+ in.
+  #  CommandClient.connect(host, port) do
+  #    on_connected { request("info") }
+  #    on_info {|i| p i}
+  #  end
+  def initialize host, port, block, *args
+    @host, @port = host, port
+    @args = args
+    @callbacks = {}
+    @block = block
+    instance_eval &block  if block
+    @buffer = BufferedTokenizer.new("\x00")
+    @connection_attempts = 0
+  end
+
+  def log;
+    @log ||= Bitcoin::Logger.create(:client)
+  end
+
+  def self.connect host, port, *args, &block
+    client = EM.connect(host, port.to_i, self, host, port.to_i, block, *args)
+  end
+
+  # call +connected+ callback
+  def post_init
+    log.debug { "Connected" }
+    callback :connected
+  end
+
+  # call +disconnected+ callback and try to reconnect
+  def unbind
+    log.debug { "Disconnected." }
+    callback :disconnected
+    if @connection_attempts > 1
+      log.info { "Trying to start server..." }
+      EM.defer { system("bin/bitcoin_node", "--quiet") }
+    end
+    EM.add_timer(1) do
+      @connection_attempts += 1
+      reconnect(@host, @port)
+      post_init
+    end
+  end
+
+  # request command +cmd+ with +args+ from the server
+  def request cmd, *args
+    log.debug { "request: #{cmd} #{args.inspect}" }
+    register_monitor_callbacks  if cmd.to_sym == :monitor
+    send_data([cmd, args].to_json + "\x00")
+  end
+
+  # receive response from server
+  def receive_data data
+    @connection_attempts = 0
+    @buffer.extract(data).each do |packet|
+      cmd, *data = *JSON.load(packet)
+      log.debug { d = data.inspect
+        "response: #{cmd} #{d[0...50]}#{d.size > 50 ? '...' : ''}" }
+      callback(:response, cmd, *data)
+      callback(cmd.to_sym, *data)
+    end
+  end
+
+  # call the callback specified by +name+ passing in +args+
+  def callback name, *args
+    cb = @callbacks[name.to_sym]
+    return  unless cb
+    log.debug { "callback: #{name}" }
+    cb.call(*args)
+  end
+
+  # register callback methods
+  def method_missing(name, *args, &block)
+    if name =~ /^on_/
+      @callbacks[name.to_s.split("on_")[1].to_sym] = block
+      log.debug { "callback #{name} registered" }
+    else
+      super(name, *args)
+    end
+  end
+
+  # register callbacks for monitor
+  def register_monitor_callbacks
+    on_monitor do |type, data|
+      callback(type, *data)
+    end
+  end
+
+end

data/lib/bitcoin/network/command_handler.rb

@@ -0,0 +1,179 @@
+require 'json'
+require 'monitor'
+
+# Started by the Node, accepts connections from CommandClient and answers requests or
+# registers for events and notifies the clients when they happen.
+class Bitcoin::Network::CommandHandler < EM::Connection
+
+  # create new CommandHandler
+  def initialize node
+    @node = node
+    @node.command_connections << self
+    @buf = BufferedTokenizer.new("\x00")
+    @lock = Monitor.new
+  end
+
+  # wrap logger and append prefix
+  def log
+    @log ||= Bitcoin::Logger::LogWrapper.new("command:", @node.log)
+  end
+
+  # respond to a command; send serialized response to the client
+  def respond(cmd, data)
+    return  unless data
+    @lock.synchronize do
+      send_data([cmd, data].to_json + "\x00")
+    end
+  end
+
+  # receive request from the client
+  def receive_data data
+    @buf.extract(data).each do |packet|
+      cmd, args = JSON::parse(packet)
+      log.debug { [cmd, args] }
+      if respond_to?("handle_#{cmd}")
+        respond(cmd, send("handle_#{cmd}", *args))
+      else
+        respond(cmd, {:error => "unknown command: #{cmd}. send 'help' for help."})
+      end
+    end
+  rescue Exception
+    p $!
+  end
+
+  # handle +monitor+ command; subscribe client to specified channels
+  # (+block+, +tx+, +connection+)
+  #  bitcoin_node monitor block
+  #  bitcoin_node monitor "block tx connection"
+  def handle_monitor *channels
+    channels.each do |channel|
+      @node.notifiers[channel.to_sym].subscribe do |*data|
+        respond("monitor", [channel, *data])
+      end
+      case channel.to_sym
+      when :block
+        head = Bitcoin::P::Block.new(@node.store.get_head.to_payload) rescue nil
+        respond("monitor", ["block", [head, @node.store.get_depth.to_s]])  if head
+      when :connection
+        @node.connections.select {|c| c.connected?}.each do |conn|
+          respond("monitor", [:connection, [:connected, conn.info]])
+        end
+      end
+    end
+    nil
+  end
+
+  # display various statistics
+  #  bitcoin_node info
+  def handle_info
+    blocks = @node.connections.map(&:version).compact.map(&:block) rescue nil
+    {
+      :blocks => "#{@node.store.get_depth} (#{(blocks.inject{|a,b| a+=b;a} / blocks.size rescue '?')})#{@node.in_sync ? ' sync' : ''}",
+      :addrs => "#{@node.addrs.select{|a| a.alive?}.size} (#{@node.addrs.size})",
+      :connections => "#{@node.connections.select{|c| c.state == :connected}.size} (#{@node.connections.size})",
+      :queue => @node.queue.size,
+      :inv_queue => @node.inv_queue.size,
+      :inv_cache => @node.inv_cache.size,
+      :network => @node.config[:network],
+      :storage => @node.config[:storage],
+      :version => Bitcoin::Protocol::VERSION,
+      :uptime => format_uptime(@node.uptime),
+    }
+  end
+
+  # display configuration hash currently used
+  #  bitcoin_node config
+  def handle_config
+    @node.config
+  end
+
+  # display connected peers
+  #  bitcoin_node connections
+  def handle_connections
+    @node.connections.sort{|x,y| y.uptime <=> x.uptime}.map{|c|
+      "#{c.host.rjust(15)}:#{c.port} [state: #{c.state}, " +
+      "version: #{c.version.version rescue '?'}, " +
+      "block: #{c.version.block rescue '?'}, " +
+      "uptime: #{format_uptime(c.uptime) rescue 0}, " +
+      "client: #{c.version.user_agent rescue '?'}]" }
+  end
+
+  # connect to given peer(s)
+  #  bitcoin_node connect <ip>:<port>[,<ip>:<port>]
+  def handle_connect *args
+    args.each {|a| @node.connect_peer(*a.split(':')) }
+    {:state => "Connecting..."}
+  end
+
+  # disconnect peer(s)
+  #  bitcoin_node disconnect <ip>:<port>[,<ip>,<port>]
+  def handle_disconnect *args
+    args.each do |c|
+      host, port = *c.split(":")
+      conn = @node.connections.select{|c| c.host == host && c.port == port.to_i}.first
+      conn.close_connection  if conn
+    end
+    {:state => "Disconnected"}
+  end
+
+  # trigger node to ask peers for new blocks
+  #  bitcoin_node getblocks
+  def handle_getblocks
+    @node.connections.sample.send_getblocks
+    {:state => "Sending getblocks..."}
+  end
+
+  # trigger node to ask for new peer addrs
+  #  bitcoin_node getaddr
+  def handle_getaddr
+    @node.connections.sample.send_getaddr
+    {:state => "Sending getaddr..."}
+  end
+
+  # display known peer addrs (used by bin/bitcoin_dns_seed)
+  #  bitcoin_node addrs [count]
+  def handle_addrs count = 32
+    @node.addrs.weighted_sample(count.to_i) do |addr|
+      Time.now.tv_sec + 7200 - addr.time
+    end.map do |addr|
+      [addr.ip, addr.port, Time.now.tv_sec - addr.time] rescue nil
+    end.compact
+  end
+
+  # relay given transaction (in hex)
+  #  bitcoin_node relay_tx <tx data>
+  def handle_relay_tx data
+    tx = Bitcoin::Protocol::Tx.from_hash(data)
+    @node.relay_tx(tx)
+  rescue
+    {:error => $!}
+  end
+
+  # stop bitcoin node
+  #  bitcoin_node stop
+  def handle_stop
+    Thread.start { sleep 0.1; @node.stop }
+    {:state => "Stopping..."}
+  end
+
+  # list all commands
+  #  bitcoin_node help
+  def handle_help
+    self.methods.grep(/^handle_(.*?)/).map {|m| m.to_s.sub(/^(.*?)_/, '')}
+  end
+
+  # format node uptime
+  def format_uptime t
+    mm, ss = t.divmod(60)            #=> [4515, 21]
+    hh, mm = mm.divmod(60)           #=> [75, 15]
+    dd, hh = hh.divmod(24)           #=> [3, 3]
+    "%02d:%02d:%02d:%02d" % [dd, hh, mm, ss]
+  end
+
+  # disconnect notification clients when connection is closed
+  def unbind
+    #@node.notifiers.unsubscribe(@notify_sid)  if @notify_sid
+    @node.command_connections.delete(self)
+  end
+
+end