bitcoin-ruby 0.0.1 → 0.0.2

data/lib/bitcoin/protocol.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 require 'socket'
 require 'digest/sha2'
 require 'json'
@@ -5,6 +7,12 @@ require 'json'
 module Bitcoin
   module Protocol
 
+    # bitcoin/src/main.h
+    MAX_INV_SZ = 50000
+
+    # BIP 0031, pong message, is enabled for all versions AFTER this one
+    BIP0031_VERSION = 60000
+    
     autoload :TxIn,    'bitcoin/protocol/txin'
     autoload :TxOut,   'bitcoin/protocol/txout'
     autoload :Tx,      'bitcoin/protocol/tx'
@@ -12,15 +20,15 @@ module Bitcoin
     autoload :Addr,    'bitcoin/protocol/address'
     autoload :Alert,   'bitcoin/protocol/alert'
     autoload :Version, 'bitcoin/protocol/version'
+    autoload :AuxPow,  'bitcoin/protocol/aux_pow'
 
     autoload :Handler, 'bitcoin/protocol/handler'
     autoload :Parser,  'bitcoin/protocol/parser'
 
-    VERSION = 60001
-
-    DNS_Seed = [ "bitseed.xf2.org", "bitseed.bitcoin.org.uk" ]
     Uniq = rand(0xffffffffffffffff)
 
+    # var_int refers to https://en.bitcoin.it/wiki/Protocol_specification#Variable_length_integer and is what Satoshi called "CompactSize"
+    # BitcoinQT has later added even more compact format called CVarInt to use in its local block storage. CVarInt is not implemented here.
     def self.unpack_var_int(payload)
       case payload.unpack("C")[0] # TODO add test cases
       when 0xfd; payload.unpack("xva*")
@@ -30,6 +38,16 @@ module Bitcoin
       end
     end
 
+    def self.unpack_var_int_from_io(io)
+      uchar = io.read(1).unpack("C")[0]
+      case uchar
+      when 0xfd; io.read(2).unpack("v")[0]
+      when 0xfe; io.read(4).unpack("V")[0]
+      when 0xff; io.read(8).unpack("Q")[0]
+      else;      uchar
+      end
+    end
+
     def self.pack_var_int(i)
       if    i <  0xfd;                [      i].pack("C")
       elsif i <= 0xffff;              [0xfd, i].pack("Cv")
@@ -44,6 +62,11 @@ module Bitcoin
       size > 0 ? (string, payload = payload.unpack("a#{size}a*")) : [nil, payload]
     end
 
+    def self.unpack_var_string_from_io(buf)
+      size = unpack_var_int_from_io(buf)
+      size > 0 ? buf.read(size) : nil
+    end
+
     def self.pack_var_string(payload)
       pack_var_int(payload.bytesize) + payload
     end
@@ -60,13 +83,14 @@ module Bitcoin
       [(0...size).map{ i, payload = unpack_var_int(payload); i }, payload]
     end
 
+    BINARY = Encoding.find('ASCII-8BIT')
 
     def self.pkt(command, payload)
       cmd      = command.ljust(12, "\x00")[0...12]
-      length   = [payload.bytesize].pack("I")
+      length   = [payload.bytesize].pack("V")
       checksum = Digest::SHA256.digest(Digest::SHA256.digest(payload))[0...4]
-
-      [Bitcoin.network[:magic_head], cmd, length, checksum, payload].join
+      pkt      = "".force_encoding(BINARY)
+      pkt << Bitcoin.network[:magic_head].force_encoding(BINARY) << cmd.force_encoding(BINARY) << length << checksum << payload.force_encoding(BINARY)
     end
 
     def self.version_pkt(from_id, from=nil, to=nil, last_block=nil, time=nil, user_agent=nil, version=nil)
@@ -98,39 +122,36 @@ module Bitcoin
     TypeLookup = Hash[:tx, 1, :block, 2, nil, 0]
 
     def self.getdata_pkt(type, hashes)
-      return if hashes.size >= 256
-      t = [ TypeLookup[type] ].pack("I")
-      pkt("getdata", [hashes.size].pack("C") + hashes.map{|hash| t + hash[0..32].reverse }.join)
+      return if hashes.size > MAX_INV_SZ
+      t = [ TypeLookup[type] ].pack("V")
+      pkt("getdata", pack_var_int(hashes.size) + hashes.map{|hash| t + hash[0..32].reverse }.join)
     end
 
     def self.inv_pkt(type, hashes)
-      return if hashes.size >= 256
-      t = [ TypeLookup[type] ].pack("I")
-      pkt("inv", [hashes.size].pack("C") + hashes.map{|hash| t + hash[0..32].reverse }.join)
+      return if hashes.size > MAX_INV_SZ
+      t = [ TypeLookup[type] ].pack("V")
+      pkt("inv", pack_var_int(hashes.size) + hashes.map{|hash| t + hash[0..32].reverse }.join)
     end
 
     DEFAULT_STOP_HASH = "00"*32
 
-    def self.locator_payload(locator_hashes, stop_hash)
+    def self.locator_payload(version, locator_hashes, stop_hash)
       payload = [
-        Bitcoin.network[:magic_head],
+        [version].pack("V"),
         pack_var_int(locator_hashes.size),
-        locator_hashes.map{|l| htb(l).reverse }.join,
-        htb(stop_hash).reverse
+        locator_hashes.map{|l| l.htb_reverse }.join,
+        stop_hash.htb_reverse
       ].join
     end
 
-    def self.getblocks_pkt(locator_hashes, stop_hash=DEFAULT_STOP_HASH)
-      pkt "getblocks",  locator_payload(locator_hashes, stop_hash)
+    def self.getblocks_pkt(version, locator_hashes, stop_hash=DEFAULT_STOP_HASH)
+      pkt "getblocks",  locator_payload(version, locator_hashes, stop_hash)
     end
 
-    def self.getheaders_pkt(locator_hashes, stop_hash=DEFAULT_STOP_HASH)
-      pkt "getheaders", locator_payload(locator_hashes, stop_hash)
+    def self.getheaders_pkt(version, locator_hashes, stop_hash=DEFAULT_STOP_HASH)
+      pkt "getheaders", locator_payload(version, locator_hashes, stop_hash)
     end
 
-    def self.hth(h); h.unpack("H*")[0]; end
-    def self.htb(h); [h].pack("H*"); end
-
     def self.read_binary_file(path)
       File.open(path, 'rb'){|f| f.read }
     end

data/lib/bitcoin/protocol/address.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin
   module Protocol
 
@@ -15,7 +17,7 @@ module Bitcoin
       # create addr from raw binary +data+
       def initialize(data = nil)
         if data
-          self[:time], self[:service], self[:ip], self[:port] = data.unpack("IQx12a4n")
+          self[:time], self[:service], self[:ip], self[:port] = data.unpack("VQx12a4n")
           self[:ip] = ip.unpack("C*").join(".")
         else
           self[:time], self[:service] = Time.now.to_i, 1
@@ -30,7 +32,7 @@ module Bitcoin
 
       def to_payload
         ip = self[:ip].split(".").map(&:to_i)
-        [ time, service, ("\x00"*10)+"\xff\xff", *ip, port ].pack("IQa12C4n")
+        [ time, service, ("\x00"*10)+"\xff\xff", *ip, port ].pack("VQa12C4n")
       end
 
       def string
@@ -38,7 +40,7 @@ module Bitcoin
       end
 
       def self.pkt(*addrs)
-        addrs = addrs.select{|i| i.is_a?(Bitcoin::Protocol::Addr) }
+        addrs = addrs.select{|i| i.is_a?(Bitcoin::Protocol::Addr) && i.ip =~ /^\d+\.\d+\.\d+\.\d+$/ }
         length = Bitcoin::Protocol.pack_var_int(addrs.size)
         Bitcoin::Protocol.pkt("addr", length + addrs.map(&:to_payload).join)
       end

data/lib/bitcoin/protocol/alert.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin
 module Protocol
 
@@ -11,13 +13,10 @@ module Protocol
       super(*values)
     end
 
-
-    Valid_Keys = [ "04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284" ] 
-
     def valid_signature?
       return false unless @payload && @signature
       hash = Digest::SHA256.digest(Digest::SHA256.digest(@payload))
-      Valid_Keys.any?{|public_key| Bitcoin.verify_signature(hash, @signature, public_key) }
+      Bitcoin.network[:alert_pubkeys].any?{|public_key| Bitcoin.verify_signature(hash, @signature, public_key) }
     end
 
 

data/lib/bitcoin/protocol/aux_pow.rb

@@ -0,0 +1,123 @@
+# encoding: ascii-8bit
+
+module Bitcoin
+  module Protocol
+
+    # Auxiliary Proof-of-Work for merge-mined blockchains
+    class AuxPow
+
+      # Coinbase transaction linking the aux to its parent block
+      attr_accessor :tx
+
+      # Hash of the block header
+      attr_accessor :block_hash
+
+      # Merkle branches to bring the transaction to the block's merkle root
+      attr_accessor :branch
+
+      # Index of this transaction in the merkle tree
+      attr_accessor :mrkl_index
+
+      # Merkle branches linking this aux chains to the aux root
+      attr_accessor :aux_branch
+
+      # Index of "this" block chain in the aux chain list
+      attr_accessor :aux_index
+
+      # Parent block header
+      attr_accessor :parent_block
+
+      def initialize(data)
+        parse_data (data) if data
+      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
+      end
+
+      def parse_data_from_io(data)
+        @tx = P::Tx.new(nil)
+        @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]
+
+        @aux_branch = []
+        aux_branch_count = P.unpack_var_int_from_io(data)
+        aux_branch_count.times{ @aux_branch << data.read(32) }
+
+        @aux_index = data.read(4).unpack("I")[0]
+        block = data.read(80)
+        @parent_block = P::Block.new(block)
+
+        data
+      end
+
+
+      def to_payload
+        payload = @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 << @parent_block.to_payload
+        payload
+      end
+
+      def self.from_hash h
+        aux_pow = new(nil)
+        aux_pow.instance_eval do
+          @tx = P::Tx.from_hash(h['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']
+          @parent_block = P::Block.from_hash(h['parent_block'])
+        end
+        aux_pow
+      end
+
+      def to_hash
+        { 'tx' => @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,
+          'parent_block' => @parent_block.to_hash }
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/protocol/block.rb

@@ -1,8 +1,15 @@
+# encoding: ascii-8bit
+
 module Bitcoin
   module Protocol
 
     class Block
 
+      BLOCK_VERSION_DEFAULT     = (1 << 0)
+      BLOCK_VERSION_AUXPOW      = (1 << 8)
+      BLOCK_VERSION_CHAIN_START = (1 << 16)
+      BLOCK_VERSION_CHAIN_END   = (1 << 30)
+
       # block hash
       attr_accessor :hash
 
@@ -30,6 +37,9 @@ module Bitcoin
       # raw protocol payload
       attr_accessor :payload
 
+      # AuxPow linking the block to a merge-mined chain
+      attr_accessor :aux_pow
+
       alias :transactions :tx
 
       # compare to another block
@@ -37,58 +47,95 @@ module Bitcoin
         @hash == other.hash
       end
 
+      def binary_hash
+        [@hash].pack("H*")
+      end
+
+      def prev_block_hex
+        @prev_block_hex ||= @prev_block.reverse.unpack("H*")[0]
+      end
+
       # create block from raw binary +data+
       def initialize(data)
         @tx = []
-        parse_data(data) if data
+        parse_data_from_io(data) if data
       end
 
       # parse raw binary data
       def parse_data(data)
-        @ver, @prev_block, @mrkl_root, @time, @bits, @nonce, payload = data.unpack("Ia32a32IIIa*")
+        buf = parse_data_from_io(data)
+        buf.eof? ? true : buf.read
+      end
+
+      # 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")
         recalc_block_hash
 
-        tx_size, payload = Protocol.unpack_var_int(payload)
-        (0...tx_size).each{  break if payload == true
+        if (@ver & BLOCK_VERSION_AUXPOW) > 0
+          @aux_pow = AuxPow.new(nil)
+          @aux_pow.parse_data_from_io(buf)
+        end
+
+        return buf if buf.eof?
+
+        tx_size = Protocol.unpack_var_int_from_io(buf)
+        @tx_count = tx_size
+        return buf if header_only
+
+        tx_size.times{  break if payload == true
           t = Tx.new(nil)
-          payload = t.parse_data(payload)
+          payload = t.parse_data_from_io(buf)
           @tx << t
         }
 
         @payload = to_payload
-        payload
+        buf
       end
 
       # recalculate the block hash
       def recalc_block_hash
-        @hash = Bitcoin.block_hash(hth(@prev_block), hth(@mrkl_root), @time, @bits, @nonce, @ver)
+        @hash = Bitcoin.block_hash(@prev_block.reverse_hth, @mrkl_root.reverse_hth, @time, @bits, @nonce, @ver)
+      end
+
+      def recalc_mrkl_root
+        @mrkl_root = Bitcoin.hash_mrkl_tree( @tx.map(&:hash) ).last.htb_reverse
+      end
+
+      # verify mrkl tree
+      def verify_mrkl_root
+        @mrkl_root.reverse_hth == Bitcoin.hash_mrkl_tree( @tx.map(&:hash) ).last
       end
 
       # get the block header info
       # [<version>, <prev_block>, <merkle_root>, <time>, <bits>, <nonce>, <txcount>, <size>]
       def header_info
-        [@ver, hth(@prev_block), hth(@mrkl_root), Time.at(@time), @bits, @nonce, @tx.size, @payload.size]
+        [@ver, @prev_block.reverse_hth, @mrkl_root.reverse_hth, Time.at(@time), @bits, @nonce, @tx.size, @payload.size]
       end
 
-      def hth(h); h.reverse.unpack("H*")[0]; end
-      def htb(s); [s].pack('H*').reverse; end
-
       # convert to raw binary format
       def to_payload
-        head = [@ver, @prev_block, @mrkl_root, @time, @bits, @nonce].pack("Ia32a32III")
-        [head, Protocol.pack_var_int(@tx.size), @tx.map(&:to_payload).join].join
+        head = [@ver, @prev_block, @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)
+        @tx.each{|tx| head << tx.to_payload }
+        head
       end
 
       # convert to ruby hash (see also #from_hash)
       def to_hash
-        {
+        h = {
           'hash' => @hash, 'ver' => @ver,
-          'prev_block' => hth(@prev_block), 'mrkl_root' => hth(@mrkl_root),
+          'prev_block' => @prev_block.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 },
           'mrkl_tree' => Bitcoin.hash_mrkl_tree( @tx.map{|i| i.hash } )
         }
+        h['aux_pow'] = @aux_pow.to_hash  if @aux_pow
+        h
       end
 
       def hextarget
@@ -103,6 +150,22 @@ module Bitcoin
         Bitcoin.block_difficulty(@bits)
       end
 
+      # 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)
+        return nil unless @ver >= 2
+        if height # generate height binary
+          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
+        end
+      rescue
+        nil
+      end
+
       # convert to json representation as seen in the block explorer.
       # (see also #from_json)
       def to_json(options = {:space => ''}, *a)
@@ -116,13 +179,19 @@ module Bitcoin
       end
 
       # parse ruby hash (see also #to_hash)
-      def self.from_hash(h)
+      def self.from_hash(h, do_raise=true)
         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| htb(i) }
-          recalc_block_hash
+          @prev_block, @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) }
+          if h['tx'].any? && !Bitcoin.freicoin?
+            (raise "Block merkle root mismatch! Block: #{h['hash']}"  unless verify_mrkl_root) if do_raise
+          end
         }
         blk
       end
@@ -148,6 +217,17 @@ module Bitcoin
 
       # read json block from a file
       def self.from_json_file(path); from_json( Bitcoin::Protocol.read_binary_file(path) ); end
+
+      def validator(store, prev_block = nil)
+        @validator ||= Bitcoin::Validation::Block.new(self, store, prev_block)
+      end
+
+      # get the (statistical) amount of work that was needed to generate this block.
+      def block_work
+        target = Bitcoin.decode_compact_bits(@bits)
+        (2**256) / (target.to_i(16) + 1)
+      end
+
     end
 
   end