bitcoin-ruby 0.0.7 → 0.0.8

data/lib/bitcoin/key.rb

@@ -5,6 +5,8 @@ module Bitcoin
   # Elliptic Curve key as used in bitcoin.
   class Key
 
+    attr_reader :key
+
     # Generate a new keypair.
     #  Bitcoin::Key.generate
     def self.generate(opts={compressed: true})
@@ -54,6 +56,7 @@ module Bitcoin
     # Set the private key to +priv+ (in hex).
     def priv= priv
       set_priv(priv)
+      regenerate_pubkey
     end
 
     # Get the public key (in hex).
@@ -98,12 +101,7 @@ module Bitcoin
     #  key1 = Bitcoin::Key.generate
     #  sig = key1.sign("some data")
     def sign(data)
-      sig = @key.dsa_sign_asn1(data)
-      if Script::is_low_der_signature?(sig)
-        sig
-      else
-        Bitcoin::OpenSSL_EC.signature_to_low_s(sig)
-      end
+      Bitcoin.sign_data(key, data)
     end
 
     # Verify signature +sig+ for +data+.

data/lib/bitcoin/logger.rb

@@ -2,6 +2,17 @@
 
 begin
   require 'log4r'
+  # 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
 rescue LoadError
 end
 

data/lib/bitcoin/protocol.rb

@@ -19,6 +19,7 @@ module Bitcoin
     autoload :Block,   'bitcoin/protocol/block'
     autoload :Addr,    'bitcoin/protocol/address'
     autoload :Alert,   'bitcoin/protocol/alert'
+    autoload :Reject,  'bitcoin/protocol/reject'
     autoload :Version, 'bitcoin/protocol/version'
     autoload :AuxPow,  'bitcoin/protocol/aux_pow'
 
@@ -72,15 +73,27 @@ module Bitcoin
     end
 
     def self.unpack_var_string_array(payload) # unpacks set<string>
-      size, payload = unpack_var_int(payload)
-      return [nil, payload] if size == 0
-      [(0...size).map{ s, payload = unpack_var_string(payload); s }, payload]
+      buf = StringIO.new(payload)
+      size = unpack_var_int_from_io(buf)
+      return [nil, buf.read] if size == 0
+      strings = []
+      size.times{
+        break if buf.eof?
+        strings << unpack_var_string_from_io(buf)
+      }
+      [strings, buf.read]
     end
 
     def self.unpack_var_int_array(payload) # unpacks set<int>
-      size, payload = unpack_var_int(payload)
-      return [nil, payload] if size == 0
-      [(0...size).map{ i, payload = unpack_var_int(payload); i }, payload]
+      buf = StringIO.new(payload)
+      size =  unpack_var_int_from_io(buf)
+      return [nil, buf.read] if size == 0
+      ints = []
+      size.times{
+        break if buf.eof?
+        ints << unpack_var_int_from_io(buf)
+      }
+      [ints, buf.read]
     end
 
     def self.unpack_boolean(payload)

data/lib/bitcoin/protocol/aux_pow.rb

@@ -4,25 +4,40 @@ module Bitcoin
   module Protocol
 
     # Auxiliary Proof-of-Work for merge-mined blockchains
+    # See https://en.bitcoin.it/wiki/Merged_mining_specification.
+    #
+    # The AuxPow contains all data needed to verify that the child
+    # block was included in the parents coinbase transaction, and
+    # the parent satisfies the difficulty target.
+    #
+    # It encodes the +parent_block+ header, and its +coinbase_tx+.
+    # The +coinbase_branch+ and +coinbase_index+ can be used to recalculate
+    # the parent blocks merkle root and prove the coinbase transaction is
+    # really included in it.
+    # The +chain_branch+ and +chain_index+ are used to link the child block
+    # to the merkle root contained in the +coinbase_tx+. (So there can be
+    # more than one merge-mined chain)
+    #
+    # TODO: decode merged-mining data from +coinbase_tx+
     class AuxPow
 
-      # Coinbase transaction linking the aux to its parent block
-      attr_accessor :tx
+      # Coinbase transaction of the parent block, linking to the child block
+      attr_accessor :coinbase_tx
 
-      # Hash of the block header
+      # Hash of the parent block header
       attr_accessor :block_hash
 
-      # Merkle branches to bring the transaction to the block's merkle root
-      attr_accessor :branch
+      # Merkle branch linking the +coinbase_tx+ to the +parent_block+
+      attr_accessor :coinbase_branch
 
-      # Index of this transaction in the merkle tree
-      attr_accessor :mrkl_index
+      # Index of the +coinbase_tx+ in the parent blocks merkle tree
+      attr_accessor :coinbase_index
 
-      # Merkle branches linking this aux chains to the aux root
-      attr_accessor :aux_branch
+      # Merkle branch linking the child block to the +coinbase_tx+
+      attr_accessor :chain_branch
 
-      # Index of "this" block chain in the aux chain list
-      attr_accessor :aux_index
+      # Index of the child block in the chain merkle tree
+      attr_accessor :chain_index
 
       # Parent block header
       attr_accessor :parent_block
@@ -32,47 +47,32 @@ module Bitcoin
       end
 
       def parse_data(data)
-        @tx = P::Tx.new(nil)
-        payload = @tx.parse_data(data)
-        @block_hash, payload = payload.unpack("a32a*")
-
-        branch_count, payload = P.unpack_var_int(payload)
-        @branch = []
-        branch_count.times {
-          b, payload = payload.unpack("a32a*")
-          @branch << b
-        }
-        @mrkl_index, payload = payload.unpack("Ia*")
-
-        @aux_branch = []
-        aux_branch_count, payload = P.unpack_var_int(payload)
-        aux_branch_count.times {
-          b, payload = payload.unpack("a32a*")
-          @aux_branch << b
-        }
-
-        @aux_index, payload = payload.unpack("Ia*")
-        block, payload = payload.unpack("a80a*")
-        @parent_block = P::Block.new(block)
-
-        payload
+        buf = StringIO.new(data)
+        parse_data_from_io(buf)
+        buf.eof? ? '' : buf.read
       end
 
       def parse_data_from_io(data)
-        @tx = P::Tx.new(nil)
-        @tx.parse_data_from_io(data)
+        @coinbase_tx = P::Tx.new(nil)
+        @coinbase_tx.parse_data_from_io(data)
 
         @block_hash = data.read(32)
-        branch_count = P.unpack_var_int_from_io(data)
-        @branch = []
-        branch_count.times{ @branch << data.read(32) }
-        @mrkl_index = data.read(4).unpack("I")[0]
+        coinbase_branch_count = P.unpack_var_int_from_io(data)
+        @coinbase_branch = []
+        coinbase_branch_count.times{
+          break if data.eof?
+          @coinbase_branch << data.read(32).reverse.hth
+        }
+        @coinbase_index = data.read(4).unpack("I")[0]
 
-        @aux_branch = []
-        aux_branch_count = P.unpack_var_int_from_io(data)
-        aux_branch_count.times{ @aux_branch << data.read(32) }
+        @chain_branch = []
+        chain_branch_count = P.unpack_var_int_from_io(data)
+        chain_branch_count.times{
+          break if data.eof?
+          @chain_branch << data.read(32).reverse.hth
+        }
 
-        @aux_index = data.read(4).unpack("I")[0]
+        @chain_index = data.read(4).unpack("I")[0]
         block = data.read(80)
         @parent_block = P::Block.new(block)
 
@@ -81,14 +81,14 @@ module Bitcoin
 
 
       def to_payload
-        payload = @tx.to_payload
+        payload = @coinbase_tx.to_payload
         payload << @block_hash
-        payload << P.pack_var_int(@branch.count)
-        payload << @branch.join
-        payload << [@mrkl_index].pack("I")
-        payload << P.pack_var_int(@aux_branch.count)
-        payload << @aux_branch.join
-        payload << [@aux_index].pack("I")
+        payload << P.pack_var_int(@coinbase_branch.count)
+        payload << @coinbase_branch.map(&:htb).map(&:reverse).join
+        payload << [@coinbase_index].pack("I")
+        payload << P.pack_var_int(@chain_branch.count)
+        payload << @chain_branch.map(&:htb).map(&:reverse).join
+        payload << [@chain_index].pack("I")
         payload << @parent_block.to_payload
         payload
       end
@@ -96,24 +96,24 @@ module Bitcoin
       def self.from_hash h
         aux_pow = new(nil)
         aux_pow.instance_eval do
-          @tx = P::Tx.from_hash(h['tx'])
+          @coinbase_tx = P::Tx.from_hash(h['coinbase_tx'])
           @block_hash = h['block_hash'].htb
-          @branch = h['branch'].map(&:htb)
-          @mrkl_index = h['mrkl_index']
-          @aux_branch = h['aux_branch'].map(&:htb)
-          @aux_index = h['aux_index']
+          @coinbase_branch = h['coinbase_branch']
+          @coinbase_index = h['coinbase_index']
+          @chain_branch = h['chain_branch']
+          @chain_index = h['chain_index']
           @parent_block = P::Block.from_hash(h['parent_block'])
         end
         aux_pow
       end
 
       def to_hash
-        { 'tx' => @tx.to_hash,
+        { 'coinbase_tx' => @coinbase_tx.to_hash,
           'block_hash' => @block_hash.hth,
-          'branch' => @branch.map(&:hth),
-          'mrkl_index' => @mrkl_index,
-          'aux_branch' => @aux_branch.map(&:hth),
-          'aux_index' => @aux_index,
+          'coinbase_branch' => @coinbase_branch,
+          'coinbase_index' => @coinbase_index,
+          'chain_branch' => @chain_branch,
+          'chain_index' => @chain_index,
           'parent_block' => @parent_block.to_hash }
       end
 

data/lib/bitcoin/protocol/block.rb

@@ -14,7 +14,9 @@ module Bitcoin
       attr_accessor :hash
 
       # previous block hash
-      attr_accessor :prev_block
+      attr_accessor :prev_block_hash
+      alias :prev_block :prev_block_hash
+      def prev_block=(hash); @prev_block_hash = hash; end
 
       # transactions (Array of Tx)
       attr_accessor :tx
@@ -52,7 +54,7 @@ module Bitcoin
       end
 
       def prev_block_hex
-        @prev_block_hex ||= @prev_block.reverse.unpack("H*")[0]
+        @prev_block_hex ||= @prev_block_hash.reverse.unpack("H*")[0]
       end
 
       # create block from raw binary +data+
@@ -70,7 +72,7 @@ module Bitcoin
       # parse raw binary data
       def parse_data_from_io(buf, header_only=false)
         buf = buf.is_a?(String) ? StringIO.new(buf) : buf
-        @ver, @prev_block, @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
@@ -84,7 +86,10 @@ module Bitcoin
         @tx_count = tx_size
         return buf if header_only
 
-        tx_size.times{  break if payload == true
+        tx_size.times{
+          break if payload == true
+          return buf if buf.eof?
+
           t = Tx.new(nil)
           payload = t.parse_data_from_io(buf)
           @tx << t
@@ -96,11 +101,11 @@ module Bitcoin
 
       # recalculate the block hash
       def recalc_block_hash
-        @hash = Bitcoin.block_hash(@prev_block.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.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
@@ -115,12 +120,12 @@ module Bitcoin
       # get the block header info
       # [<version>, <prev_block>, <merkle_root>, <time>, <bits>, <nonce>, <txcount>, <size>]
       def header_info
-        [@ver, @prev_block.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, @mrkl_root, @time, @bits, @nonce].pack("Va32a32VVV")
+        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
         head << Protocol.pack_var_int(@tx.size)
@@ -129,13 +134,13 @@ module Bitcoin
       end
 
       # convert to ruby hash (see also #from_hash)
-      def to_hash
+      def to_hash(options = {})
         h = {
           'hash' => @hash, 'ver' => @ver,
-          'prev_block' => @prev_block.reverse_hth, 'mrkl_root' => @mrkl_root.reverse_hth,
+          '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 },
+          'tx' => @tx.map{|i| i.to_hash(options) },
           'mrkl_tree' => Bitcoin.hash_mrkl_tree( @tx.map{|i| i.hash } )
         }
         h['aux_pow'] = @aux_pow.to_hash  if @aux_pow
@@ -177,7 +182,7 @@ module Bitcoin
       # 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 )
+        JSON.pretty_generate( to_hash(options), options )
       end
 
       # write json representation to a file
@@ -191,12 +196,12 @@ module Bitcoin
         blk = new(nil)
         blk.instance_eval{
           @ver, @time, @bits, @nonce = h.values_at('ver', 'time', 'bits', 'nonce')
-          @prev_block, @mrkl_root = h.values_at('prev_block', 'mrkl_root').map{|i| i.htb_reverse }
+          @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
           end
           @aux_pow = AuxPow.from_hash(h['aux_pow'])  if h['aux_pow']
-          h['tx'].each{|tx| @tx << Tx.from_hash(tx) }
+          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
           end
@@ -222,7 +227,7 @@ module Bitcoin
 
       # block header binary output
       def block_header
-        [@ver, @prev_block, @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

data/lib/bitcoin/protocol/handler.rb

@@ -33,6 +33,10 @@ module Bitcoin
         puts block.to_json
       end
 
+      def on_error(message, payload)
+        p ['error', message, payload]
+      end
+
     end
 
   end

data/lib/bitcoin/protocol/parser.rb

@@ -9,29 +9,19 @@ module Bitcoin
       def initialize(handler=nil)
         @h = handler || Handler.new
         @buf = ""
-        @stats = {
-          'total_packets' => 0,
-          'total_bytes' => 0
-        }
+        @stats = { 'total_packets' => 0, 'total_bytes' => 0, 'total_errors' => 0 }
       end
 
-      def log
-        @log ||= Bitcoin::Logger.create("parser")
-      end
+      def log; @log ||= Bitcoin::Logger.create("parser"); end
 
       # handles inv/getdata packets
-      #
       def parse_inv(payload, type=:put)
         count, payload = Protocol.unpack_var_int(payload)
-        payload.each_byte.each_slice(36).with_index{|i, idx|
+        payload.each_byte.each_slice(36).with_index do |i, idx|
           hash = i[4..-1].reverse.pack("C32")
           case i[0]
           when 1
-            if type == :put
-              @h.on_inv_transaction(hash)
-            else
-              @h.on_get_transaction(hash)
-            end
+            type == :put ? @h.on_inv_transaction(hash) : @h.on_get_transaction(hash)
           when 2
             if type == :put
               if @h.respond_to?(:on_inv_block_v2)
@@ -43,28 +33,26 @@ module Bitcoin
               @h.on_get_block(hash)
             end
           else
-            p ['parse_inv error', i]
+            parse_error :parse_inv, i.pack("C*")
           end
-        }
+        end
       end
 
       def parse_addr(payload)
         count, payload = Protocol.unpack_var_int(payload)
-        payload.each_byte.each_slice(30){|i|
-          begin
-            addr = Addr.new(i.pack("C*"))
-          rescue
-            puts "Error parsing addr: #{i.inspect}"
-          end
-          @h.on_addr( addr )
-        }
+        payload.each_byte.each_slice(30) do |i|
+          @h.on_addr(Addr.new(i.pack("C*"))) rescue parse_error(:addr, i.pack("C*"))
+        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{ b = Block.new; b.parse_data_from_io(buf, header_only=true); b }
+        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
 
@@ -98,8 +86,9 @@ module Bitcoin
         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 'reject'; handle_reject(payload)
         else
-          p ['unknown-packet', command, payload]
+          parse_error :unknown_packet, [command, payload.hth]
         end
       end
 
@@ -113,6 +102,11 @@ module Bitcoin
         @h.on_alert Bitcoin::Protocol::Alert.parse(payload)
       end
 
+      def handle_reject(payload)
+        return unless @h.respond_to?(:on_reject)
+        @h.on_reject Bitcoin::Protocol::Reject.parse(payload)
+      end
+
       # https://en.bitcoin.it/wiki/BIP_0035
       def handle_mempool_request(payload)
         return unless @version.fields[:version] >= 60002           # Protocol version >= 60002
@@ -123,15 +117,15 @@ module Bitcoin
       def handle_notfound_reply(payload)
         return unless @h.respond_to?(:on_notfound)
         count, payload = Protocol.unpack_var_int(payload)
-        payload.each_byte.each_slice(36){|i|
+        payload.each_byte.each_slice(36) do |i|
           hash = i[4..-1].reverse.pack("C32")
           case i[0]
           when 1; @h.on_notfound(:tx, hash)
           when 2; @h.on_notfound(:block, hash)
           else
-            p ['handle_notfound_reply error', i, hash]
+            parse_error(:notfound, [i.pack("C*"), hash])
           end
-        }
+        end
       end
 
       def parse(buf)
@@ -179,6 +173,13 @@ module Bitcoin
           log.debug { [type, msg] }
         end
       end
+
+      def parse_error *err
+        @stats['total_errors'] += 1
+        return unless @h.respond_to?(:on_error)
+        @h.on_error *err
+      end
+
     end # Parser
 
   end