bitcoin-ruby 0.0.1 → 0.0.2

data/lib/bitcoin/protocol/handler.rb

@@ -1,21 +1,23 @@
+# encoding: ascii-8bit
+
 module Bitcoin
   module Protocol
 
     class Handler
       def on_inv_transaction(hash)
-        p ['inv transaction', hth(hash)]
+        p ['inv transaction', hash.hth]
       end
 
       def on_inv_block(hash)
-        p ['inv block', hth(hash)]
+        p ['inv block', hash.hth]
       end
 
       def on_get_transaction(hash)
-        p ['get transaction', hth(hash)]
+        p ['get transaction', hash.hth]
       end
 
       def on_get_block(hash)
-        p ['get block', hth(hash)]
+        p ['get block', hash.hth]
       end
 
       def on_addr(addr)
@@ -31,7 +33,6 @@ module Bitcoin
         puts block.to_json
       end
 
-      def hth(h); h.unpack("H*")[0]; end
     end
 
   end

data/lib/bitcoin/protocol/parser.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin
   module Protocol
 
@@ -37,8 +39,6 @@ module Bitcoin
         }
       end
 
-      def hth(h); h.unpack("H*")[0]; end
-
       def parse_addr(payload)
         count, payload = Protocol.unpack_var_int(payload)
         payload.each_byte.each_slice(30){|i|
@@ -52,18 +52,19 @@ module Bitcoin
       end
 
       def parse_headers(payload)
-        count, payload = Protocol.unpack_var_int(payload)
-        idx = 0
-        headers = count.times.map{ Block.new(payload[idx..idx+=81]) }
+        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 }
         @h.on_headers(headers)
       end
 
       def parse_getblocks(payload)
-        version, payload = payload.unpack('a4a*')
+        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 = Protocol.hth(i.reverse.pack("C32")) }
-        stop_hash = Protocol.hth(payload[0..32].reverse)
+        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
 
@@ -75,21 +76,24 @@ module Bitcoin
         when 'inv';      parse_inv(payload, :put)
         when 'getdata';  parse_inv(payload, :get)
         when 'addr';     parse_addr(payload)
-        when 'verack';   @h.on_handshake_complete # nop
+        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))
-        when 'getheaders';  @h.on_getheaders(*parse_getblocks(payload))
+        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)
         else
-          p ['unkown-packet', command, payload]
+          p ['unknown-packet', command, payload]
         end
       end
 
       def parse_version(payload)
-        version = Bitcoin::Protocol::Version.parse(payload)
-        @h.on_version(version)
+        @version = Bitcoin::Protocol::Version.parse(payload)
+        @h.on_version(@version)
       end
 
       def parse_alert(payload)
@@ -97,6 +101,27 @@ module Bitcoin
         @h.on_alert Bitcoin::Protocol::Alert.parse(payload)
       end
 
+      # https://en.bitcoin.it/wiki/BIP_0035
+      def handle_mempool_request(payload)
+        return unless @version[:version] >= 60002           # Protocol version >= 60002
+        return unless (@version[: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.each_byte.each_slice(36){|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]
+          end
+        }
+      end
+
       def parse(buf)
         @buf += buf
         while parse_buffer; end
@@ -108,20 +133,20 @@ module Bitcoin
         head_size  = 24
         return false if @buf.size <= head_size
 
-        magic, cmd, length, checksum = @buf.unpack("a4A12Ia4")
+        magic, cmd, length, checksum = @buf.unpack("a4A12Va4")
         payload = @buf[head_size...head_size+length]
 
         unless magic == head_magic
-          handle_error(:close, "head_magic not found")
+          handle_stream_error(:close, "head_magic not found")
           @buf = ''
         else
 
           if Digest::SHA256.digest(Digest::SHA256.digest( payload ))[0...4] != checksum
             if (length < 50000) && (payload.size < length)
               size_info = [payload.size, length].join('/')
-              handle_error(:debug, "chunked packet stream (#{size_info})")
+              handle_stream_error(:debug, "chunked packet stream (#{size_info})")
             else
-              handle_error(:close, "checksum mismatch")
+              handle_stream_error(:close, "checksum mismatch")
             end
             return
           end
@@ -134,7 +159,7 @@ module Bitcoin
         @buf[0] != nil
       end
 
-      def handle_error(type, msg)
+      def handle_stream_error(type, msg)
         case type
         when :close
           log.debug {"closing packet stream (#{msg})"}

data/lib/bitcoin/protocol/tx.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 require 'bitcoin/script'
 
 module Bitcoin
@@ -39,12 +41,12 @@ module Bitcoin
       # create tx from raw binary +data+
       def initialize(data=nil)
         @ver, @lock_time, @in, @out = 1, 0, [], []
-        parse_data(data) if data
+        parse_data_from_io(data) if data
       end
 
       # generate the tx hash for given +payload+ in hex format
       def hash_from_payload(payload)
-        Digest::SHA256.digest(Digest::SHA256.digest( payload )).reverse.unpack("H*")[0]
+        Digest::SHA256.digest(Digest::SHA256.digest( payload )).reverse_hth
       end
       alias generate_hash hash_from_payload
 
@@ -55,49 +57,49 @@ module Bitcoin
       def add_out(output); (@out ||= []) << output; end
 
       # parse raw binary data
-      def parse_data(data)
-        @ver = data.unpack("I")[0]
-        idx = 4
-        in_size, tmp = Protocol.unpack_var_int(data[idx..-1])
-        idx += data[idx..-1].bytesize-tmp.bytesize
-        # raise "unkown transaction version: #{@ver}" unless @ver == 1
-
-        @in = (0...in_size).map{
-          txin = TxIn.new
-          idx += txin.parse_data(data[idx..-1])
-          txin
-        }
+      def parse_data_from_io(data)
+        buf = data.is_a?(String) ? StringIO.new(data) : data
+        payload_start = buf.pos
 
-        out_size, tmp = Protocol.unpack_var_int(data[idx..-1])
-        idx += data[idx..-1].bytesize-tmp.bytesize
+        @ver = buf.read(4).unpack("V")[0]
 
-        @out = (0...out_size).map{
-          txout = TxOut.new
-          idx += txout.parse_data(data[idx..-1])
-          txout
-        }
+        in_size = Protocol.unpack_var_int_from_io(buf)
+        @in = []
+        in_size.times{ @in << TxIn.from_io(buf) }
+
+        out_size = Protocol.unpack_var_int_from_io(buf)
+        @out = []
+        out_size.times{ @out << TxOut.from_io(buf) }
 
-        @lock_time = data[idx...idx+=4].unpack("I")[0]
+        @lock_time = buf.read(4).unpack("V")[0]
 
-        @payload = data[0...idx]
+        payload_end = buf.pos;
+        buf.seek(payload_start)
+        @payload = buf.read( payload_end-payload_start )
         @hash = hash_from_payload(@payload)
 
-        if data[idx] == nil
-          true          # reached the end.
+        if buf.eof?
+          true
         else
-          data[idx..-1] # rest of buffer.
+          data.is_a?(StringIO) ? buf : buf.read
         end
       end
 
+      alias :parse_data  :parse_data_from_io
+
       # output transaction in raw binary format
       def to_payload
-        pin  =  @in.map(&:to_payload).join
-        pout = @out.map(&:to_payload).join
+        pin = ""
+        @in.each{|input| pin << input.to_payload }
+        pout = ""
+        @out.each{|output| pout << output.to_payload }
 
-        in_size, out_size = Protocol.pack_var_int(@in.size), Protocol.pack_var_int(@out.size)
-        [[@ver].pack("I"), in_size, pin, out_size, pout, [@lock_time].pack("I")].join
+        [@ver].pack("V") << Protocol.pack_var_int(@in.size) << pin << Protocol.pack_var_int(@out.size) << pout << [@lock_time].pack("V")
       end
 
+
+      SIGHASH_TYPE = { all: 1, none: 2, single: 3, anyonecanpay: 128 }
+
       # generate a signature hash for input +input_idx+.
       # either pass the +outpoint_tx+ or the +script_pubkey+ directly.
       def signature_hash_for_input(input_idx, outpoint_tx, script_pubkey=nil, hash_type=nil, drop_sigs=nil, script=nil)
@@ -105,46 +107,58 @@ module Bitcoin
         # http://code.google.com/p/bitcoinj/source/browse/trunk/src/com/google/bitcoin/core/Script.java#318
         # https://en.bitcoin.it/wiki/OP_CHECKSIG#How_it_works
         # https://github.com/bitcoin/bitcoin/blob/c2e8c8acd8ae0c94c70b59f55169841ad195bb99/src/script.cpp#L1058
+        # https://en.bitcoin.it/wiki/OP_CHECKSIG
 
-        hash_type ||= 1 # 1: ALL, 2: NONE, 3: SINGLE
+        return "\x01".ljust(32, "\x00") if input_idx >= @in.size # ERROR: SignatureHash() : input_idx=%d out of range
+
+        hash_type ||= SIGHASH_TYPE[:all]
 
         pin  = @in.map.with_index{|input,idx|
           if idx == input_idx
             script_pubkey ||= outpoint_tx.out[ input.prev_out_index ].pk_script
-            script_pubkey = Bitcoin::Script.binary_from_string(script)                if script    # force this string a script
-            script_pubkey = Bitcoin::Script.drop_signatures(script_pubkey, drop_sigs) if drop_sigs # array of signature to drop
+            script_pubkey = script                                                    if script    # force binary aa script
+            script_pubkey = Bitcoin::Script.drop_signatures(script_pubkey, drop_sigs) if drop_sigs # array of signature to drop (slow)
+            #p Bitcoin::Script.new(script_pubkey).to_string
             input.to_payload(script_pubkey)
           else
-            case hash_type
-            when 2; input.to_payload("", "\x00\x00\x00\x00")
-            else;   input.to_payload("")
+            case (hash_type & 0x1f)
+            when SIGHASH_TYPE[:none];   input.to_payload("", "\x00\x00\x00\x00")
+            when SIGHASH_TYPE[:single]; input.to_payload("", "\x00\x00\x00\x00")
+            else;                       input.to_payload("")
             end
           end
-        }.join
+        }
 
-        pout = @out.map(&:to_payload).join
+        pout = @out.map(&:to_payload)
+        in_size, out_size = Protocol.pack_var_int(@in.size), Protocol.pack_var_int(@out.size)
 
-        case hash_type
-        when 2
+        case (hash_type & 0x1f)
+        when SIGHASH_TYPE[:none]
           pout = ""
-          in_size, out_size = Protocol.pack_var_int(@in.size), Protocol.pack_var_int(0)
-        else
-          in_size, out_size = Protocol.pack_var_int(@in.size), Protocol.pack_var_int(@out.size)
+          out_size = Protocol.pack_var_int(0)
+        when SIGHASH_TYPE[:single]
+          return "\x01".ljust(32, "\x00") if input_idx >= @out.size # ERROR: SignatureHash() : input_idx=%d out of range (SIGHASH_SINGLE)
+          pout = @out[0...(input_idx+1)].map.with_index{|out,idx| (idx==input_idx) ? out.to_payload : out.to_null_payload }.join
+          out_size = Protocol.pack_var_int(input_idx+1)
         end
 
-        buf = [ [@ver].pack("I"), in_size, pin, out_size, pout, [@lock_time, hash_type].pack("II") ].join
+        if (hash_type & SIGHASH_TYPE[:anyonecanpay]) != 0
+          in_size, pin = Protocol.pack_var_int(1), [ pin[input_idx] ]
+        end
+
+        buf = [ [@ver].pack("V"), in_size, pin, out_size, pout, [@lock_time, hash_type].pack("VV") ].join
         Digest::SHA256.digest( Digest::SHA256.digest( buf ) )
       end
 
       # verify input signature +in_idx+ against the corresponding
       # output in +outpoint_tx+
-      def verify_input_signature(in_idx, outpoint_tx)
+      def verify_input_signature(in_idx, outpoint_tx, block_timestamp=Time.now.to_i)
         outpoint_idx  = @in[in_idx].prev_out_index
         script_sig    = @in[in_idx].script_sig
         script_pubkey = outpoint_tx.out[outpoint_idx].pk_script
         script        = script_sig + script_pubkey
 
-        Bitcoin::Script.new(script).run do |pubkey,sig,hash_type,drop_sigs,script|
+        Bitcoin::Script.new(script).run(block_timestamp) do |pubkey,sig,hash_type,drop_sigs,script|
           # this IS the checksig callback, must return true/false
           hash = signature_hash_for_input(in_idx, outpoint_tx, nil, hash_type, drop_sigs, script)
           #hash = signature_hash_for_input(in_idx, nil, script_pubkey, hash_type, drop_sigs, script)
@@ -153,20 +167,21 @@ module Bitcoin
       end
 
       # convert to ruby hash (see also #from_hash)
-      def to_hash
+      def to_hash(options = {})
         @hash ||= hash_from_payload(to_payload)
-        {
+        h = {
           'hash' => @hash, 'ver' => @ver,
           'vin_sz' => @in.size, 'vout_sz' => @out.size,
           'lock_time' => @lock_time, 'size' => (@payload ||= to_payload).bytesize,
-          'in'  =>  @in.map(&:to_hash),
-          'out' => @out.map(&:to_hash)
+          'in'  =>  @in.map{|i| i.to_hash(options) },
+          'out' => @out.map{|o| o.to_hash(options) }
         }
+        h
       end
 
       # generates rawblock json as seen in the block explorer.
       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
@@ -199,7 +214,45 @@ module Bitcoin
 
       # read json block from a file
       def self.from_json_file(path); from_json( Bitcoin::Protocol.read_binary_file(path) ); end
-    end
 
+      def validator(store, block = nil)
+        @validator ||= Bitcoin::Validation::Tx.new(self, store, block)
+      end
+
+      def minimum_relay_fee; calculate_minimum_fee(1_000, true, :relay); end
+      def minimum_block_fee; calculate_minimum_fee(1_000, true, :block); end
+
+      def calculate_minimum_fee(block_size=1, allow_free=true, mode=:block)
+        base_fee       = (mode == :relay) ? Bitcoin.network[:min_relay_tx_fee] : Bitcoin.network[:min_tx_fee]
+        tx_size        = to_payload.bytesize
+        new_block_size = block_size + tx_size
+        min_fee       = (1 + tx_size / 1_000) * base_fee
+
+        if allow_free
+          if block_size == 1
+            min_fee = 0 if tx_size < 10_000
+          else
+            min_fee = 0 if new_block_size < 27_000
+          end
+        end
+
+        if min_fee < base_fee
+          outputs.each{|output| (min_fee = base_fee; break) if output.value < Bitcoin::CENT }
+        end
+
+        if block_size != 1 && new_block_size >= (Bitcoin::MAX_BLOCK_SIZE_GEN/2)
+          #return Bitcoin::network[:max_money] if new_block_size >= Bitcoin::MAX_BLOCK_SIZE_GEN
+          min_fee *= Bitcoin::MAX_BLOCK_SIZE_GEN / (Bitcoin::MAX_BLOCK_SIZE_GEN - new_block_size)
+        end
+
+        min_fee = Bitcoin::network[:max_money] unless min_fee.between?(0, Bitcoin::network[:max_money])
+        min_fee
+      end
+
+      def is_coinbase?
+        inputs.size == 1 and inputs.first.coinbase?
+      end
+
+    end
   end
 end

data/lib/bitcoin/protocol/txin.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin
   module Protocol
 
@@ -12,10 +14,19 @@ module Bitcoin
       # script_sig input Script (signature)
       attr_accessor :script_sig, :script_sig_length
 
+      # signature hash and the address of the key that needs to sign it
+      # (used when dealing with unsigned or partly signed tx)
+      attr_accessor :sig_hash, :sig_address
+
+      alias :script   :script_sig
+      alias :script_length  :script_sig_length
+
       # sequence
       attr_accessor :sequence
 
       DEFAULT_SEQUENCE = "\xff\xff\xff\xff"
+      NULL_HASH = "\x00"*32
+      COINBASE_INDEX = 0xffffffff
 
       def initialize *args
         @prev_out, @prev_out_index, @script_sig_length,
@@ -33,32 +44,34 @@ module Bitcoin
 
       # parse raw binary data for transaction input
       def parse_data(data)
-        idx = 0
-        @prev_out, @prev_out_index = data[idx...idx+=36].unpack("a32I")
-        @script_sig_length, tmp = Protocol.unpack_var_int(data[idx..-1])
-        idx += data[idx..-1].bytesize - tmp.bytesize
-        @script_sig = data[idx...idx+=@script_sig_length]
-        @sequence = data[idx...idx+=4]
-        idx
+        buf = data.is_a?(String) ? StringIO.new(data) : data
+        parse_data_from_io(buf)
+        buf.pos
+      end
+
+      def self.from_io(buf)
+        txin = new; txin.parse_data_from_io(buf); txin
       end
 
-      alias :parse_payload :parse_data
+      def parse_data_from_io(buf)
+        @prev_out, @prev_out_index = buf.read(36).unpack("a32V")
+        @script_sig_length = Protocol.unpack_var_int_from_io(buf)
+        @script_sig = buf.read(@script_sig_length)
+        @sequence = buf.read(4)
+      end
 
       def to_payload(script=@script_sig, sequence=@sequence)
-        buf =  [ @prev_out, @prev_out_index ].pack("a32I")
-        buf << Protocol.pack_var_int(script.bytesize)
-        buf << script if script.bytesize > 0
-        buf << (sequence || DEFAULT_SEQUENCE)
+        [@prev_out, @prev_out_index].pack("a32V") << Protocol.pack_var_int(script.bytesize) << script << (sequence || DEFAULT_SEQUENCE)
       end
 
-      def to_hash
-        t = { 'prev_out'  => { 'hash' => @prev_out.reverse.unpack("H*")[0], 'n' => @prev_out_index } }
+      def to_hash(options = {})
+        t = { 'prev_out'  => { 'hash' => @prev_out.reverse_hth, 'n' => @prev_out_index } }
         if coinbase?
           t['coinbase']  = @script_sig.unpack("H*")[0]
         else # coinbase tx
           t['scriptSig'] = Bitcoin::Script.new(@script_sig).to_string
-          t['sequence']  = @sequence.unpack("I")[0] unless @sequence == "\xff\xff\xff\xff"
         end
+        t['sequence']  = @sequence.unpack("V")[0] unless @sequence == "\xff\xff\xff\xff"
         t
       end
 
@@ -66,22 +79,25 @@ module Bitcoin
         txin = TxIn.new([ input['prev_out']['hash'] ].pack('H*').reverse, input['prev_out']['n'])
         if input['coinbase']
           txin.script_sig = [ input['coinbase'] ].pack("H*")
-          txin.sequence = "\xff\xff\xff\xff"
         else
           txin.script_sig = Script.binary_from_string(input['scriptSig'])
-          txin.sequence = [ input['sequence'] || 0xffffffff ].pack("I")
         end
+        txin.sequence = [ input['sequence'] || 0xffffffff ].pack("V")
         txin
       end
 
+      def self.from_hex_hash(hash, index)
+        TxIn.new([hash].pack("H*").reverse, index, 0)
+      end
+
       # previous output in hex
       def previous_output
-        @prev_out.reverse.unpack("H*")[0]
+        @prev_out.reverse_hth
       end
 
       # check if input is coinbase
       def coinbase?
-        (@prev_out_index == 4294967295) && (@prev_out == "\x00"*32)
+        (@prev_out_index == COINBASE_INDEX) && (@prev_out == NULL_HASH)
       end
 
       # set script_sig and script_sig_length
@@ -91,6 +107,10 @@ module Bitcoin
       end
       alias :script= :script_sig=
 
+      def add_signature_pubkey_script(sig, pubkey_hex)
+        self.script = Bitcoin::Script.to_signature_pubkey_script(sig, [pubkey_hex].pack("H*"))
+      end
+
     end
 
   end