bitcoin-ruby 0.0.18 → 0.0.19

data/lib/bitcoin/connection.rb

@@ -6,7 +6,7 @@ require 'bitcoin'
 require 'resolv'
 
 module Bitcoin
-
+  # Handle messages received from node
   module ConnectionHandler
     def on_inv_transaction(hash)
       p ['inv transaction', hash.hth]
@@ -38,13 +38,13 @@ module Bitcoin
 
     def on_block(block)
       p ['block', block.hash]
-      #p block.payload.each_byte.map{|i| "%02x" % [i] }.join(" ")
-      #puts block.to_json
+      # p block.payload.each_byte.map{|i| "%02x" % [i] }.join(" ")
+      # puts block.to_json
     end
 
     def on_version(version)
       p [@sockaddr, 'version', version, version.time - Time.now.to_i]
-      send_data( Protocol.verack_pkt )
+      send_data(Protocol.verack_pkt)
     end
 
     def on_verack
@@ -59,17 +59,17 @@ module Bitcoin
     end
 
     def query_blocks
-      start = ("\x00"*32)
-      stop  = ("\x00"*32)
-      pkt = Protocol.pkt("getblocks", "\x00" + start + stop )
+      start = ("\x00" * 32)
+      stop  = ("\x00" * 32)
+      pkt = Protocol.pkt('getblocks', "\x00" + start + stop)
       send_data(pkt)
     end
 
     def on_handshake_begin
-      block   = 127953
-      from    = "127.0.0.1:8333"
+      block   = 127_953
+      from    = '127.0.0.1:8333'
       from_id = Bitcoin::Protocol::Uniq
-      to      = @sockaddr.reverse.join(":")
+      to      = @sockaddr.reverse.join(':')
       # p "==", from_id, from, to, block
       pkt = Protocol.version_pkt(from_id, from, to, block)
       p ['sending version pkt', pkt]
@@ -77,19 +77,19 @@ module Bitcoin
     end
   end
 
-
+  # Establish connection to node
   class Connection < EM::Connection
     include ConnectionHandler
 
     def initialize(host, port, connections)
       @sockaddr = [port, host]
       @connections = connections
-      @parser = Bitcoin::Protocol::Parser.new( self )
+      @parser = Bitcoin::Protocol::Parser.new(self)
     end
 
     def post_init
       p ['connected', @sockaddr]
-      EM.schedule{ on_handshake_begin }
+      EM.schedule { on_handshake_begin }
     end
 
     def receive_data(data)
@@ -107,24 +107,21 @@ module Bitcoin
 
     def self.connect_random_from_dns(connections)
       seeds = Bitcoin.network[:dns_seeds]
-      if seeds.any?
-        host = Resolv::DNS.new.getaddresses(seeds.sample).map {|a| a.to_s}.sample
-        connect(host, Bitcoin::network[:default_port], connections)
-      else
-        raise "No DNS seeds available. Provide IP, configure seeds, or use different network."
+      if seeds.empty?
+        raise 'No DNS seeds available. Provide IP, configure seeds, or use different network.'
       end
+
+      host = Resolv::DNS.new.getaddresses(seeds.sample).map(&:to_s).sample
+      connect(host, Bitcoin.network[:default_port], connections)
     end
   end
 end
 
-
-if $0 == __FILE__
+if $PROGRAM_NAME == __FILE__
   EM.run do
-
     connections = []
-    #Bitcoin::Connection.connect('127.0.0.1', 8333, connections)
-    #Bitcoin::Connection.connect('217.157.1.202', 8333, connections)
+    # Bitcoin::Connection.connect('127.0.0.1', 8333, connections)
+    # Bitcoin::Connection.connect('217.157.1.202', 8333, connections)
     Bitcoin::Connection.connect_random_from_dns(connections)
-
   end
 end

data/lib/bitcoin/contracthash.rb

@@ -1,43 +1,39 @@
-#
-# Ruby port of https://github.com/Blockstream/contracthashtool
-#
-
 module Bitcoin
+  # Ruby port of https://github.com/Blockstream/contracthashtool
   module ContractHash
-
-    HMAC_DIGEST = OpenSSL::Digest.new("SHA256")
-    EC_GROUP = OpenSSL::PKey::EC::Group.new("secp256k1")
+    HMAC_DIGEST = OpenSSL::Digest.new('SHA256')
+    EC_GROUP = OpenSSL::PKey::EC::Group.new('secp256k1')
 
     def self.hmac(pubkey, data)
       OpenSSL::HMAC.hexdigest(HMAC_DIGEST, pubkey, data)
     end
 
     # generate a contract address
-    def self.generate(redeem_script_hex, payee_address_or_ascii, nonce_hex=nil)
-      redeem_script = Bitcoin::Script.new([redeem_script_hex].pack("H*"))
-      raise "only multisig redeem scripts are currently supported" unless redeem_script.is_multisig?
+    def self.generate(redeem_script_hex, payee_address_or_ascii, nonce_hex = nil)
+      redeem_script = Bitcoin::Script.new([redeem_script_hex].pack('H*'))
+      raise 'only multisig redeem scripts are currently supported' unless redeem_script.is_multisig?
       nonce_hex, data = compute_data(payee_address_or_ascii, nonce_hex)
 
       derived_keys = []
       redeem_script.get_multisig_pubkeys.each do |pubkey|
         tweak = hmac(pubkey, data).to_i(16)
-        raise "order exceeded, pick a new nonce" if tweak >= EC_GROUP.order.to_i
+        raise 'order exceeded, pick a new nonce' if tweak >= EC_GROUP.order.to_i
         tweak = OpenSSL::BN.new(tweak.to_s)
 
-        key = Bitcoin::Key.new(nil, pubkey.unpack("H*")[0])
+        key = Bitcoin::Key.new(nil, pubkey.unpack('H*')[0])
         key = key.instance_variable_get(:@key)
         point = EC_GROUP.generator.mul(tweak).ec_add(key.public_key).to_bn.to_i
-        raise "infinity" if point == 1/0.0
+        raise 'infinity' if point == 1 / 0.0
 
         key = Bitcoin::Key.new(nil, point.to_s(16))
-        key.instance_eval{ @pubkey_compressed = true }
+        key.instance_eval { @pubkey_compressed = true }
         derived_keys << key.pub
       end
 
       m = redeem_script.get_signatures_required
       p2sh_script, redeem_script = Bitcoin::Script.to_p2sh_multisig_script(m, *derived_keys)
 
-      [ nonce_hex, redeem_script.unpack("H*")[0], Bitcoin::Script.new(p2sh_script).get_p2sh_address ]
+      [nonce_hex, redeem_script.unpack('H*')[0], Bitcoin::Script.new(p2sh_script).get_p2sh_address]
     end
 
     # claim a contract
@@ -45,32 +41,32 @@ module Bitcoin
       key = Bitcoin::Key.from_base58(private_key_wif)
       data = compute_data(payee_address_or_ascii, nonce_hex)[1]
 
-      pubkey = [key.pub].pack("H*")
+      pubkey = [key.pub].pack('H*')
       tweak = hmac(pubkey, data).to_i(16)
-      raise "order exceeded, verify parameters" if tweak >= EC_GROUP.order.to_i
+      raise 'order exceeded, verify parameters' if tweak >= EC_GROUP.order.to_i
 
       derived_key = (tweak + key.priv.to_i(16)) % EC_GROUP.order.to_i
-      raise "zero" if derived_key == 0
+      raise 'zero' if derived_key.zero?
 
       Bitcoin::Key.new(derived_key.to_s(16))
     end
 
     # compute HMAC data
     def self.compute_data(address_or_ascii, nonce_hex)
-      nonce = nonce_hex ? [nonce_hex].pack("H32") : SecureRandom.random_bytes(16)
+      nonce = nonce_hex ? [nonce_hex].pack('H32') : SecureRandom.random_bytes(16)
       if Bitcoin.valid_address?(address_or_ascii)
         address_type = case Bitcoin.address_type(address_or_ascii)
-                       when :hash160;  'P2PH'
-                       when :p2sh;     'P2SH'
+                       when :hash160 then  'P2PH'
+                       when :p2sh then     'P2SH'
                        else
                          raise "unsupported address type #{address_type}"
                        end
-        contract_bytes = [ Bitcoin.hash160_from_address(address_or_ascii) ].pack("H*")
+        contract_bytes = [Bitcoin.hash160_from_address(address_or_ascii)].pack('H*')
       else
-        address_type = "TEXT"
+        address_type = 'TEXT'
         contract_bytes = address_or_ascii
       end
-      [ nonce.unpack("H*")[0], address_type + nonce + contract_bytes ]
+      [nonce.unpack('H*')[0], address_type + nonce + contract_bytes]
     end
   end
 end

data/lib/bitcoin/dogecoin.rb

@@ -1,97 +1,99 @@
 # encoding: ascii-8bit
 
-# This module includes (almost) everything necessary to add dogecoin support
-# to bitcoin-ruby. When switching to a :dogecoin network, it will load its
-# functionality into the Script class.
-# The only things not included here should be parsing the AuxPow, which is
-# done in Protocol::Block directly, and passing the txout to #store_doge from
-# the storage backend.
-module Bitcoin::Dogecoin
-
-  def self.load
-    Bitcoin::Util.class_eval { include Util }
-  end
-
-  # fixed reward past the 600k block
-  POST_600K_REWARD = 10000 * Bitcoin::COIN
-
-  # Dogecoin-specific Script methods for parsing and creating of dogecoin scripts,
-  # as well as methods to extract address, doge_hash, doge and value.
-  module Util
-
-    def self.included(base)
-      base.constants.each {|c| const_set(c, base.const_get(c)) unless constants.include?(c) }
-      base.class_eval do
+module Bitcoin
+  # This module includes (almost) everything necessary to add dogecoin support
+  # to bitcoin-ruby. When switching to a :dogecoin network, it will load its
+  # functionality into the Script class.
+  # The only things not included here should be parsing the AuxPow, which is
+  # done in Protocol::Block directly, and passing the txout to #store_doge from
+  # the storage backend.
+  module Dogecoin
+    def self.load
+      Bitcoin::Util.class_eval { include Util }
+    end
 
-        def block_creation_reward(block_height)
-          if block_height < Bitcoin.network[:difficulty_change_block]
-            # Dogecoin early rewards were random, using part of the hash of the
-            # previous block as the seed for the Mersenne Twister algorithm.
-            # Given we don't have previous block hash available, and this value is
-            # functionally a maximum (not exact value), I'm using the maximum the random
-            # reward generator can produce and calling it good enough.
-            Bitcoin.network[:reward_base] / (2 ** (block_height / Bitcoin.network[:reward_halving].to_f).floor) * 2
-          elsif block_height < 600000
-            Bitcoin.network[:reward_base] / (2 ** (block_height / Bitcoin.network[:reward_halving].to_f).floor)
-          else
-            POST_600K_REWARD
+    # fixed reward past the 600k block
+    POST_600K_REWARD = 10_000 * Bitcoin::COIN
+
+    # Dogecoin-specific Script methods for parsing and creating of dogecoin scripts,
+    # as well as methods to extract address, doge_hash, doge and value.
+    module Util
+      # rubocop:disable CyclomaticComplexity,PerceivedComplexity
+      def self.included(base)
+        base.constants.each { |c| const_set(c, base.const_get(c)) unless constants.include?(c) }
+        base.class_eval do
+          def block_creation_reward(block_height)
+            reward_scaler = 2**(block_height / Bitcoin.network[:reward_halving].to_f).floor
+            if block_height < Bitcoin.network[:difficulty_change_block]
+              # Dogecoin early rewards were random, using part of the hash of the
+              # previous block as the seed for the Mersenne Twister algorithm.
+              # Given we don't have previous block hash available, and this value is
+              # functionally a maximum (not exact value), I'm using the maximum the random
+              # reward generator can produce and calling it good enough.
+              Bitcoin.network[:reward_base] / reward_scaler * 2
+            elsif block_height < 600_000
+              Bitcoin.network[:reward_base] / reward_scaler
+            else
+              POST_600K_REWARD
+            end
           end
-        end
-        
-        def block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
-          new_difficulty_protocol = (prev_height + 1) >= Bitcoin.network[:difficulty_change_block]
 
-          # target interval for block interval in seconds
-          retarget_time = Bitcoin.network[:retarget_time]
+          def block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
+            new_difficulty_protocol = (prev_height + 1) >= Bitcoin.network[:difficulty_change_block]
 
-          if new_difficulty_protocol
-            # what is the ideal interval between the blocks
-            retarget_time = Bitcoin.network[:retarget_time_new]
-          end
+            # target interval for block interval in seconds
+            retarget_time = Bitcoin.network[:retarget_time]
 
-          # actual time elapsed since last retarget
-          actual_time = prev_block_time - last_retarget_time
+            if new_difficulty_protocol
+              # what is the ideal interval between the blocks
+              retarget_time = Bitcoin.network[:retarget_time_new]
+            end
 
-          if new_difficulty_protocol
-            # DigiShield implementation - thanks to RealSolid & WDC for this code
-            # We round always towards zero to match the C++ version
-            if actual_time < retarget_time
-              actual_time = retarget_time + ((actual_time - retarget_time) / 8.0).ceil
+            # actual time elapsed since last retarget
+            actual_time = prev_block_time - last_retarget_time
+
+            if new_difficulty_protocol
+              # DigiShield implementation - thanks to RealSolid & WDC for this code
+              # We round always towards zero to match the C++ version
+              actual_time = if actual_time < retarget_time
+                              retarget_time + ((actual_time - retarget_time) / 8.0).ceil
+                            else
+                              retarget_time + ((actual_time - retarget_time) / 8.0).floor
+                            end
+              # amplitude filter - thanks to daft27 for this code
+              min = retarget_time - (retarget_time / 4)
+              max = retarget_time + (retarget_time / 2)
+            elsif prev_height + 1 > 10_000
+              min = retarget_time / 4
+              max = retarget_time * 4
+            elsif prev_height + 1 > 5000
+              min = retarget_time / 8
+              max = retarget_time * 4
             else
-              actual_time = retarget_time + ((actual_time - retarget_time) / 8.0).floor
+              min = retarget_time / 16
+              max = retarget_time * 4
             end
-            # amplitude filter - thanks to daft27 for this code
-            min = retarget_time - (retarget_time/4)
-            max = retarget_time + (retarget_time/2)
-          elsif prev_height+1 > 10000
-            min = retarget_time / 4
-            max = retarget_time * 4
-          elsif prev_height+1 > 5000
-            min = retarget_time / 8
-            max = retarget_time * 4
-          else
-            min = retarget_time / 16
-            max = retarget_time * 4
-          end
 
-          actual_time = min if actual_time < min
-          actual_time = max if actual_time > max
+            actual_time = min if actual_time < min
+            actual_time = max if actual_time > max
 
-          # It could be a bit confusing: we are adjusting difficulty of the previous block, while logically
-          # we should use difficulty of the previous 2016th block ("first")
+            # It could be a bit confusing: we are adjusting difficulty of the previous block,
+            # while logically we should use difficulty of the previous 2016th block ("first")
 
-          prev_target = decode_compact_bits(prev_block_bits).to_i(16)
+            prev_target = decode_compact_bits(prev_block_bits).to_i(16)
 
-          new_target = prev_target * actual_time / retarget_time
-          if new_target < Bitcoin.decode_compact_bits(Bitcoin.network[:proof_of_work_limit]).to_i(16)
-            encode_compact_bits(new_target.to_s(16))
-          else
-            Bitcoin.network[:proof_of_work_limit]
+            new_target = prev_target * actual_time / retarget_time
+            if new_target < Bitcoin.decode_compact_bits(
+              Bitcoin.network[:proof_of_work_limit]
+            ).to_i(16)
+              encode_compact_bits(new_target.to_s(16))
+            else
+              Bitcoin.network[:proof_of_work_limit]
+            end
           end
         end
       end
+      # rubocop:enable CyclomaticComplexity,PerceivedComplexity
     end
-
   end
-
 end

data/lib/bitcoin/electrum/mnemonic.rb

@@ -1,10 +1,9 @@
 # encoding: ascii-8bit
 
+# ruby version of: https://github.com/spesmilo/electrum/blob/master/lib/mnemonic.py
 class Mnemonic
-  # ruby version of: https://github.com/spesmilo/electrum/blob/master/lib/mnemonic.py
-
   # list of words from http://en.wiktionary.org/wiki/Wiktionary:Frequency_lists/Contemporary_poetry
-  Words = (<<-TEXT).split
+  WORDS = <<-TEXT.split
     like just love know never want time out there make look eye down only think
     heart back then into about more away still them take thing even through long always
     world too friend tell try hand thought over here other need smile again much cry
@@ -116,47 +115,51 @@ class Mnemonic
     thigh throne total unseen weapon weary
   TEXT
 
-  def self.encode(hex, words=Words)
+  def self.encode(hex, words = WORDS)
     n = words.size
-    [hex].pack("H*").unpack("N*").map{|x|
+    [hex].pack('H*').unpack('N*').map do |x|
       w1 = x % n
       w2 = ((x / n) + w1) % n
       w3 = ((x / n / n) + w2) % n
-      [ words[w1], words[w2], words[w3] ]
-    }.flatten
+      [words[w1], words[w2], words[w3]]
+    end.flatten
   end
 
-  def self.decode(word_list, words=Words)
+  def self.decode(word_list, words = WORDS)
     n = words.size
-    word_list.each_slice(3).map{|three_words|
-      w1, w2, w3 = three_words.map{|word| words.index(word) % n }
-      '%08x' % ( w1 + n*((w2-w1)%n) + n*n*((w3-w2)%n) )
-    }.join
+    word_list.each_slice(3).map do |three_words|
+      w1, w2, w3 = three_words.map { |word| words.index(word) % n }
+      format('%08x', (w1 + n * ((w2 - w1) % n) + n * n * ((w3 - w2) % n)))
+    end.join
   end
-
 end
 
+if $PROGRAM_NAME == __FILE__
+  hex = '4c7d10656aa55383a5d88e3f63300af5e169918f4058bf349d99b20239909b61'
+  expected_words = %w[horse love nose speak diamond gaze wash drag glance
+                      money cease soft complete huge aside confusion touch
+                      grass pie play bread exactly bubble great]
 
-
-if $0 == __FILE__
-  hex = "4c7d10656aa55383a5d88e3f63300af5e169918f4058bf349d99b20239909b61"
-  expected_words = ['horse', 'love', 'nose', 'speak', 'diamond', 'gaze', 'wash', 'drag', 'glance',
-                    'money', 'cease', 'soft', 'complete', 'huge', 'aside', 'confusion', 'touch',
-                    'grass', 'pie', 'play', 'bread', 'exactly', 'bubble', 'great']
+  p Mnemonic.encode(hex) == expected_words
+  p Mnemonic.decode(expected_words) == hex
 
   # from http://brainwallet.org/#chains
-  hex = "ff64b72c431f75799f0c5ebe438e46dd"
+  hex = 'ff64b72c431f75799f0c5ebe438e46dd'
   expected_words = %w[muscle lot sea got revenge crack wait yeah gas study embrace spend]
-  hex = "18cfaf96961750c7a4e4e39c861d1415"
+  p Mnemonic.encode(hex) == expected_words
+  p Mnemonic.decode(expected_words) == hex
+
+  hex = '18cfaf96961750c7a4e4e39c861d1415'
   expected_words = %w[example poor twice expect decision master blame rub forward easy jump carve]
+  p Mnemonic.encode(hex) == expected_words
+  p Mnemonic.decode(expected_words) == hex
 
   # from  https://en.bitcoin.it/wiki/Electrum#Brain_Wallet
-  hex = "431a62f1c86555d3c45e5c4d9e10c8c7"
+  hex = '431a62f1c86555d3c45e5c4d9e10c8c7'
   expected_words = %w[constant forest adore false green weave stop guy fur freeze giggle clock]
 
-  #p Mnemonic.encode(hex)
+  # p Mnemonic.encode(hex)
   p Mnemonic.encode(hex) == expected_words
-  #p Mnemonic.decode(expected_words)
+  # p Mnemonic.decode(expected_words)
   p Mnemonic.decode(expected_words) == hex
 end
-