bitcoin-ruby 0.0.5 → 0.0.6

data/lib/bitcoin/network/connection_handler.rb

@@ -41,7 +41,7 @@ module Bitcoin::Network
       @latency_ms = nil
       @lock = Monitor.new
       @last_getblocks = []  # the last few getblocks messages received
-    rescue Exception
+    rescue
       log.fatal { "Error in #initialize" }
       p $!; puts $@; exit
     end
@@ -51,15 +51,16 @@ module Bitcoin::Network
       if incoming?
         begin_handshake
       end
-    rescue Exception
+    rescue
       log.fatal { "Error in #post_init" }
       p $!; puts *$@
     end
 
     # only called for outgoing connection
     def connection_completed
+      @connection_completed = true
       begin_handshake
-    rescue Exception
+    rescue
       log.fatal { "Error in #connection_completed" }
       p $!; puts *$@
     end
@@ -75,8 +76,8 @@ module Bitcoin::Network
 
     # connection closed; notify listeners and cleanup connection from node
     def unbind
-      log.info { "Disconnected" }
-      @node.push_notification(:connection, [:disconnected, [@host, @port]])
+      log.info { (outgoing? && !@connection_completed) ? "Connection failed" : "Disconnected" }
+      @node.push_notification(:connection, {type: :disconnected, host: @host, port: @port})
       @state = :disconnected
       @node.connections.delete(self)
     end
@@ -90,9 +91,8 @@ module Bitcoin::Network
       log.info { "Established #{@direction} connection" }
       @node.connections << self
       @state = :handshake
-      # incoming connections wait to receive a version
-      send_version if outgoing?
-    rescue Exception
+      send_version
+    rescue
       log.fatal { "Error in #begin_handshake" }
       p $!; puts *$@
     end
@@ -103,9 +103,10 @@ module Bitcoin::Network
         log.debug { 'Handshake completed' }
         @state = :connected
         @started = Time.now
-        @node.push_notification(:connection, [:connected, info])
+        @node.push_notification(:connection, info.merge(type: :connected))
         @node.addrs << addr
       end
+      send_data P::Addr.pkt(@node.addr)  if @node.config[:announce]
     end
 
     # received +inv_tx+ message for given +hash+.
@@ -223,15 +224,15 @@ module Bitcoin::Network
 
       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]]
+      blocks = @node.store.db[:blk].where(chain: 0, depth: range).order(:depth).select(:hash).all
       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]
+      addrs = @node.config[:announce] ? [@node.addr] : []
+      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
@@ -311,7 +312,7 @@ module Bitcoin::Network
         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) 
+        @latency_ms = (5*1000)
         log.debug { "<< ping" }
         send_data(Protocol.ping_pkt)
       end

data/lib/bitcoin/network/node.rb

@@ -50,11 +50,16 @@ module Bitcoin::Network
 
     DEFAULT_CONFIG = {
       :network => :bitcoin,
-      :listen => ["0.0.0.0", Bitcoin.network[:default_port]],
+      :listen => ["0.0.0.0", nil],
       :connect => [],
       :command => ["127.0.0.1", 9999],
       :storage => "utxo::sqlite://~/.bitcoin-ruby/<network>/blocks.db",
+      :announce => false,
+      :external_port => nil,
       :mode => :full,
+      :cache_head => true,
+      :index_nhash => false,
+      :index_p2sh_type => false,
       :dns => true,
       :epoll_limit => 10000,
       :epoll_user => nil,
@@ -102,8 +107,9 @@ module Bitcoin::Network
     def set_store
       backend, config = @config[:storage].split('::')
       @store = Bitcoin::Storage.send(backend, {
-          db: config, mode: @config[:mode], cache_head: true,
-          skip_validation: @config[:skip_validation],
+          db: config, mode: @config[:mode], cache_head: @config[:cache_head],
+          skip_validation: @config[:skip_validation], index_nhash: @config[:index_nhash],
+          index_p2sh_type: @config[:index_p2sh_type],
           log_level: @config[:log][:storage]}, ->(locator) {
           peer = @connections.select(&:connected?).sample
           peer.send_getblocks(locator)
@@ -251,6 +257,31 @@ module Bitcoin::Network
           self.stop
         end
 
+        subscribe(:block) do |blk, depth|
+          next  unless @store.in_sync?
+          @log.debug { "Relaying block #{blk.hash}" }
+          @connections.each do |conn|
+            next  unless conn.connected?
+            conn.send_inv(:block, blk.hash)
+          end
+        end
+
+        @store.subscribe(:block) do |blk, depth, chain|
+          if chain == 0 && blk.hash == @store.get_head.hash
+            @last_block_time = Time.now
+            push_notification(:block, [blk, depth])
+            blk.tx.each {|tx| @unconfirmed.delete(tx.hash) }
+          end
+          getblocks  if chain == 2 && @store.in_sync?
+        end
+
+        @store.subscribe(:reorg) do |new_main, new_side|
+          @log.warn { "Reorg of #{new_side.size} blocks." }
+          new_main.each {|b| @log.debug { "new main: #{b}" } }
+          new_side.each {|b| @log.debug { "new side: #{b}" } }
+          push_notification(:reorg, [new_main, new_side])
+        end
+
       end
     end
 
@@ -378,27 +409,13 @@ module Bitcoin::Network
       while obj = @queue.shift
         begin
           if obj[0].to_sym == :block
-            if res = @store.send("new_#{obj[0]}", obj[1])
-              if res[1] == 0  && obj[1].hash == @store.get_head.hash
-                @last_block_time = Time.now
-                push_notification(:block, [obj[1], res[0]])
-                obj[1].tx.each {|tx| @unconfirmed.delete(tx.hash) }
-              end
-              getblocks  if res[1] == 2 && @store.in_sync?
-            end
+            @store.new_block(obj[1])
           else
             drop = @unconfirmed.size - @config[:max][:unconfirmed] + 1
             drop.times { @unconfirmed.shift }  if drop > 0
             unless @unconfirmed[obj[1].hash]
               @unconfirmed[obj[1].hash] = obj[1]
               push_notification(:tx, [obj[1], 0])
-
-              if @notifiers[:output]
-                obj[1].out.each do |out|
-                  address = Bitcoin::Script.new(out.pk_script).get_address
-                  push_notification(:output, [obj[1].hash, address, out.value, 0])
-                end
-              end
             end
           end
         rescue Bitcoin::Validation::ValidationError
@@ -456,6 +473,12 @@ module Bitcoin::Network
       @config[:listen][0]
     end
 
+    # get the external port
+    # assume the same as local port if config option :external_port isn't given explicitly
+    def external_port
+      @config[:external_port] || @config[:listen][1] || Bitcoin.network[:default_port]
+    end
+
     # push notification +message+ to +channel+
     def push_notification channel, message
       @notifiers[channel.to_sym].push(message)  if @notifiers[channel.to_sym]
@@ -466,12 +489,30 @@ module Bitcoin::Network
     # see CommandHandler for details.
     def subscribe channel
       @notifiers[channel.to_sym] ||= EM::Channel.new
-      @notifiers[channel.to_sym].subscribe {|*data| yield(*data) }
+      @notifiers[channel.to_sym].subscribe do |*data|
+        begin
+          yield(*data)
+        rescue
+          p $!; puts *$@
+        end
+      end
+    end
+
+    def unsubscribe channel, id
+      @notifiers[channel.to_sym].unsubscribe(id)
     end
 
     # should the node accept new incoming connections?
     def accept_connections?
-      connections.select(&:incoming?).size >= config[:max][:connections_in]
+      connections.select(&:incoming?).size < config[:max][:connections_in]
+    end
+
+    # get Addr object for our own server
+    def addr
+      @addr = Bitcoin::P::Addr.new
+      @addr.time, @addr.service, @addr.ip, @addr.port =
+        Time.now.tv_sec, (1 << 0), external_ip, external_port
+      @addr
     end
 
   end

data/lib/bitcoin/protocol.rb

@@ -12,7 +12,7 @@ module Bitcoin
 
     # 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'
@@ -161,6 +161,10 @@ module Bitcoin
       pkt "getheaders", locator_payload(version, locator_hashes, stop_hash)
     end
 
+    def self.headers_pkt(version, blocks)
+      pkt "headers", [pack_var_int(blocks.size), blocks.map{|block| block.block_header}.join].join
+    end
+
     def self.read_binary_file(path)
       File.open(path, 'rb'){|f| f.read }
     end

data/lib/bitcoin/protocol/block.rb

@@ -73,7 +73,7 @@ module Bitcoin
         @ver, @prev_block, @mrkl_root, @time, @bits, @nonce = buf.read(80).unpack("Va32a32VVV")
         recalc_block_hash
 
-        if (@ver & BLOCK_VERSION_AUXPOW) > 0
+        if Bitcoin.network[:project] == :namecoin && (@ver & BLOCK_VERSION_AUXPOW) > 0
           @aux_pow = AuxPow.new(nil)
           @aux_pow.parse_data_from_io(buf)
         end
@@ -99,6 +99,10 @@ module Bitcoin
         @hash = Bitcoin.block_hash(@prev_block.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)
+      end
+
       def recalc_mrkl_root
         @mrkl_root = Bitcoin.hash_mrkl_tree( @tx.map(&:hash) ).last.htb_reverse
       end
@@ -216,20 +220,28 @@ module Bitcoin
         JSON.pretty_generate( h, options )
       end
 
+      # block header binary output
+      def block_header
+        [@ver, @prev_block, @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
 
       # read json block from a file
       def self.from_json_file(path); from_json( Bitcoin::Protocol.read_binary_file(path) ); end
 
+      # Get a Bitcoin::Validation object to validate this block. It needs a +store+
+      # to validate against, and optionally takes the +prev_block+ for optimization.
       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)
+        target = Bitcoin.decode_compact_bits(@bits).to_i(16)
+        return 0 if target <= 0
+        (2**256) / (target + 1)
       end
 
     end

data/lib/bitcoin/protocol/parser.rb

@@ -111,8 +111,8 @@ module Bitcoin
 
       # 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
+        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
         @h.on_mempool if @h.respond_to?(:on_mempool)
       end
 
@@ -139,7 +139,7 @@ module Bitcoin
       def parse_buffer
         head_magic = Bitcoin::network[:magic_head]
         head_size  = 24
-        return false if @buf.size <= head_size
+        return false if @buf.size < head_size
 
         magic, cmd, length, checksum = @buf.unpack("a4A12Va4")
         payload = @buf[head_size...head_size+length]

data/lib/bitcoin/protocol/tx.rb

@@ -25,6 +25,9 @@ module Bitcoin
       # lock time
       attr_accessor :lock_time
 
+      # parsed / evaluated input scripts cached for later use
+      attr_reader :scripts
+
       alias :inputs  :in
       alias :outputs :out
 
@@ -35,12 +38,12 @@ module Bitcoin
 
       # return the tx hash in binary format
       def binary_hash
-        [@hash].pack("H*").reverse
+        @binary_hash ||= [@hash].pack("H*").reverse
       end
 
       # create tx from raw binary +data+
       def initialize(data=nil)
-        @ver, @lock_time, @in, @out = 1, 0, [], []
+        @ver, @lock_time, @in, @out, @scripts = 1, 0, [], [], []
         parse_data_from_io(data) if data
       end
 
@@ -102,24 +105,28 @@ module Bitcoin
 
       # 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)
+      def signature_hash_for_input(input_idx, subscript, hash_type=nil)
         # https://github.com/bitcoin/bitcoin/blob/e071a3f6c06f41068ad17134189a4ac3073ef76b/script.cpp#L834
         # 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
 
+        # Note: BitcoinQT checks if input_idx >= @in.size and returns 1 with an error message.
+        # But this check is never actually useful because BitcoinQT would crash 
+        # right before VerifyScript if input index is out of bounds (inside CScriptCheck::operator()()).
+        # That's why we don't need to do such a check here.
+        #
+        # However, if you look at the case SIGHASH_TYPE[:single] below, we must 
+        # return 1 because it's possible to have more inputs than outputs and BitcoinQT returns 1 as well.
         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 = 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)
+            subscript = subscript.out[ input.prev_out_index ].script if subscript.respond_to?(:out) # legacy api (outpoint_tx)
+            input.to_payload(subscript)
           else
             case (hash_type & 0x1f)
             when SIGHASH_TYPE[:none];   input.to_payload("", "\x00\x00\x00\x00")
@@ -152,16 +159,22 @@ module Bitcoin
 
       # verify input signature +in_idx+ against the corresponding
       # output in +outpoint_tx+
-      def verify_input_signature(in_idx, outpoint_tx, block_timestamp=Time.now.to_i)
+      # outpoint
+      def verify_input_signature(in_idx, outpoint_tx_or_script, 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
+        
+        # If given an entire previous transaction, take the script from it
+        script_pubkey = if outpoint_tx_or_script.respond_to?(:out) 
+          outpoint_tx_or_script.out[outpoint_idx].pk_script
+        else
+          # Otherwise, it's already a script.
+          outpoint_tx_or_script
+        end
 
-        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)
+        @scripts[in_idx] = Bitcoin::Script.new(script_sig, script_pubkey)
+        @scripts[in_idx].run(block_timestamp) do |pubkey,sig,hash_type,subscript|
+          hash = signature_hash_for_input(in_idx, subscript, hash_type)
           Bitcoin.verify_signature( hash, sig, pubkey.unpack("H*")[0] )
         end
       end
@@ -170,7 +183,7 @@ module Bitcoin
       def to_hash(options = {})
         @hash ||= hash_from_payload(to_payload)
         h = {
-          'hash' => @hash, 'ver' => @ver,
+          'hash' => @hash, 'ver' => @ver, # 'nid' => normalized_hash,
           'vin_sz' => @in.size, 'vout_sz' => @out.size,
           'lock_time' => @lock_time, 'size' => (@payload ||= to_payload).bytesize,
           'in'  =>  @in.map{|i| i.to_hash(options) },
@@ -215,13 +228,46 @@ 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, block = nil)
-        @validator ||= Bitcoin::Validation::Tx.new(self, store, block)
+      # Get a Bitcoin::Validation object to validate this block. It needs a +store+
+      # to validate against, a block to validate tx chains inside one block, and
+      # optionally takes the +block_validator+ as an optimization.
+      def validator(store, block = nil, block_validator = nil)
+        @validator ||= Bitcoin::Validation::Tx.new(self, store, block, block_validator)
       end
 
       def size
         payload.bytesize
       end
+      
+      # Checks if transaction is final taking into account height and time 
+      # of a block in which it is located (or about to be included if it's unconfirmed tx).
+      def is_final?(block_height, block_time)
+        # No time lock - tx is final.
+        return true if lock_time == 0
+
+        # Time based nLockTime implemented in 0.1.6
+        # If lock_time is below the magic threshold treat it as a block height.
+        # If lock_time is above the threshold, it's a unix timestamp.
+        return true if lock_time < (lock_time < Bitcoin::LOCKTIME_THRESHOLD ? block_height : block_time)
+
+        inputs.each{|input| return false if !input.is_final? }
+
+        return true
+      end
+      
+      def legacy_sigops_count
+        # Note: input scripts normally never have any opcodes since every input script 
+        # can be statically reduced to a pushdata-only script.
+        # However, anyone is allowed to create a non-standard transaction with any opcodes in the inputs.
+        count = 0
+        self.in.each do |txin|
+          count += Bitcoin::Script.new(txin.script_sig).sigops_count_accurate(false)
+        end
+        self.out.each do |txout|
+          count += Bitcoin::Script.new(txout.pk_script).sigops_count_accurate(false)
+        end
+        count
+      end
 
       DEFAULT_BLOCK_PRIORITY_SIZE = 27000
 
@@ -241,13 +287,24 @@ module Bitcoin
           #   multiple transactions instead of one big transaction to avoid fees.
           # * If we are creating a transaction we allow transactions up to 1,000 bytes
           #   to be considered safe and assume they can likely make it into this section.
-          min_fee = 0 if tx_size < (mode == :block ? 1_000 : DEFAULT_BLOCK_PRIORITY_SIZE - 1_000)
+          min_fee = 0 if tx_size < (mode == :block ? Bitcoin.network[:free_tx_bytes] : DEFAULT_BLOCK_PRIORITY_SIZE - 1_000)
         end
 
         # This code can be removed after enough miners have upgraded to version 0.9.
         # Until then, be safe when sending and require a fee if any output is less than CENT
         if min_fee < base_fee && mode == :block
-          outputs.each{|output| (min_fee = base_fee; break) if output.value < Bitcoin::CENT }
+          outputs.each do |output|
+            if output.value < Bitcoin.network[:dust]
+              # If per dust fee, then we add min fee for each output less than dust.
+              # Otherwise, we set to min fee if there is any output less than dust.
+              if Bitcoin.network[:per_dust_fee]
+                min_fee += base_fee
+              else
+                min_fee = base_fee
+                break
+              end
+            end
+          end
         end
 
         min_fee = Bitcoin::network[:max_money] unless min_fee.between?(0, Bitcoin::network[:max_money])
@@ -258,6 +315,11 @@ module Bitcoin
         inputs.size == 1 and inputs.first.coinbase?
       end
 
+      def normalized_hash
+        signature_hash_for_input(-1, nil, SIGHASH_TYPE[:all]).unpack("H*")[0]
+      end
+      alias :nhash :normalized_hash
+
     end
   end
 end