bitcoin-ruby 0.0.1 → 0.0.2

data/lib/bitcoin/network/command_client.rb

@@ -1,3 +1,7 @@
+# encoding: ascii-8bit
+
+require 'json'
+
 # Client to connect to CommandHandler and issue requests or register for events
 class Bitcoin::Network::CommandClient < EM::Connection
 
@@ -35,11 +39,7 @@ class Bitcoin::Network::CommandClient < EM::Connection
   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
+    EM.add_timer(@connection_attempts) do
       @connection_attempts += 1
       reconnect(@host, @port)
       post_init
@@ -86,7 +86,8 @@ class Bitcoin::Network::CommandClient < EM::Connection
   # register callbacks for monitor
   def register_monitor_callbacks
     on_monitor do |type, data|
-      callback(type, *data)
+      type, *params = type.split("_")
+      callback(type, *((data || []) + (params || [])))
     end
   end
 

data/lib/bitcoin/network/command_handler.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 require 'json'
 require 'monitor'
 
@@ -29,83 +31,156 @@ class Bitcoin::Network::CommandHandler < EM::Connection
   # 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."})
+      begin
+        cmd, args = JSON::parse(packet)
+        log.debug { [cmd, args] }
+        if cmd == "relay_tx"
+          handle_relay_tx(*args)
+          return
+        end
+        if respond_to?("handle_#{cmd}")
+          respond(cmd, send("handle_#{cmd}", *args))
+        else
+          respond(cmd, { error: "unknown command: #{cmd}. send 'help' for help." })
+        end
+      rescue ArgumentError
+        respond(cmd, { error: $!.message })
       end
     end
   rescue Exception
-    p $!
+    p $!; puts *$@
   end
 
   # handle +monitor+ command; subscribe client to specified channels
-  # (+block+, +tx+, +connection+)
+  # (+block+, +tx+, +output+, +connection+).
+  # Some commands can have parameters, e.g. the number of confirmations
+  # +tx+ or +output+ should have. Parameters are appended to the command
+  # name after an underscore (_), e.g. subscribe to channel "tx_6" to
+  # receive only transactions with 6 confirmations.
+  # 
+  # Receive new blocks:
   #  bitcoin_node monitor block
-  #  bitcoin_node monitor "block tx connection"
+  # Receive new (unconfirmed) transactions:
+  #  bitcoin_node monitor tx
+  # Receive transactions with 6 confirmations:
+  #  bitcoin_node monitor tx_6 
+  # Receive [txhash, address, value] for each output:
+  #  bitcoin_node monitor output
+  # Receive peer connections/disconnections:
+  #  bitcoin_node monitor connection"
+  # Combine multiple channels:
+  #  bitcoin_node monitor "block tx tx_1 tx_6 connection"
+  # 
+  # NOTE: When a new block is found, it might include transactions that we
+  # didn't previously receive as unconfirmed. To make sure you receive all
+  # transactions, also subscribe to the tx_1 channel.
   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]])
+    channels.map(&:to_sym).each do |channel|
+      @node.subscribe(channel) {|*data| respond("monitor", [channel, *data]) }
+      name, *params = channel.to_s.split("_")
+      send("handle_monitor_#{name}", *params)
+      log.info { "Client subscribed to channel #{channel}" }
+    end
+    nil
+  end
+
+  # Handle +monitor block+ command; send the current chain head
+  # after client is subscribed to :block channel
+  def handle_monitor_block
+    head = Bitcoin::P::Block.new(@node.store.get_head.to_payload) rescue nil
+    respond("monitor", ["block", [head, @node.store.get_depth]])  if head
+  end
+
+  # Handle +monitor tx+ command.
+  # When +conf+ is given, don't subscribe to the :tx channel for unconfirmed
+  # transactions. Instead, subscribe to the :block channel, and whenever a new
+  # block comes in, send all transactions that now have +conf+ confirmations.
+  def handle_monitor_tx conf = nil
+    return  unless conf
+    if conf.to_i == 0 # 'tx_0' is just an alias for 'tx'
+      return @node.subscribe(:tx) {|*a| @node.notifiers[:tx_0].push(*a) }
+    end
+    @node.subscribe(:block) do |block, depth|
+      block = @node.store.get_block_by_depth(depth - conf.to_i + 1)
+      next  unless block
+      block.tx.each {|tx| @node.notifiers["tx_#{conf}".to_sym].push([tx, conf.to_i]) }
+    end
+  end
+
+  # Handle +monitor output+ command.
+  # Receive tx hash, recipient address and value for each output.
+  # This allows easy scanning for new payments without parsing the
+  # tx format and running scripts.
+  # See #handle_monitor_tx for confirmation behavior.
+  def handle_monitor_output conf = 0
+    return  unless (conf = conf.to_i) > 0
+    @node.subscribe(:block) do |block, depth|
+      block = @node.store.get_block_by_depth(depth - conf + 1)
+      next  unless block
+      block.tx.each do |tx|
+        tx.out.each do |out|
+          addr = Bitcoin::Script.new(out.pk_script).get_address
+          res = [tx.hash, addr, out.value, conf]
+          @node.push_notification("output_#{conf}".to_sym, res)
         end
       end
     end
-    nil
   end
 
-  # display various statistics
+  # Handle +monitor connection+ command; send current connections
+  # after client is subscribed to :connection channel.
+  def handle_monitor_connection
+    @node.connections.select {|c| c.connected?}.each do |conn|
+      respond("monitor", [:connection, [:connected, conn.info]])
+    end
+  end
+
+  # Get 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' : ''}",
+    blocks = @node.connections.map(&:version).compact.map(&:last_block) rescue nil
+    established = @node.connections.select {|c| c.state == :connected }
+    info = {
+      :blocks => "#{@node.store.get_depth} (#{(blocks.inject{|a,b| a+=b; a } / blocks.size rescue '?' )})#{@node.store.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})",
+      :connections => "#{established.size} established (#{established.select(&:outgoing?).size} out, #{established.select(&:incoming?).size} in), #{@node.connections.size - established.size} connecting",
       :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,
+      :version => Bitcoin.network[:protocol_version],
+      :external_ip => @node.external_ip,
       :uptime => format_uptime(@node.uptime),
     }
+    Bitcoin.namecoin? ? {:names => @node.store.db[:names].count}.merge(info) : info
   end
 
-  # display configuration hash currently used
+  # Get the currently active configuration.
   #  bitcoin_node config
   def handle_config
     @node.config
   end
 
-  # display connected peers
+  # Get currently 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}, " +
+      "#{c.host.rjust(15)}:#{c.port} [#{c.direction}, 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)
+  # 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)
+  # Disconnect given peer(s).
   #  bitcoin_node disconnect <ip>:<port>[,<ip>,<port>]
   def handle_disconnect *args
     args.each do |c|
@@ -116,21 +191,21 @@ class Bitcoin::Network::CommandHandler < EM::Connection
     {:state => "Disconnected"}
   end
 
-  # trigger node to ask peers for new blocks
+  # Trigger the node to ask its 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
+  # Trigger the node to ask its for new peer addresses.
   #  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)
+  # Get known peer addresses (used by bin/bitcoin_dns_seed).
   #  bitcoin_node addrs [count]
   def handle_addrs count = 32
     @node.addrs.weighted_sample(count.to_i) do |addr|
@@ -140,28 +215,139 @@ class Bitcoin::Network::CommandHandler < EM::Connection
     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)
+  # Trigger a rescan operation when used with a UtxoStore.
+  #  bitcoin_node rescan
+  def handle_rescan
+    EM.defer { @node.store.rescan }
+    {:state => "Rescanning ..."}
+  end
+
+  # Get Time Since Last Block.
+  #  bitcoin_node tslb
+  def handle_tslb
+    { tslb: (Time.now - @node.last_block_time).to_i }
+  end
+
+  # Create a transaction, collecting outputs from given +keys+, spending to +recipients+
+  # with an optional +fee+.
+  # Keys is an array that can contain either privkeys, pubkeys or addresses.
+  # When a privkey is given, the corresponding inputs are signed. If not, the
+  # signature_hash is computed and passed along with the response.
+  # After creating an unsigned transaction, one just needs to sign the sig_hashes
+  # and send everything to #assemble_tx, to receive the complete transaction that
+  # can be relayed to the network.
+  def handle_create_tx keys, recipients, fee = 0
+    keystore = Bitcoin::Wallet::SimpleKeyStore.new(file: StringIO.new("[]"))
+    keys.each do |k|
+      begin
+        key = Bitcoin::Key.from_base58(k)
+        key = { addr: key.addr, key: key }
+      rescue
+        if Bitcoin.valid_address?(k)
+          key = { addr: k }
+        else
+          begin
+            key = Bitcoin::Key.new(nil, k)
+            key = { addr: key.addr, key: key }
+          rescue
+            return { error: "Input not valid address, pub- or privkey: #{k}" }
+          end
+        end
+      end
+      keystore.add_key(key)
+    end
+    wallet = Bitcoin::Wallet::Wallet.new(@node.store, keystore)
+    tx = wallet.new_tx(recipients.map {|r| [:address, r[0], r[1]]}, fee)
+    return { error: "Error creating tx." }  unless tx
+    [ tx.to_payload.hth, tx.in.map {|i| [i.sig_hash.hth, i.sig_address] rescue nil } ]
   rescue
-    {:error => $!}
+    { error: "Error creating tx: #{$!.message}" }
   end
 
-  # stop bitcoin node
+  # Assemble an unsigned transaction from the +tx_hex+ and +sig_pubkeys+.
+  # The +tx_hex+ is the regular transaction structure, with empty input scripts
+  # (as returned by #create_tx when called without privkeys).
+  # +sig_pubkeys+ is an array of [signature, pubkey] pairs used to build the
+  # input scripts.
+  def handle_assemble_tx tx_hex, sig_pubs
+    tx = Bitcoin::P::Tx.new(tx_hex.htb)
+    sig_pubs.each.with_index do |sig_pub, idx|
+      sig, pub = *sig_pub.map(&:htb)
+      script_sig = Bitcoin::Script.to_signature_pubkey_script(sig, pub)
+      tx.in[idx].script_sig_length = script_sig.bytesize
+      tx.in[idx].script_sig = script_sig
+    end
+    tx = Bitcoin::P::Tx.new(tx.to_payload)
+    tx.validator(@node.store).validate(raise_errors: true)
+    tx.to_payload.hth
+  rescue
+    { error: "Error assembling tx: #{$!.message}" }
+  end
+
+  # Relay given transaction (in hex).
+  #  bitcoin_node relay_tx <tx in hex>
+  def handle_relay_tx hex, send = 3, wait = 3
+    begin
+      tx = Bitcoin::P::Tx.new(hex.htb)
+    rescue
+      return respond("relay_tx", { error: "Error decoding transaction." })
+    end
+
+    validator = tx.validator(@node.store)
+    unless validator.validate(rules: [:syntax])
+      return respond("relay_tx", { error: "Transaction syntax invalid.",
+                     details: validator.error })
+    end
+    unless validator.validate(rules: [:context])
+      return respond("relay_tx", { error: "Transaction context invalid.",
+                     details: validator.error })
+    end
+
+    #@node.store.store_tx(tx)
+    @node.relay_tx[tx.hash] = tx
+    @node.relay_propagation[tx.hash] = 0
+    @node.connections.select(&:connected?).sample(send).each {|c| c.send_inv(:tx, tx.hash) }
+
+    EM.add_timer(wait) do
+      received = @node.relay_propagation[tx.hash]
+      total = @node.connections.select(&:connected?).size - send
+      percent = 100.0 / total * received
+      respond("relay_tx", { success: true, hash: tx.hash, propagation: {
+                  received: received, sent: 1, percent: percent } })
+    end
+  rescue
+    respond("relay_tx", { error: $!.message, backtrace: $@ })
+  end
+
+  # Stop the bitcoin node.
   #  bitcoin_node stop
   def handle_stop
     Thread.start { sleep 0.1; @node.stop }
     {:state => "Stopping..."}
   end
 
-  # list all commands
+  # List all available commands.
   #  bitcoin_node help
   def handle_help
     self.methods.grep(/^handle_(.*?)/).map {|m| m.to_s.sub(/^(.*?)_/, '')}
   end
 
+  # Validate and store given block (in hex) as if it was received by a peer.
+  #  bitcoin_node store_block <block in hex>
+  def handle_store_block hex
+    block = Bitcoin::P::Block.new(hex.htb)
+    @node.queue << [:block, block]
+    { queued: [ :block, block.hash ] }
+  end
+
+  # Store given transaction (in hex) as if it was received by a peer.
+  #  bitcoin_node store_tx <tx in hex>
+  def handle_store_tx hex
+    tx = Bitcoin::P::Tx.new(hex.htb)
+    @node.queue << [:tx, tx]
+    { queued: [ :tx, tx.hash ] }
+  end
+
   # format node uptime
   def format_uptime t
     mm, ss = t.divmod(60)            #=> [4515, 21]

data/lib/bitcoin/network/connection_handler.rb

@@ -1,18 +1,24 @@
+# encoding: ascii-8bit
+
 require 'eventmachine'
 
 module Bitcoin::Network
 
   # Node network connection to a peer. Handles all the communication with a specific peer.
-  # TODO: incoming/outgoing?
   class ConnectionHandler < EM::Connection
 
+    LATENCY_MAX = (5*60*1000) # 5min in ms
+
     include Bitcoin
     include Bitcoin::Storage
 
-    attr_reader :host, :port, :state, :version
+    attr_reader :host, :port, :version, :direction
 
-    def hth(h); h.unpack("H*")[0]; end
-    def htb(h); [h].pack("H*"); end
+    # :new, :handshake, :connected, :disconnected
+    attr_reader :state
+
+    # latency of this connection based on last ping/pong
+    attr_reader :latency_ms
 
     def log
       @log ||= Logger::LogWrapper.new("#@host:#@port", @node.log)
@@ -24,12 +30,17 @@ module Bitcoin::Network
     end
 
     # create connection to +host+:+port+ for given +node+
-    def initialize node, host, port
-      @node, @host, @port = node, host, port
+    def initialize node, host, port, direction
+      @node, @host, @port, @direction = node, host, port, direction
       @parser = Bitcoin::Protocol::Parser.new(self)
       @state = :new
       @version = nil
       @started = nil
+      @port, @host = *Socket.unpack_sockaddr_in(get_peername)  if get_peername
+      @ping_nonce = nil
+      @latency_ms = nil
+      @lock = Monitor.new
+      @last_getblocks = []  # the last few getblocks messages received
     rescue Exception
       log.fatal { "Error in #initialize" }
       p $!; puts $@; exit
@@ -37,36 +48,73 @@ module Bitcoin::Network
 
     # check if connection is wanted, begin handshake if it is, disconnect if not
     def post_init
-      if @node.connections.size >= @node.config[:max][:connections]
-        return close_connection  unless @node.config[:connect].include?([@host, @port.to_s])
+      if incoming?
+        begin_handshake
       end
-      log.info { "Connected to #{@host}:#{@port}" }
-      @state = :established
-      @node.connections << self
-      on_handshake_begin
     rescue Exception
       log.fatal { "Error in #post_init" }
-      p $!; puts $@; exit
+      p $!; puts *$@
+    end
+
+    # only called for outgoing connection
+    def connection_completed
+      begin_handshake
+    rescue Exception
+      log.fatal { "Error in #connection_completed" }
+      p $!; puts *$@
     end
 
     # receive data from peer and invoke Protocol::Parser
     def receive_data data
       #log.debug { "Receiving data (#{data.size} bytes)" }
-      @parser.parse(data)
+      @lock.synchronize { @parser.parse(data) }
+    rescue
+      log.warn { "Error handling data: #{data.hth}" }
+      p $!; puts *$@
     end
 
     # connection closed; notify listeners and cleanup connection from node
     def unbind
-      log.info { "Disconnected #{@host}:#{@port}" }
-      @node.notifiers[:connection].push([:disconnected, [@host, @port]])
+      log.info { "Disconnected" }
+      @node.push_notification(:connection, [:disconnected, [@host, @port]])
       @state = :disconnected
       @node.connections.delete(self)
     end
 
+    # begin handshake
+    # TODO: disconnect if we don't complete within a reasonable time
+    def begin_handshake
+      if incoming? && !@node.accept_connections?
+        return close_connection  unless @node.config[:connect].include?([@host, @port.to_s])
+      end
+      log.info { "Established #{@direction} connection" }
+      @node.connections << self
+      @state = :handshake
+      # incoming connections wait to receive a version
+      send_version if outgoing?
+    rescue Exception
+      log.fatal { "Error in #begin_handshake" }
+      p $!; puts *$@
+    end
+
+    # complete handshake; set state, started time, notify listeners and add address to Node
+    def complete_handshake
+      if @state == :handshake
+        log.debug { 'Handshake completed' }
+        @state = :connected
+        @started = Time.now
+        @node.push_notification(:connection, [:connected, info])
+        @node.addrs << addr
+      end
+    end
+
     # received +inv_tx+ message for given +hash+.
     # add to inv_queue, unlesss maximum is reached
     def on_inv_transaction(hash)
-      log.debug { ">> inv transaction: #{hth(hash)}" }
+      log.debug { ">> inv transaction: #{hash.hth}" }
+      if @node.relay_propagation.keys.include?(hash.hth)
+        @node.relay_propagation[hash.hth] += 1
+      end
       return  if @node.inv_queue.size >= @node.config[:max][:inv]
       @node.queue_inv([:tx, hash, self])
     end
@@ -74,7 +122,7 @@ module Bitcoin::Network
     # received +inv_block+ message for given +hash+.
     # add to inv_queue, unless maximum is reached
     def on_inv_block(hash)
-      log.debug { ">> inv block: #{hth(hash)}" }
+      log.debug { ">> inv block: #{hash.hth}" }
       return  if @node.inv_queue.size >= @node.config[:max][:inv]
       @node.queue_inv([:block, hash, self])
     end
@@ -82,8 +130,9 @@ module Bitcoin::Network
     # received +get_tx+ message for given +hash+.
     # send specified tx if we have it
     def on_get_transaction(hash)
-      log.debug { ">> get transaction: #{hash.unpack("H*")[0]}" }
-      tx = @node.store.get_tx(hash.unpack("H*")[0])
+      log.debug { ">> get transaction: #{hash.hth}" }
+      tx = @node.store.get_tx(hash.hth)
+      tx ||= @node.relay_tx[hash.hth]
       return  unless tx
       pkt = Bitcoin::Protocol.pkt("tx", tx.to_payload)
       log.debug { "<< tx: #{tx.hash}" }
@@ -92,16 +141,13 @@ module Bitcoin::Network
 
     # received +get_block+ message for given +hash+.
     # send specified block if we have it
-    # TODO
     def on_get_block(hash)
-      log.debug { ">> get block: #{hth(hash)}" }
-    end
-
-    # send +inv+ message with given +type+ for given +obj+
-    def send_inv type, obj
-      pkt = Protocol.inv_pkt(type, [[obj.hash].pack("H*")])
-      log.debug { "<< inv #{type}: #{obj.hash}" }
-      send_data(pkt)
+      log.debug { ">> get block: #{hash.hth}" }
+      blk = @node.store.get_block(hash.hth)
+      return  unless blk
+      pkt = Bitcoin::Protocol.pkt("block", blk.to_payload)
+      log.debug { "<< block: #{blk.hash}" }
+      send_data pkt
     end
 
     # received +addr+ message for given +addr+.
@@ -109,7 +155,7 @@ module Bitcoin::Network
     def on_addr(addr)
       log.debug { ">> addr: #{addr.ip}:#{addr.port} alive: #{addr.alive?}, service: #{addr.service}" }
       @node.addrs << addr
-      @node.notifiers[:addr].push(addr)
+      @node.push_notification(:addr, addr)
     end
 
     # received +tx+ message for given +tx+.
@@ -136,18 +182,23 @@ module Bitcoin::Network
     # received +version+ message for given +version+.
     # send +verack+ message and complete handshake
     def on_version(version)
-      log.info { ">> version: #{version.version}" }
+      log.debug { ">> version: #{version.version}" }
+      @node.external_ips << version.to.split(":")[0]
       @version = version
-      log.info { "<< verack" }
+      log.debug { "<< verack" }
       send_data( Protocol.verack_pkt )
-      on_handshake_complete
+
+      # sometimes other nodes don't bother to send a verack back,
+      # but we can consider the handshake complete once we sent ours.
+      # apparently it can happen on incoming and outgoing connections alike
+      complete_handshake
     end
 
     # received +verack+ message.
     # complete handshake if it isn't completed already
     def on_verack
-      log.info { ">> verack" }
-      on_handshake_complete  if handshake?
+      log.debug { ">> verack" }
+      complete_handshake if outgoing?
     end
 
     # received +alert+ message for given +alert+.
@@ -156,25 +207,80 @@ module Bitcoin::Network
       log.warn { ">> alert: #{alert.inspect}" }
     end
 
+    # received +getblocks+ message.
+    # TODO: locator fallback
+    def on_getblocks(version, hashes, stop_hash)
+      # remember the last few received getblocks messages and ignore duplicate ones
+      # fixes unexplained issue where remote node is bombarding us with the same getblocks
+      # message over and over (probably related to missing locator fallback handling)
+      return  if @last_getblocks && @last_getblocks.include?([version, hashes, stop_hash])
+      @last_getblocks << [version, hashes, stop_hash]
+      @last_getblocks.shift  if @last_getblocks.size > 3
+
+      blk = @node.store.db[:blk][hash: hashes[0].htb.blob]
+      depth = blk[:depth]  if blk
+      log.info { ">> getblocks #{hashes[0]} (#{depth || 'unknown'})" }
+
+      return  unless depth && depth <= @node.store.get_depth
+      range = (depth+1..depth+500)
+      blocks = @node.store.db[:blk].where(chain: 0, depth: range).select(:hash).all +
+        [@node.store.db[:blk].select(:hash)[chain: 0, depth: depth+502]]
+      send_inv(:block, *blocks.map {|b| b[:hash].hth })
+    end
+
+    # received +getaddr+ message.
+    # send +addr+ message with peer addresses back.
+    def on_getaddr
+      addrs = @node.addrs.select{|a| a.time > Time.now.to_i - 10800 }.shuffle[0..250]
+      log.debug { "<< addr (#{addrs.size})" }
+      send_data P::Addr.pkt(*addrs)
+    end
+
+    # begin handshake; send +version+ message
+    def send_version
+      from = "#{@node.external_ip}:#{@node.config[:listen][1]}"
+      version = Bitcoin::Protocol::Version.new({
+        :version    => 70001,
+        :last_block => @node.store.get_depth,
+        :from       => from,
+        :to         => @host,
+        :user_agent => "/bitcoin-ruby:#{Bitcoin::VERSION}/",
+        #:user_agent => "/Satoshi:0.8.3/",
+      })
+      send_data(version.to_pkt)
+      log.debug { "<< version: #{Bitcoin.network[:protocol_version]}" }
+    end
+
+    # send +inv+ message with given +type+ for given +obj+
+    def send_inv type, *hashes
+      hashes.each_slice(251) do |slice|
+        pkt = Protocol.inv_pkt(type, slice.map(&:htb))
+        log.debug { "<< inv #{type}: #{slice[0][0..16]}" + (slice.size > 1 ? "..#{slice[-1][0..16]}" : "") }
+        send_data(pkt)
+      end
+    end
+
     # send +getdata tx+ message for given tx +hash+
     def send_getdata_tx(hash)
       pkt = Protocol.getdata_pkt(:tx, [hash])
-      log.debug { "<< getdata tx: #{hth(hash)}" }
+      log.debug { "<< getdata tx: #{hash.hth}" }
       send_data(pkt)
     end
 
     # send +getdata block+ message for given block +hash+
     def send_getdata_block(hash)
       pkt = Protocol.getdata_pkt(:block, [hash])
-      log.debug { "<< getdata block: #{hth(hash)}" }
+      log.debug { "<< getdata block: #{hash.hth}" }
       send_data(pkt)
     end
 
     # send +getblocks+ message
     def send_getblocks locator = @node.store.get_locator
-      return get_genesis_block  if @node.store.get_depth == -1
-      pkt = Protocol.pkt("getblocks", [Bitcoin::network[:magic_head],
-          locator.size.chr, *locator.map{|l| htb(l).reverse}, "\x00"*32].join)
+      if @node.store.get_depth == -1
+        EM.add_timer(3) { send_getblocks }
+        return get_genesis_block
+      end
+      pkt = Protocol.getblocks_pkt(@version.version, locator)
       log.info { "<< getblocks: #{locator.first}" }
       send_data(pkt)
     end
@@ -183,7 +289,7 @@ module Bitcoin::Network
     def send_getheaders locator = @node.store.get_locator
       return get_genesis_block  if @node.store.get_depth == -1
       pkt = Protocol.pkt("getheaders", [Bitcoin::network[:magic_head],
-          locator.size.chr, *locator.map{|l| htb(l).reverse}, "\x00"*32].join)
+          locator.size.chr, *locator.map{|l| l.htb_reverse}, "\x00"*32].join)
       log.debug { "<< getheaders: #{locator.first}" }
       send_data(pkt)
     end
@@ -197,30 +303,27 @@ module Bitcoin::Network
     # send +ping+ message
     # TODO: wait for pong and disconnect if it doesn't arrive (and version is new enough)
     def send_ping
-      nonce = rand(0xffffffff)
-      log.debug { "<< ping (#{nonce})" }
-      send_data(Protocol.ping_pkt(nonce))
+      if @version.version > Bitcoin::Protocol::BIP0031_VERSION
+        @latency_ms = LATENCY_MAX
+        @ping_nonce = rand(0xffffffff)
+        @ping_time = Time.now
+        log.debug { "<< ping (#{@ping_nonce})" }
+        send_data(Protocol.ping_pkt(@ping_nonce))
+      else
+        # set latency to 5 seconds, terrible but this version should be obsolete now
+        @latency_ms = (5*1000) 
+        log.debug { "<< ping" }
+        send_data(Protocol.ping_pkt)
+      end
     end
 
     # ask for the genesis block
     def get_genesis_block
       log.info { "Asking for genesis block" }
-      pkt = Protocol.getdata_pkt(:block, [htb(Bitcoin::network[:genesis_hash])])
+      pkt = Protocol.getdata_pkt(:block, [Bitcoin::network[:genesis_hash].htb])
       send_data(pkt)
     end
 
-    # complete handshake; set state, started time, notify listeners and add address to Node
-    def on_handshake_complete
-      return  unless handshake?
-      log.debug { "handshake complete" }
-      @state = :connected
-      @started = Time.now
-      @node.notifiers[:connection].push([:connected, info])
-      @node.addrs << addr
-      # send_getaddr
-      # EM.add_periodic_timer(15) { send_ping }
-    end
-
     # received +ping+ message with given +nonce+.
     # send +pong+ message back, if +nonce+ is set.
     # network versions <=60000 don't set the nonce and don't expect a pong.
@@ -230,28 +333,33 @@ module Bitcoin::Network
     end
 
     # received +pong+ message with given +nonce+.
-    # TODO: see #send_ping
     def on_pong nonce
-      log.debug { ">> pong (#{nonce})" }
+      if @ping_nonce == nonce
+        @latency_ms = (Time.now - @ping_time) * 1000.0
+      end
+      log.debug { ">> pong (#{nonce}), latency: #{@latency_ms.to_i}ms" }
     end
 
     # begin handshake; send +version+ message
     def on_handshake_begin
       @state = :handshake
-      block   = @node.store.get_depth
-      from    = "127.0.0.1:8333"
-      from_id = Bitcoin::Protocol::Uniq
-      to      = @node.config[:listen].join(':')
-
-      pkt = Protocol.version_pkt(from_id, from, to, block)
-      log.info { "<< version (#{Bitcoin::Protocol::VERSION})" }
-      send_data(pkt)
+      from = "#{@node.external_ip}:#{@node.config[:listen][1]}"
+      version = Bitcoin::Protocol::Version.new({
+        :version    => 70001,
+        :last_block => @node.store.get_depth,
+        :from       => from,
+        :to         => @host,
+        :user_agent => "/bitcoin-ruby:#{Bitcoin::VERSION}/",
+        #:user_agent => "/Satoshi:0.8.1/",
+      })
+      send_data(version.to_pkt)
+      log.debug { "<< version (#{Bitcoin.network[:protocol_version]})" }
     end
 
     # get Addr object for this connection
     def addr
       return @addr  if @addr
-      @addr = Bitcoin::Protocol::Addr.new
+      @addr = P::Addr.new
       @addr.time, @addr.service, @addr.ip, @addr.port =
         Time.now.tv_sec, @version.services, @host, @port
       @addr
@@ -265,10 +373,14 @@ module Bitcoin::Network
     def info
       {
         :host => @host, :port => @port, :state => @state,
-        :version => @version.version, :block => @version.block, :started => @started.to_i,
-        :user_agent => @version.user_agent
+        :version => (@version.version rescue 0), :block => @version.last_block,
+        :started => @started.to_i, :user_agent => @version.user_agent
       }
     end
+
+    def incoming?; @direction == :in; end
+    def outgoing?; @direction == :out; end
+
   end
 
 end