bitcoin-ruby 0.0.18 → 0.0.19

data/lib/bitcoin/protocol/txin.rb

@@ -2,19 +2,21 @@
 
 module Bitcoin
   module Protocol
-
+    # TxIn section of https://en.bitcoin.it/wiki/Protocol_documentation#tx
     class TxIn
-
       # previous output hash
       attr_accessor :prev_out_hash
-      alias :prev_out :prev_out_hash
-      def prev_out=(hash); @prev_out_hash = hash; end
+      alias prev_out prev_out_hash
+      def prev_out=(hash)
+        @prev_out_hash = hash
+      end
 
       # previous output index
       attr_accessor :prev_out_index
 
       # script_sig input Script (signature)
-      attr_accessor :script_sig, :script_sig_length
+      attr_reader :script_sig
+      attr_accessor :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)
@@ -23,17 +25,17 @@ module Bitcoin
       # segregated witness
       attr_accessor :script_witness
 
-      alias :script   :script_sig
-      alias :script_length  :script_sig_length
+      alias script script_sig
+      alias script_length script_sig_length
 
       # sequence
       attr_accessor :sequence
 
-      DEFAULT_SEQUENCE = "\xff\xff\xff\xff"
-      NULL_HASH = "\x00"*32
+      DEFAULT_SEQUENCE = "\xff\xff\xff\xff".freeze
+      NULL_HASH = "\x00" * 32
       COINBASE_INDEX = 0xffffffff
 
-      def initialize *args
+      def initialize(*args)
         @prev_out_hash, @prev_out_index, @script_sig_length,
         @script_sig, @sequence = *args
         @script_sig_length ||= 0
@@ -48,13 +50,18 @@ module Bitcoin
           @prev_out_index == other.prev_out_index &&
           @script_sig == other.script_sig &&
           @sequence == other.sequence
-      rescue
+      rescue StandardError
         false
       end
-      
+
+      def is_final? # rubocop:disable Naming/PredicateName
+        warn '[DEPRECATION] `TxIn.is_final?` is deprecated. Use `final?` instead.'
+        final?
+      end
+
       # returns true if the sequence number is final (DEFAULT_SEQUENCE)
-      def is_final?
-        self.sequence == DEFAULT_SEQUENCE
+      def final?
+        sequence == DEFAULT_SEQUENCE
       end
 
       # parse raw binary data for transaction input
@@ -65,11 +72,13 @@ module Bitcoin
       end
 
       def self.from_io(buf)
-        txin = new; txin.parse_data_from_io(buf); txin
+        txin = new
+        txin.parse_data_from_io(buf)
+        txin
       end
 
       def parse_data_from_io(buf)
-        @prev_out_hash, @prev_out_index = buf.read(36).unpack("a32V")
+        @prev_out_hash, @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)
@@ -79,40 +88,39 @@ module Bitcoin
         @parsed_script ||= Bitcoin::Script.new(script_sig)
       end
 
-      def to_payload(script=@script_sig, sequence=@sequence)
-        [@prev_out_hash, @prev_out_index].pack("a32V") << Protocol.pack_var_int(script.bytesize) << script << (sequence || DEFAULT_SEQUENCE)
+      def to_payload(script = @script_sig, sequence = @sequence)
+        [@prev_out_hash, @prev_out_index].pack('a32V') << Protocol.pack_var_int(script.bytesize) \
+                                                       << script << (sequence || DEFAULT_SEQUENCE)
       end
 
-      def to_hash(options = {})
-        t = { 'prev_out'  => { 'hash' => @prev_out_hash.reverse_hth, 'n' => @prev_out_index } }
+      def to_hash(_options = {})
+        t = { 'prev_out' => { 'hash' => @prev_out_hash.reverse_hth, 'n' => @prev_out_index } }
         if coinbase?
-          t['coinbase']  = @script_sig.unpack("H*")[0]
+          t['coinbase']  = @script_sig.unpack('H*')[0]
         else # coinbase tx
           t['scriptSig'] = Bitcoin::Script.new(@script_sig).to_string
         end
-        t['sequence']  = @sequence.unpack("V")[0] unless @sequence == "\xff\xff\xff\xff"
-        t['witness'] = @script_witness.stack.map{|s|s.bth} unless @script_witness.empty?
+        t['sequence'] = @sequence.unpack('V')[0] unless @sequence == "\xff\xff\xff\xff"
+        t['witness'] = @script_witness.stack.map(&:bth) unless @script_witness.empty?
         t
       end
 
       def self.from_hash(input)
         previous_hash         = input['previous_transaction_hash'] || input['prev_out']['hash']
         previous_output_index = input['output_index'] || input['prev_out']['n']
-        txin = TxIn.new([ previous_hash ].pack('H*').reverse, previous_output_index)
-        if input['coinbase']
-          txin.script_sig = [ input['coinbase'] ].pack("H*")
-        else
-          txin.script_sig = Script.binary_from_string(input['scriptSig'] || input['script'])
-        end
-        if input['witness']
-          input['witness'].each {|w| txin.script_witness.stack << w.htb}
-        end
-        txin.sequence = [ input['sequence'] || 0xffffffff ].pack("V")
+        txin = TxIn.new([previous_hash].pack('H*').reverse, previous_output_index)
+        txin.script_sig = if input['coinbase']
+                            [input['coinbase']].pack('H*')
+                          else
+                            Script.binary_from_string(input['scriptSig'] || input['script'])
+                          end
+        input['witness'].each { |w| txin.script_witness.stack << w.htb } if input['witness']
+        txin.sequence = [input['sequence'] || 0xffffffff].pack('V')
         txin
       end
 
       def self.from_hex_hash(hash, index)
-        TxIn.new([hash].pack("H*").reverse, index, 0)
+        TxIn.new([hash].pack('H*').reverse, index, 0)
       end
 
       # previous output in hex
@@ -130,13 +138,11 @@ module Bitcoin
         @script_sig_length = script_sig.bytesize
         @script_sig = script_sig
       end
-      alias :script= :script_sig=
+      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*"))
+        self.script = Bitcoin::Script.to_signature_pubkey_script(sig, [pubkey_hex].pack('H*'))
       end
-
     end
-
   end
 end

data/lib/bitcoin/protocol/txout.rb

@@ -2,9 +2,8 @@
 
 module Bitcoin
   module Protocol
-
+    # TxOut section of https://en.bitcoin.it/wiki/Protocol_documentation#tx
     class TxOut
-
       # output value (in base units; "satoshi")
       attr_accessor :value
 
@@ -14,16 +13,20 @@ module Bitcoin
       # p2sh redeem script (optional, not included in the serialized binary format)
       attr_accessor :redeem_script
 
-      def initialize *args
+      def initialize(*args)
         if args.size == 2
-          @value, @pk_script_length, @pk_script = args[0], args[1].bytesize, args[1]
+          @value = args[0]
+          @pk_script_length = args[1].bytesize
+          @pk_script = args[1]
         else
           @value, @pk_script_length, @pk_script = *args
         end
       end
 
       def ==(other)
-        @value == other.value && @pk_script == other.pk_script rescue false
+        @value == other.value && @pk_script == other.pk_script
+      rescue StandardError
+        false
       end
 
       # parse raw binary data for transaction output
@@ -34,18 +37,20 @@ module Bitcoin
       end
 
       def self.from_io(buf)
-        txout = new; txout.parse_data_from_io(buf); txout
+        txout = new
+        txout.parse_data_from_io(buf)
+        txout
       end
 
       # parse raw binary data for transaction output
       def parse_data_from_io(buf)
         clear_parsed_script_cache
-        @value = buf.read(8).unpack("Q")[0]
+        @value = buf.read(8).unpack('Q')[0]
         @pk_script_length = Protocol.unpack_var_int_from_io(buf)
         @pk_script = buf.read(@pk_script_length)
       end
 
-      alias :parse_payload :parse_data
+      alias parse_payload parse_data
 
       def parsed_script
         @parsed_script ||= Bitcoin::Script.new(pk_script)
@@ -56,7 +61,7 @@ module Bitcoin
       end
 
       def to_payload
-        [@value].pack("Q") << Protocol.pack_var_int(@pk_script_length) << @pk_script
+        [@value].pack('Q') << Protocol.pack_var_int(@pk_script_length) << @pk_script
       end
 
       def to_null_payload
@@ -64,14 +69,17 @@ module Bitcoin
       end
 
       def to_hash(options = {})
-        h = { 'value' => "%.8f" % (@value / 100000000.0),
-          'scriptPubKey' => parsed_script.to_string }
-        h["address"] = parsed_script.get_address  if parsed_script.is_hash160? && options[:with_address]
+        h = { 'value' => format('%.8f', (@value / 100_000_000.0)),
+              'scriptPubKey' => parsed_script.to_string }
+        if options[:with_address]
+          addrs = parsed_script.get_addresses
+          h['address'] = addrs.first if addrs.size == 1
+        end
         h
       end
 
       def self.from_hash(output)
-        amount = output['value'] ? output['value'].gsub('.','').to_i : output['amount']
+        amount = output['value'] ? output['value'].delete('.').to_i : output['amount']
         script = Script.binary_from_string(output['scriptPubKey'] || output['script'])
         new(amount, script)
       end
@@ -79,14 +87,15 @@ module Bitcoin
       # set pk_script and pk_script_length
       def pk_script=(pk_script)
         clear_parsed_script_cache
-        @pk_script_length, @pk_script = pk_script.bytesize, pk_script
+        @pk_script_length = pk_script.bytesize
+        @pk_script = pk_script
       end
 
-      alias :amount   :value
-      alias :amount=  :value=
+      alias amount   value
+      alias amount=  value=
 
-      alias :script   :pk_script
-      alias :script=  :pk_script=
+      alias script   pk_script
+      alias script=  pk_script=
 
       # create output spending +value+ btc (base units) to +address+
       def self.value_to_address(value, address)
@@ -94,8 +103,6 @@ module Bitcoin
         raise "Script#pk_script nil with address #{address}" unless pk_script
         new(value, pk_script)
       end
-
     end
-
   end
 end

data/lib/bitcoin/protocol/version.rb

@@ -2,7 +2,6 @@
 
 module Bitcoin
   module Protocol
-
     # https://en.bitcoin.it/wiki/Protocol_specification#version
     class Version
       # services bit constants
@@ -11,78 +10,92 @@ module Bitcoin
 
       attr_reader :fields
 
-      def initialize(opts={})
+      def initialize(opts = {})
         @fields = {
-          :version    => Bitcoin.network[:protocol_version],
-          :services   => NODE_NETWORK,
-          :time       => Time.now.tv_sec,
-          :from       => "127.0.0.1:8333",
-          :to         => "127.0.0.1:8333",
-          :nonce      => Bitcoin::Protocol::Uniq,
-          :user_agent => "/bitcoin-ruby:#{Bitcoin::VERSION}/",
-          :last_block => 0, # 188617
-          :relay      => true # BIP0037
-        }.merge( opts.reject{|k,v| v == nil } )
+          version: Bitcoin.network[:protocol_version],
+          services: NODE_NETWORK,
+          time: Time.now.tv_sec,
+          from: '127.0.0.1:8333',
+          to: '127.0.0.1:8333',
+          nonce: Bitcoin::Protocol::Uniq,
+          user_agent: "/bitcoin-ruby:#{Bitcoin::VERSION}/",
+          last_block: 0, # 188617
+          relay: true # BIP0037
+        }.merge(opts.reject { |_k, v| v.nil? })
       end
 
       def to_payload
         [
-          @fields.values_at(:version, :services, :time).pack("VQQ"),
+          @fields.values_at(:version, :services, :time).pack('VQQ'),
           pack_address_field(@fields[:from]),
           pack_address_field(@fields[:to]),
-          @fields.values_at(:nonce).pack("Q"),
+          @fields.values_at(:nonce).pack('Q'),
           Protocol.pack_var_string(@fields[:user_agent]),
-          @fields.values_at(:last_block).pack("V"),
-          Protocol.pack_boolean(@fields[:relay]) # Satoshi 0.8.6 doesn't send this but it does respect it
+          @fields.values_at(:last_block).pack('V'),
+          # Satoshi 0.8.6 doesn't send this but it does respect it
+          Protocol.pack_boolean(@fields[:relay])
         ].join
       end
 
       def to_pkt
-        Bitcoin::Protocol.pkt("version", to_payload)
+        Bitcoin::Protocol.pkt('version', to_payload)
       end
 
       def parse(payload)
-        version, services, timestamp, to, from, nonce, payload = payload.unpack("VQQa26a26Qa*")
-        to, from = unpack_address_field(to), unpack_address_field(from)
+        version, services, timestamp, to, from, nonce, payload = payload.unpack('VQQa26a26Qa*')
+        to = unpack_address_field(to)
+        from = unpack_address_field(from)
         user_agent, payload = Protocol.unpack_var_string(payload)
-        last_block, payload = payload.unpack("Va*")
-        relay, payload = unpack_relay_field(version, payload)
+        last_block, payload = payload.unpack('Va*')
+        relay, = unpack_relay_field(version, payload)
 
         @fields = {
-         :version => version, :services => services, :time => timestamp,
-         :from => from, :to => to, :nonce => nonce,
-         :user_agent => user_agent.to_s, :last_block => last_block, :relay => relay
+          version: version, services: services, time: timestamp,
+          from: from, to: to, nonce: nonce,
+          user_agent: user_agent.to_s, last_block: last_block, relay: relay
         }
         self
       end
 
       def unpack_address_field(payload)
-        ip, port = payload.unpack("x8x12a4n")
-        "#{ip.unpack("C*").join(".")}:#{port}"
+        ip, port = payload.unpack('x8x12a4n')
+        "#{ip.unpack('C*').join('.')}:#{port}"
       end
 
       def pack_address_field(addr_str)
-        host, port = addr_str.split(":")
+        host, port = addr_str.split(':')
         port = port ? port.to_i : 8333
         sockaddr = Socket.pack_sockaddr_in(port, host)
-        #raise "invalid IPv4 Address: #{addr}" unless sockaddr[0...2] == "\x02\x00"
-        port, host = sockaddr[2...4], sockaddr[4...8]
-        [[1].pack("Q"), "\x00"*10, "\xFF\xFF",  host, port].join
+        # raise "invalid IPv4 Address: #{addr}" unless sockaddr[0...2] == "\x02\x00"
+        port = sockaddr[2...4]
+        host = sockaddr[4...8]
+        [[1].pack('Q'), "\x00" * 10, "\xFF\xFF", host, port].join
       end
 
       # BIP0037: this field starts with version 70001 and is allowed to be missing, defaults to true
       def unpack_relay_field(version, payload)
-        ( version >= 70001 and payload ) ? Protocol.unpack_boolean(payload) : [ true, nil ]
+        version >= 70_001 && payload ? Protocol.unpack_boolean(payload) : [true, nil]
       end
 
       def uptime
         @fields[:time] - Time.now.tv_sec
       end
 
-      def method_missing(*a); (@fields[a.first] rescue nil) or super(*a); end
+      def method_missing(*a)
+        @fields[a.first]
+      rescue StandardError
+        super
+      end
 
-      def self.parse(payload); new.parse(payload); end
-    end
+      def respond_to_missing?(*a)
+        @fields[a.first]
+      rescue StandardError
+        super
+      end
 
+      def self.parse(payload)
+        new.parse(payload)
+      end
+    end
   end
 end

data/lib/bitcoin/script.rb

@@ -161,9 +161,13 @@ class Bitcoin::Script
   attr_reader :raw, :chunks, :debug, :stack
 
   # create a new script. +bytes+ is typically input_script + output_script
+
   def initialize(input_script, previous_output_script=nil)
     @raw_byte_sizes = [input_script.bytesize, previous_output_script ? previous_output_script.bytesize : 0]
     @input_script, @previous_output_script = input_script, previous_output_script
+    @parse_invalid = nil
+    @inner_p2sh = nil
+    @script_codeseparator_index = nil
 
     @raw = if @previous_output_script
              @input_script + [ Bitcoin::Script::OP_CODESEPARATOR ].pack("C") + @previous_output_script
@@ -258,7 +262,7 @@ class Bitcoin::Script
     (chunks || @chunks).each.with_index{|i,idx|
       string << " " unless idx == 0
       string << case i
-      when Fixnum
+      when Bitcoin::Integer
         if opcode = OPCODES_PARSE_BINARY[i]
           opcode
         else
@@ -276,9 +280,10 @@ class Bitcoin::Script
   end
 
   def to_binary(chunks=nil)
+
     (chunks || @chunks).map{|chunk|
       case chunk
-      when Fixnum; [chunk].pack("C*")
+      when Bitcoin::Integer; [chunk].pack("C*")
       when String; self.class.pack_pushdata(chunk)
       end
     }.join
@@ -317,7 +322,7 @@ class Bitcoin::Script
   # Adds opcode (OP_0, OP_1, ... OP_CHECKSIG etc.)
   # Returns self.
   def append_opcode(opcode)
-    raise "Opcode should be a Fixnum" if !opcode.is_a?(Fixnum)
+    raise "Opcode should be an integer" if !opcode.is_a?(Bitcoin::Integer)
     if opcode >= OP_0 && opcode <= 0xff
       @chunks << opcode
     else
@@ -417,7 +422,7 @@ class Bitcoin::Script
         end
       end
 
-      buf << if i.is_a?(Fixnum)
+      buf << if i.is_a?(Bitcoin::Integer)
                i < 256 ? [i].pack("C") : [OpenSSL::BN.new(i.to_s,10).to_hex].pack("H*")
              else
                i
@@ -452,7 +457,7 @@ class Bitcoin::Script
       #p [@stack, @do_exec]
 
       case chunk
-      when Fixnum
+      when Bitcoin::Integer
         if DISABLED_OPCODES.include?(chunk)
           @script_invalid = true
           @debug << "DISABLED_#{OPCODES[chunk]}"
@@ -550,7 +555,8 @@ class Bitcoin::Script
 
   # is this a :script_hash (pay-to-script-hash/p2sh) script?
   def is_pay_to_script_hash?
-    return false  if @inner_p2sh
+    @inner_p2sh ||= false
+    return false if @inner_p2sh
     if @previous_output_script
       chunks = Bitcoin::Script.new(@previous_output_script).chunks
       chunks.size == 3 &&
@@ -590,7 +596,7 @@ class Bitcoin::Script
 
   # is this a multisig script
   def is_multisig?
-    return false  if @chunks.size < 4 || !@chunks[-2].is_a?(Fixnum)
+    return false  if @chunks.size < 4 || !@chunks[-2].is_a?(Bitcoin::Integer)
     @chunks[-1] == OP_CHECKMULTISIG and get_multisig_pubkeys.all?{|c| c.is_a?(String) }
   end
 
@@ -616,12 +622,12 @@ class Bitcoin::Script
 
   # Verify the script is only pushing data onto the stack
   def is_push_only?(script_data=nil)
-    check_pushes(push_only=true, canonical_only=false, (script_data||@input_script))
+    check_pushes(true, false, (script_data||@input_script))
   end
 
   # Make sure opcodes used to push data match their intended length ranges
   def pushes_are_canonical?(script_data=nil)
-    check_pushes(push_only=false, canonical_only=true, (script_data||@raw))
+    check_pushes(false, true, (script_data||@raw))
   end
 
   def check_pushes(push_only=true, canonical_only=false, buf)
@@ -930,7 +936,7 @@ class Bitcoin::Script
       elsif chunk == OP_CHECKMULTISIG || chunk == OP_CHECKMULTISIGVERIFY
         # Accurate mode counts exact number of pubkeys required (not signatures, but pubkeys!). Only used in P2SH scripts.
         # Inaccurate mode counts every multisig as 20 signatures.
-        if is_accurate && last_opcode && last_opcode.is_a?(Fixnum) && last_opcode >= OP_1 && last_opcode <= OP_16
+        if is_accurate && last_opcode && last_opcode.is_a?(Bitcoin::Integer) && last_opcode >= OP_1 && last_opcode <= OP_16
           count += ::Bitcoin::Script.decode_OP_N(last_opcode)
         else
           count += 20
@@ -956,7 +962,7 @@ class Bitcoin::Script
     data = nil
     @chunks.each do |chunk|
       case chunk
-      when Fixnum
+      when Bitcoin::Integer
         data = ""
         return 0 if chunk > OP_16
       when String
@@ -974,7 +980,7 @@ class Bitcoin::Script
     if opcode == OP_0
       return 0
     end
-    if opcode.is_a?(Fixnum) && opcode >= OP_1 && opcode <= OP_16
+    if opcode.is_a?(Bitcoin::Integer) && opcode >= OP_1 && opcode <= OP_16
       return opcode - (OP_1 - 1);
     else
       nil
@@ -1533,11 +1539,6 @@ class Bitcoin::Script
     op_verify
   end
 
-  # op_eval: https://en.bitcoin.it/wiki/BIP_0012
-  #   the BIP was never accepted and must be handled as old OP_NOP1
-  def op_nop1
-  end
-
   OPCODES_METHOD = Hash[*instance_methods.grep(/^op_/).map{|m|
       [ (OPCODES.find{|k,v| v == m.to_s.upcase }.first rescue nil), m ]
     }.flatten]