bitcoin-ruby 0.0.18 → 0.0.19

data/lib/bitcoin/protocol/block.rb

@@ -2,9 +2,8 @@
 
 module Bitcoin
   module Protocol
-
+    # https://en.bitcoin.it/wiki/Protocol_documentation#block
     class Block
-
       BLOCK_VERSION_DEFAULT     = (1 << 0)
       BLOCK_VERSION_AUXPOW      = (1 << 8)
       BLOCK_VERSION_CHAIN_START = (1 << 16)
@@ -15,8 +14,10 @@ module Bitcoin
 
       # previous block hash
       attr_accessor :prev_block_hash
-      alias :prev_block :prev_block_hash
-      def prev_block=(hash); @prev_block_hash = hash; end
+      alias prev_block prev_block_hash
+      def prev_block=(hash)
+        @prev_block_hash = hash
+      end
 
       # transactions (Array of Tx)
       attr_accessor :tx
@@ -44,7 +45,7 @@ module Bitcoin
 
       attr_reader :partial_merkle_tree
 
-      alias :transactions :tx
+      alias transactions tx
 
       # compare to another block
       def ==(other)
@@ -52,16 +53,17 @@ module Bitcoin
       end
 
       def binary_hash
-        [@hash].pack("H*")
+        [@hash].pack('H*')
       end
 
       def prev_block_hex
-        @prev_block_hex ||= @prev_block_hash.reverse.unpack("H*")[0]
+        @prev_block_hex ||= @prev_block_hash.reverse.unpack('H*')[0]
       end
 
       # create block from raw binary +data+
-      def initialize(data=nil)
+      def initialize(data = nil)
         @tx = []
+        @payload = nil
         parse_data_from_io(data) if data
       end
 
@@ -72,68 +74,74 @@ module Bitcoin
       end
 
       # parse raw binary data
-      def parse_data_from_io(buf, header_only=false)
+      def parse_data_from_io(buf, header_only = false)
         buf = buf.is_a?(String) ? StringIO.new(buf) : buf
-        @ver, @prev_block_hash, @mrkl_root, @time, @bits, @nonce = buf.read(80).unpack("Va32a32VVV")
+        @ver, @prev_block_hash, @mrkl_root, @time, @bits, @nonce = buf.read(80).unpack('Va32a32VVV')
         recalc_block_hash
 
-        if Bitcoin.network[:auxpow_chain_id] != nil && (@ver & BLOCK_VERSION_AUXPOW) > 0
+        if !Bitcoin.network[:auxpow_chain_id].nil? && (@ver & BLOCK_VERSION_AUXPOW) > 0
           @aux_pow = AuxPow.new(nil)
           @aux_pow.parse_data_from_io(buf)
         end
 
         return buf if buf.eof?
 
-        if header_only == :filtered
-          @tx_count = buf.read(4).unpack("V")[0]
-
-          nhashes = Protocol.unpack_var_int_from_io(buf)
-          hashes = []
-          nhashes.times do
-            hashes << buf.read(256 / 8)
-          end
-
-          nflags = Protocol.unpack_var_int_from_io(buf)
-          flags = buf.read(nflags)
-
-          @partial_merkle_tree = PartialMerkleTree.new(@tx_count, hashes, flags)
-          @partial_merkle_tree.set_value
-
-          return buf
-        end
+        return parse_filtered_header(buf) if header_only == :filtered
 
         tx_size = Protocol.unpack_var_int_from_io(buf)
         @tx_count = tx_size
         return buf if header_only
 
-        tx_size.times{
+        tx_size.times do
           break if payload == true
           return buf if buf.eof?
 
           t = Tx.new(nil)
-          payload = t.parse_data_from_io(buf)
+          t.parse_data_from_io(buf)
           @tx << t
-        }
+        end
 
         @payload = to_payload
         buf
       end
 
+      def parse_filtered_header(buf)
+        @tx_count = buf.read(4).unpack('V')[0]
+
+        nhashes = Protocol.unpack_var_int_from_io(buf)
+        hashes = []
+        nhashes.times do
+          hashes << buf.read(256 / 8)
+        end
+
+        nflags = Protocol.unpack_var_int_from_io(buf)
+        flags = buf.read(nflags)
+
+        @partial_merkle_tree = PartialMerkleTree.new(@tx_count, hashes, flags)
+        @partial_merkle_tree.assign_value
+
+        buf
+      end
+
       # recalculate the block hash
       def recalc_block_hash
-        @hash = Bitcoin.block_hash(@prev_block_hash.reverse_hth, @mrkl_root.reverse_hth, @time, @bits, @nonce, @ver)
+        @hash = Bitcoin.block_hash(
+          @prev_block_hash.reverse_hth, @mrkl_root.reverse_hth, @time, @bits, @nonce, @ver
+        )
       end
 
       def recalc_block_scrypt_hash
-        @scrypt_hash = Bitcoin.block_scrypt_hash(@prev_block_hash.reverse_hth, @mrkl_root.reverse_hth, @time, @bits, @nonce, @ver)
+        @scrypt_hash = Bitcoin.block_scrypt_hash(
+          @prev_block_hash.reverse_hth, @mrkl_root.reverse_hth, @time, @bits, @nonce, @ver
+        )
       end
 
       def recalc_mrkl_root
         @mrkl_root = if partial_merkle_tree
-          partial_merkle_tree.root.value.htb_reverse
-        else
-          Bitcoin.hash_mrkl_tree( @tx.map(&:hash) ).last.htb_reverse
-        end
+                       partial_merkle_tree.root.value.htb_reverse
+                     else
+                       Bitcoin.hash_mrkl_tree(@tx.map(&:hash)).last.htb_reverse
+                     end
       end
 
       # verify mrkl tree
@@ -141,7 +149,7 @@ module Bitcoin
         if partial_merkle_tree
           partial_merkle_tree.valid_tree?(@mrkl_root.reverse_hth)
         else
-          @mrkl_root.reverse_hth == Bitcoin.hash_mrkl_tree( @tx.map(&:hash) ).last
+          @mrkl_root.reverse_hth == Bitcoin.hash_mrkl_tree(@tx.map(&:hash)).last
         end
       end
 
@@ -156,16 +164,21 @@ module Bitcoin
       # get the block header info
       # [<version>, <prev_block>, <merkle_root>, <time>, <bits>, <nonce>, <txcount>, <size>]
       def header_info
-        [@ver, @prev_block_hash.reverse_hth, @mrkl_root.reverse_hth, Time.at(@time), @bits, @nonce, @tx.size, @payload.size]
+        [
+          @ver, @prev_block_hash.reverse_hth, @mrkl_root.reverse_hth,
+          Time.at(@time), @bits, @nonce, @tx.size, @payload.size
+        ]
       end
 
       # convert to raw binary format
       def to_payload
-        head = [@ver, @prev_block_hash, @mrkl_root, @time, @bits, @nonce].pack("Va32a32VVV")
-        head << @aux_pow.to_payload  if @aux_pow
-        return head if @tx.size == 0
+        @aux_pow ||= nil
+        head = [@ver, @prev_block_hash, @mrkl_root, @time, @bits, @nonce].pack('Va32a32VVV')
+        head << @aux_pow.to_payload if @aux_pow
+        return head if @tx.empty?
+
         head << Protocol.pack_var_int(@tx.size)
-        @tx.each{|tx| head << tx.to_payload }
+        @tx.each { |tx| head << tx.to_payload }
         head
       end
 
@@ -175,11 +188,11 @@ module Bitcoin
           'hash' => @hash, 'ver' => @ver,
           'prev_block' => @prev_block_hash.reverse_hth, 'mrkl_root' => @mrkl_root.reverse_hth,
           'time' => @time, 'bits' => @bits, 'nonce' => @nonce,
-          'n_tx' => @tx.size, 'size' => (@payload||to_payload).bytesize,
-          'tx' => @tx.map{|i| i.to_hash(options) },
-          'mrkl_tree' => Bitcoin.hash_mrkl_tree( @tx.map{|i| i.hash } )
+          'n_tx' => @tx.size, 'size' => (@payload || to_payload).bytesize,
+          'tx' => @tx.map { |i| i.to_hash(options) },
+          'mrkl_tree' => Bitcoin.hash_mrkl_tree(@tx.map(&:hash))
         }
-        h['aux_pow'] = @aux_pow.to_hash  if @aux_pow
+        h['aux_pow'] = @aux_pow.to_hash if @aux_pow
         h
       end
 
@@ -202,75 +215,90 @@ module Bitcoin
       # introduced in block version 2 by BIP_0034
       # blockchain height as seen by the block itself.
       # do not trust this value, instead verify with chain storage.
-      def bip34_block_height(height=nil)
+      def bip34_block_height(height = nil)
         return nil unless @ver >= 2
         if height # generate height binary
-          buf = [height].pack("V").gsub(/\x00+$/,"")
-          [buf.bytesize, buf].pack("Ca*")
+          buf = [height].pack('V').gsub(/\x00+$/, '')
+          [buf.bytesize, buf].pack('Ca*')
         else
           coinbase = @tx.first.inputs.first.script_sig
-          coinbase[1..coinbase[0].ord].ljust(4, "\x00").unpack("V").first
+          coinbase[1..coinbase[0].ord].ljust(4, "\x00").unpack('V').first
         end
-      rescue
+      rescue StandardError
         nil
       end
 
       # convert to json representation as seen in the block explorer.
       # (see also #from_json)
-      def to_json(options = {:space => ''}, *a)
-        JSON.pretty_generate( to_hash(options), options )
+      def to_json(options = { space: '' }, *_)
+        JSON.pretty_generate(to_hash(options), options)
       end
 
       # write json representation to a file
       # (see also #to_json)
       def to_json_file(path)
-        File.open(path, 'wb'){|f| f.print to_json; }
+        File.open(path, 'wb') { |f| f.print to_json; }
       end
 
       # parse ruby hash (see also #to_hash)
-      def self.from_hash(h, do_raise=true)
+      def self.from_hash(h, do_raise = true)
         blk = new(nil)
-        blk.instance_eval{
+        blk.instance_eval do
           @ver, @time, @bits, @nonce = h.values_at('ver', 'time', 'bits', 'nonce')
-          @prev_block_hash, @mrkl_root = h.values_at('prev_block', 'mrkl_root').map{|i| i.htb_reverse }
-          unless h['hash'] == recalc_block_hash
-            raise "Block hash mismatch! Claimed: #{h['hash']}, Actual: #{@hash}" if do_raise
+          @prev_block_hash, @mrkl_root = h.values_at('prev_block', 'mrkl_root').map(&:htb_reverse)
+
+          if do_raise && h['hash'] != recalc_block_hash
+            raise "Block hash mismatch! Claimed: #{h['hash']}, Actual: #{@hash}"
           end
-          @aux_pow = AuxPow.from_hash(h['aux_pow'])  if h['aux_pow']
-          h['tx'].each{|tx| @tx << Tx.from_hash(tx, do_raise) }
-          if h['tx'].any?
-            (raise "Block merkle root mismatch! Block: #{h['hash']}"  unless verify_mrkl_root) if do_raise
+
+          @aux_pow = AuxPow.from_hash(h['aux_pow']) if h['aux_pow']
+
+          h['tx'].each { |tx| @tx << Tx.from_hash(tx, do_raise) }
+          if h['tx'].any? && do_raise && !verify_mrkl_root
+            raise "Block merkle root mismatch! Block: #{h['hash']}"
           end
-        }
+        end
         blk
       end
 
       # convert ruby hash to raw binary
-      def self.binary_from_hash(h); from_hash(h).to_payload; end
+      def self.binary_from_hash(h)
+        from_hash(h).to_payload
+      end
 
       # parse json representation (see also #to_json)
-      def self.from_json(json_string); from_hash( JSON.load(json_string) ); end
+      def self.from_json(json_string)
+        from_hash(JSON.parse(json_string))
+      end
 
       # convert json representation to raw binary
-      def self.binary_from_json(json_string); from_json(json_string).to_payload; end
+      def self.binary_from_json(json_string)
+        from_json(json_string).to_payload
+      end
 
       # convert header to json representation.
-      def header_to_json(options = {:space => ''})
+      def header_to_json(options = { space: '' })
         h = to_hash
-        %w[tx mrkl_tree].each{|k| h.delete(k) }
-        JSON.pretty_generate( h, options )
+        %w[tx mrkl_tree].each { |k| h.delete(k) }
+        JSON.pretty_generate(h, options)
       end
 
       # block header binary output
       def block_header
-        [@ver, @prev_block_hash, @mrkl_root, @time, @bits, @nonce, Protocol.pack_var_int(0)].pack("Va32a32VVVa*")
+        [
+          @ver, @prev_block_hash, @mrkl_root, @time, @bits, @nonce, Protocol.pack_var_int(0)
+        ].pack('Va32a32VVVa*')
       end
 
       # read binary block from a file
-      def self.from_file(path); new( Bitcoin::Protocol.read_binary_file(path) ); end
+      def self.from_file(path)
+        new(Bitcoin::Protocol.read_binary_file(path))
+      end
 
       # read json block from a file
-      def self.from_json_file(path); from_json( Bitcoin::Protocol.read_binary_file(path) ); end
+      def self.from_json_file(path)
+        from_json(Bitcoin::Protocol.read_binary_file(path))
+      end
 
       # get the (statistical) amount of work that was needed to generate this block.
       def block_work
@@ -278,8 +306,6 @@ module Bitcoin
         return 0 if target <= 0
         (2**256) / (target + 1)
       end
-
     end
-
   end
 end

data/lib/bitcoin/protocol/handler.rb

@@ -2,7 +2,7 @@
 
 module Bitcoin
   module Protocol
-
+    # https://en.bitcoin.it/wiki/Protocol_documentation#Message_types
     class Handler
       def on_inv_transaction(hash)
         p ['inv transaction', hash.hth]
@@ -29,15 +29,13 @@ module Bitcoin
       end
 
       def on_block(block)
-        #p ['block', block]
+        # p ['block', block]
         puts block.to_json
       end
 
       def on_error(message, payload)
         p ['error', message, payload]
       end
-
     end
-
   end
 end

data/lib/bitcoin/protocol/parser.rb

@@ -2,23 +2,66 @@
 
 module Bitcoin
   module Protocol
-
+    # https://en.bitcoin.it/wiki/Protocol_documentation#Message_types
     class Parser
       attr_reader :stats
 
-      def initialize(handler=nil)
+      def initialize(handler = nil)
         @h = handler || Handler.new
-        @buf = ""
+        @buf = ''
         @stats = { 'total_packets' => 0, 'total_bytes' => 0, 'total_errors' => 0 }
       end
 
-      def log; @log ||= Bitcoin::Logger.create("parser"); end
+      # rubocop:disable CyclomaticComplexity
+      def process_pkt(command, payload)
+        @stats['total_packets'] += 1
+        @stats['total_bytes'] += payload.bytesize
+        @stats[command] ? (@stats[command] += 1) : @stats[command] = 1
+        case command
+        when 'tx' then @h.on_tx(Tx.new(payload))
+        when 'block' then @h.on_block(Block.new(payload))
+        when 'headers' then parse_headers(payload)
+        when 'inv' then parse_inv(payload, :put)
+        when 'getdata' then parse_inv(payload, :get)
+        when 'addr' then parse_addr(payload)
+        when 'getaddr' then @h.on_getaddr if @h.respond_to?(:on_getaddr)
+        when 'verack' then parse_verack
+        when 'version' then parse_version(payload)
+        when 'alert' then parse_alert(payload)
+        when 'ping' then @h.on_ping(payload.unpack('Q')[0])
+        when 'pong' then @h.on_pong(payload.unpack('Q')[0])
+        when 'getblocks' then @h.on_getblocks(*parse_getblocks(payload)) \
+          if @h.respond_to?(:on_getblocks)
+        when 'getheaders' then @h.on_getheaders(*parse_getblocks(payload)) \
+          if @h.respond_to?(:on_getheaders)
+        when 'mempool' then handle_mempool_request(payload)
+        when 'notfound' then handle_notfound_reply(payload)
+        when 'merkleblock' then parse_mrkle_block(payload)
+        when 'reject' then handle_reject(payload)
+        else
+          parse_error :unknown_packet, [command, payload.hth]
+        end
+      end
+      # rubocop:enable CyclomaticComplexity
+
+      def parse_headers(payload)
+        return unless @h.respond_to?(:on_headers)
+        buf = StringIO.new(payload)
+        count = Protocol.unpack_var_int_from_io(buf)
+        headers = Array.new(count) do
+          break if buf.eof?
+          b = Block.new
+          b.parse_data_from_io(buf, true)
+          b
+        end
+        @h.on_headers(headers)
+      end
 
       # handles inv/getdata packets
-      def parse_inv(payload, type=:put)
+      def parse_inv(payload, type = :put)
         count, payload = Protocol.unpack_var_int(payload)
         payload.each_byte.each_slice(36).with_index do |i, idx|
-          hash = i[4..-1].reverse.pack("C32")
+          hash = i[4..-1].reverse.pack('C32')
           case i[0]
           when 1
             type == :put ? @h.on_inv_transaction(hash) : @h.on_get_transaction(hash)
@@ -33,70 +76,27 @@ module Bitcoin
               @h.on_get_block(hash)
             end
           else
-            parse_error :parse_inv, i.pack("C*")
+            parse_error :parse_inv, i.pack('C*')
           end
         end
       end
 
       def parse_addr(payload)
-        count, payload = Protocol.unpack_var_int(payload)
+        _, payload = Protocol.unpack_var_int(payload)
         payload.each_byte.each_slice(30) do |i|
-          @h.on_addr(Addr.new(i.pack("C*"))) rescue parse_error(:addr, i.pack("C*"))
+          begin
+            @h.on_addr(Addr.new(i.pack('C*')))
+          rescue StandardError
+            parse_error(:addr, i.pack('C*'))
+          end
         end
       end
 
-      def parse_headers(payload)
-        return unless @h.respond_to?(:on_headers)
-        buf = StringIO.new(payload)
-        count = Protocol.unpack_var_int_from_io(buf)
-        headers = count.times.map{
-          break if buf.eof?
-          b = Block.new; b.parse_data_from_io(buf, header_only=true); b
-        }
-        @h.on_headers(headers)
-      end
-
-      def parse_mrkle_block(payload)
-        return unless @h.respond_to?(:on_mrkle_block)
-        b = Block.new
-        b.parse_data_from_io(payload, header_only= :filtered)
-        @h.on_mrkle_block(b)
-      end
-
-      def parse_getblocks(payload)
-        version, payload = payload.unpack('Va*')
-        count,   payload = Protocol.unpack_var_int(payload)
-        buf,     payload = payload.unpack("a#{count*32}a*")
-        hashes    = buf.each_byte.each_slice(32).map{|i| hash = i.reverse.pack("C32").hth }
-        stop_hash = payload[0..32].reverse_hth
-        [version, hashes, stop_hash]
-      end
-
-      def process_pkt(command, payload)
-        @stats['total_packets'] += 1
-        @stats['total_bytes'] += payload.bytesize
-        @stats[command] ? (@stats[command] += 1) : @stats[command] = 1
-        case command
-        when 'tx';       @h.on_tx( Tx.new(payload) )
-        when 'block';    @h.on_block( Block.new(payload) )
-        when 'headers';  parse_headers(payload)
-        when 'inv';      parse_inv(payload, :put)
-        when 'getdata';  parse_inv(payload, :get)
-        when 'addr';     parse_addr(payload)
-        when 'getaddr';  @h.on_getaddr  if @h.respond_to?(:on_getaddr)
-        when 'verack';   @h.respond_to?(:on_verack) ? @h.on_verack : (@h.respond_to?(:on_handshake_complete) ? @h.on_handshake_complete : nil)
-        when 'version';  parse_version(payload)
-        when 'alert';    parse_alert(payload)
-        when 'ping';     @h.on_ping(payload.unpack("Q")[0])
-        when 'pong';     @h.on_pong(payload.unpack("Q")[0])
-        when 'getblocks';   @h.on_getblocks(*parse_getblocks(payload))  if @h.respond_to?(:on_getblocks)
-        when 'getheaders';  @h.on_getheaders(*parse_getblocks(payload))  if @h.respond_to?(:on_getheaders)
-        when 'mempool';  handle_mempool_request(payload)
-        when 'notfound'; handle_notfound_reply(payload)
-        when 'merkleblock'; parse_mrkle_block(payload)
-        when 'reject'; handle_reject(payload)
+      def parse_verack
+        if @h.respond_to?(:on_verack)
+          @h.on_verack
         else
-          parse_error :unknown_packet, [command, payload.hth]
+          @h.respond_to?(:on_handshake_complete) ? @h.on_handshake_complete : nil
         end
       end
 
@@ -106,36 +106,53 @@ module Bitcoin
       end
 
       def parse_alert(payload)
-        return unless @h.respond_to?(:on_alert)
-        @h.on_alert Bitcoin::Protocol::Alert.parse(payload)
+        # nop (https://github.com/lian/bitcoin-ruby/issues/268)
       end
 
-      def handle_reject(payload)
-        return unless @h.respond_to?(:on_reject)
-        @h.on_reject Bitcoin::Protocol::Reject.parse(payload)
+      def parse_getblocks(payload)
+        version, payload = payload.unpack('Va*')
+        count, payload = Protocol.unpack_var_int(payload)
+        buf, payload = payload.unpack("a#{count * 32}a*")
+        hashes = buf.each_byte.each_slice(32).map { |i| i.reverse.pack('C32').hth }
+        stop_hash = payload[0..32].reverse_hth
+        [version, hashes, stop_hash]
       end
 
       # https://en.bitcoin.it/wiki/BIP_0035
-      def handle_mempool_request(payload)
-        return unless @version.fields[:version] >= 60002           # Protocol version >= 60002
-        return unless (@version.fields[:services] & Bitcoin::Protocol::Version::NODE_NETWORK) == 1 # NODE_NETWORK bit set in Services
+      def handle_mempool_request(*_)
+        return unless @version.fields[:version] >= 60_002 # Protocol version >= 60002
+        return unless (
+          @version.fields[:services] & Bitcoin::Protocol::Version::NODE_NETWORK
+        ) == 1 # NODE_NETWORK bit set in Services
         @h.on_mempool if @h.respond_to?(:on_mempool)
       end
 
       def handle_notfound_reply(payload)
         return unless @h.respond_to?(:on_notfound)
-        count, payload = Protocol.unpack_var_int(payload)
+        _, payload = Protocol.unpack_var_int(payload)
         payload.each_byte.each_slice(36) do |i|
-          hash = i[4..-1].reverse.pack("C32")
+          hash = i[4..-1].reverse.pack('C32')
           case i[0]
-          when 1; @h.on_notfound(:tx, hash)
-          when 2; @h.on_notfound(:block, hash)
+          when 1 then @h.on_notfound(:tx, hash)
+          when 2 then @h.on_notfound(:block, hash)
           else
-            parse_error(:notfound, [i.pack("C*"), hash])
+            parse_error(:notfound, [i.pack('C*'), hash])
           end
         end
       end
 
+      def parse_mrkle_block(payload)
+        return unless @h.respond_to?(:on_mrkle_block)
+        b = Block.new
+        b.parse_data_from_io(payload, :filtered)
+        @h.on_mrkle_block(b)
+      end
+
+      def handle_reject(payload)
+        return unless @h.respond_to?(:on_reject)
+        @h.on_reject Bitcoin::Protocol::Reject.parse(payload)
+      end
+
       def parse(buf)
         @buf += buf
         while parse_buffer; end
@@ -143,52 +160,51 @@ module Bitcoin
       end
 
       def parse_buffer
-        head_magic = Bitcoin::network[:magic_head]
+        head_magic = Bitcoin.network[:magic_head]
         head_size  = 24
         return false if @buf.size < head_size
 
-        magic, cmd, length, checksum = @buf.unpack("a4A12Va4")
-        payload = @buf[head_size...head_size+length]
+        magic, cmd, length, checksum = @buf.unpack('a4A12Va4')
+        payload = @buf[head_size...head_size + length]
 
-        unless magic == head_magic
-          handle_stream_error(:close, "head_magic not found")
-          @buf = ''
-        else
+        if magic == head_magic
 
-          if Digest::SHA256.digest(Digest::SHA256.digest( payload ))[0...4] != checksum
-            if (length < 50000) && (payload.size < length)
+          if Digest::SHA256.digest(Digest::SHA256.digest(payload))[0...4] != checksum
+            if (length < 50_000) && (payload.size < length)
               size_info = [payload.size, length].join('/')
               handle_stream_error(:debug, "chunked packet stream (#{size_info})")
             else
-              handle_stream_error(:close, "checksum mismatch")
+              handle_stream_error(:close, 'checksum mismatch')
             end
             return
           end
-          @buf = @buf[head_size+length..-1] || ""
+          @buf = @buf[head_size + length..-1] || ''
 
           process_pkt(cmd, payload)
+        else
+          handle_stream_error(:close, 'head_magic not found')
+          @buf = ''
         end
 
         # not empty yet? parse more.
-        @buf[0] != nil
+        !@buf[0].nil?
       end
 
       def handle_stream_error(type, msg)
+        # TODO: replace by writing a real logger/exception handler
         case type
         when :close
-          log.debug {"closing packet stream (#{msg})"}
+          puts "closing packet stream (#{msg})"
         else
-          log.debug { [type, msg] }
+          puts [type, msg].inspect
         end
       end
 
-      def parse_error *err
+      def parse_error(*err)
         @stats['total_errors'] += 1
         return unless @h.respond_to?(:on_error)
-        @h.on_error *err
+        @h.on_error(*err)
       end
-
-    end # Parser
-
+    end
   end
 end