bitcoin-ruby 0.0.18 → 0.0.19

data/lib/bitcoin/ffi/secp256k1.rb

@@ -1,19 +1,18 @@
 # encoding: ascii-8bit
 
-# bindings for secp256k1 inside bitcoin (https://github.com/bitcoin/bitcoin/tree/v0.13.1/src/secp256k1)
-# tag: v0.13.1
-# commit: 03422e564b552c1d3c16ae854f8471f7cb39e25d
-#  bitcoin@master% git checkout v0.13.1
-#  bitcoin@tags/v0.13.1^0% cd src/secp256k1
-#  bitcoin@tags/v0.13.1^0 src/secp256k1% ./autogen.sh
-#  bitcoin@tags/v0.13.1^0 src/secp256k1% ./configure --enable-module-recovery
-#  bitcoin@tags/v0.13.1^0 src/secp256k1% make libsecp256k1.la
-#  bitcoin@tags/v0.13.1^0 src/secp256k1% nm -D .libs/libsecp256k1.so.0.0.0 | grep secp
-#  export SECP256K1_LIB_PATH=/path/to/bitcoin/src/secp256k1/.libs/libsecp256k1.so.0.0.0
-
 require 'ffi'
 
 module Bitcoin
+  # bindings for secp256k1 inside bitcoin (https://github.com/bitcoin/bitcoin/tree/v0.13.1/src/secp256k1)
+  # tag: v0.13.1
+  # commit: 03422e564b552c1d3c16ae854f8471f7cb39e25d
+  #  bitcoin@master% git checkout v0.13.1
+  #  bitcoin@tags/v0.13.1^0% cd src/secp256k1
+  #  bitcoin@tags/v0.13.1^0 src/secp256k1% ./autogen.sh
+  #  bitcoin@tags/v0.13.1^0 src/secp256k1% ./configure --enable-module-recovery
+  #  bitcoin@tags/v0.13.1^0 src/secp256k1% make libsecp256k1.la
+  #  bitcoin@tags/v0.13.1^0 src/secp256k1% nm -D .libs/libsecp256k1.so.0.0.0 | grep secp
+  #  export SECP256K1_LIB_PATH=/path/to/bitcoin/src/secp256k1/.libs/libsecp256k1.so.0.0.0
   module Secp256k1
     extend FFI::Library
 
@@ -32,10 +31,10 @@ module Bitcoin
 
     # Flag to pass to secp256k1_ec_pubkey_serialize and secp256k1_ec_privkey_export.
     SECP256K1_EC_COMPRESSED = (SECP256K1_FLAGS_TYPE_COMPRESSION | SECP256K1_FLAGS_BIT_COMPRESSION)
-    SECP256K1_EC_UNCOMPRESSED = (SECP256K1_FLAGS_TYPE_COMPRESSION)
+    SECP256K1_EC_UNCOMPRESSED = SECP256K1_FLAGS_TYPE_COMPRESSION
 
     def self.ffi_load_functions(file)
-      class_eval <<-RUBY
+      class_eval <<-RUBY # rubocop:disable Style/EvalWithLocation
         ffi_lib [ %[#{file}] ]
 
         ##
@@ -91,28 +90,35 @@ module Bitcoin
         attach_function :secp256k1_ecdsa_signature_parse_der, [:pointer, :pointer, :pointer, :size_t], :int
 
         # TODO: add or port
-        # # int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) 
+        # # int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen)
         # attach_function :ecdsa_signature_parse_der_lax, [:pointer, :pointer, :pointer, :size_t], :int
       RUBY
     end
 
     def self.init
+      @loaded ||= false
       return if @loaded
-      lib_path = [ ENV['SECP256K1_LIB_PATH'], 'vendor/bitcoin/src/secp256k1/.libs/libsecp256k1.so' ].find{|f| File.exists?(f.to_s) }
+      lib_path = [
+        ENV['SECP256K1_LIB_PATH'], 'vendor/bitcoin/src/secp256k1/.libs/libsecp256k1.so'
+      ].find { |f| File.exist?(f.to_s) }
       ffi_load_functions(lib_path)
       @loaded = true
     end
 
-    def self.with_context(flags=nil, seed=nil)
+    def self.with_context(flags = nil, seed = nil)
       init
-      flags = flags || (SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN)
+      flags ||= (SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN)
       context = secp256k1_context_create(flags)
 
-      ret, tries, max = 0, 0, 20
+      ret = 0
+      tries = 0
+      max = 20
       while ret != 1
-        raise "secp256k1_context_randomize failed." if tries >= max
+        raise 'secp256k1_context_randomize failed.' if tries >= max
         tries += 1
-        ret = secp256k1_context_randomize(context, FFI::MemoryPointer.from_string(seed || SecureRandom.random_bytes(32)))
+        ret = secp256k1_context_randomize(
+          context, FFI::MemoryPointer.from_string(seed || SecureRandom.random_bytes(32))
+        )
       end
 
       yield(context) if block_given?
@@ -120,12 +126,13 @@ module Bitcoin
       secp256k1_context_destroy(context)
     end
 
-    def self.generate_key_pair(compressed=true)
+    def self.generate_key_pair(compressed = true)
       with_context do |context|
-
-        ret, tries, max = 0, 0, 20
+        ret = 0
+        tries = 0
+        max = 20
         while ret != 1
-          raise "secp256k1_ec_seckey_verify in generate_key_pair failed." if tries >= max
+          raise 'secp256k1_ec_seckey_verify in generate_key_pair failed.' if tries >= max
           tries += 1
 
           seckey = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, SecureRandom.random_bytes(32))
@@ -134,46 +141,56 @@ module Bitcoin
 
         internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
         result = secp256k1_ec_pubkey_create(context, internal_pubkey, seckey)
-        raise "error creating pubkey" unless result == 1
+        raise 'error creating pubkey' unless result == 1
 
-        pubkey, pubkey_len = FFI::MemoryPointer.new(:uchar, 65), FFI::MemoryPointer.new(:uint64)
+        pubkey = FFI::MemoryPointer.new(:uchar, 65)
+        pubkey_len = FFI::MemoryPointer.new(:uint64)
         result = if compressed
-          pubkey_len.put_uint64(0, 33)
-          secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_COMPRESSED)
-        else
-          pubkey_len.put_uint64(0, 65)
-          secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_UNCOMPRESSED)
-        end
-        raise "error serialize pubkey" unless (result == 1) || pubkey_len.read_uint64 > 0
-
-        [ seckey.read_string(32), pubkey.read_string(pubkey_len.read_uint64) ]
+                   pubkey_len.put_uint64(0, 33)
+                   secp256k1_ec_pubkey_serialize(
+                     context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_COMPRESSED
+                   )
+                 else
+                   pubkey_len.put_uint64(0, 65)
+                   secp256k1_ec_pubkey_serialize(
+                     context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_UNCOMPRESSED
+                   )
+                 end
+        raise 'error serialize pubkey' unless (result == 1) || pubkey_len.read_uint64 > 0
+
+        [seckey.read_string(32), pubkey.read_string(pubkey_len.read_uint64)]
       end
     end
 
-    def self.generate_key(compressed=true)
+    def self.generate_key(compressed = true)
       priv, pub = generate_key_pair(compressed)
-      Bitcoin::Key.new(priv.unpack("H*")[0], pub.unpack("H*")[0])
+      Bitcoin::Key.new(priv.unpack('H*')[0], pub.unpack('H*')[0])
     end
 
     def self.sign(data, priv_key)
       with_context do |context|
         seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
-        raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey) == 1
+        raise 'priv_key invalid' unless secp256k1_ec_seckey_verify(context, seckey) == 1
 
         internal_signature = FFI::MemoryPointer.new(:uchar, 64)
         msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
 
-        ret, tries, max = 0, 0, 20
+        ret = 0
+        tries = 0
+        max = 20
         while ret != 1
-          raise "secp256k1_ecdsa_sign failed." if tries >= max
+          raise 'secp256k1_ecdsa_sign failed.' if tries >= max
           tries += 1
 
           ret = secp256k1_ecdsa_sign(context, internal_signature, msg32, seckey, nil, nil)
         end
 
-        signature, signature_len = FFI::MemoryPointer.new(:uchar, 72), FFI::MemoryPointer.new(:uint64).put_uint64(0, 72)
-        result = secp256k1_ecdsa_signature_serialize_der(context, signature, signature_len, internal_signature)
-        raise "secp256k1_ecdsa_signature_serialize_der failed" unless result == 1
+        signature = FFI::MemoryPointer.new(:uchar, 72)
+        signature_len = FFI::MemoryPointer.new(:uint64).put_uint64(0, 72)
+        result = secp256k1_ecdsa_signature_serialize_der(
+          context, signature, signature_len, internal_signature
+        )
+        raise 'secp256k1_ecdsa_signature_serialize_der failed' unless result == 1
 
         signature.read_string(signature_len.read_uint64)
       end
@@ -181,7 +198,7 @@ module Bitcoin
 
     def self.verify(data, sig, pub_key)
       with_context do |context|
-        return false if data.bytesize == 0
+        return false if data.bytesize.zero?
 
         pubkey = FFI::MemoryPointer.new(:uchar, pub_key.bytesize).put_bytes(0, pub_key)
         internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
@@ -190,11 +207,16 @@ module Bitcoin
 
         signature = FFI::MemoryPointer.new(:uchar, sig.bytesize).put_bytes(0, sig)
         internal_signature = FFI::MemoryPointer.new(:uchar, 64)
-        result = secp256k1_ecdsa_signature_parse_der(context, internal_signature, signature, signature.size)
-        #result = ecdsa_signature_parse_der_lax(context, internal_signature, signature, signature.size)
+        result = secp256k1_ecdsa_signature_parse_der(
+          context, internal_signature, signature, signature.size
+        )
+        # result = ecdsa_signature_parse_der_lax(
+        # context, internal_signature, signature, signature.size
+        # )
         return false unless result == 1
 
-        # libsecp256k1's ECDSA verification requires lower-S signatures, which have not historically been enforced in Bitcoin, so normalize them first.
+        # libsecp256k1's ECDSA verification requires lower-S signatures, which have not historically
+        # been enforced in Bitcoin, so normalize them first.
         secp256k1_ecdsa_signature_normalize(context, internal_signature, internal_signature)
 
         msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
@@ -204,30 +226,37 @@ module Bitcoin
       end
     end
 
-    def self.sign_compact(message, priv_key, compressed=true)
+    def self.sign_compact(message, priv_key, compressed = true)
       with_context do |context|
         seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
-        raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey) == 1
+        raise 'priv_key invalid' unless secp256k1_ec_seckey_verify(context, seckey) == 1
 
         msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, message)
         internal_recoverable_signature = FFI::MemoryPointer.new(:uchar, 65)
         rec_id = FFI::MemoryPointer.new(:int).put_int(0, -1)
 
-        ret, tries, max = 0, 0, 20
+        ret = 0
+        tries = 0
+        max = 20
         while ret != 1
-          raise "secp256k1_ecdsa_sign_recoverable failed." if tries >= max
+          raise 'secp256k1_ecdsa_sign_recoverable failed.' if tries >= max
           tries += 1
 
-          ret = secp256k1_ecdsa_sign_recoverable(context, internal_recoverable_signature, msg32, seckey, nil, nil)
+          ret = secp256k1_ecdsa_sign_recoverable(
+            context, internal_recoverable_signature, msg32, seckey, nil, nil
+          )
         end
 
         recoverable_signature = FFI::MemoryPointer.new(:uchar, 64)
-        result = secp256k1_ecdsa_recoverable_signature_serialize_compact(context, recoverable_signature, rec_id, internal_recoverable_signature)
-        raise "secp256k1_ecdsa_recoverable_signature_serialize_compact failed" unless result == 1
-        raise "secp256k1_ecdsa_recoverable_signature_serialize_compact failed" unless rec_id.read_int != -1
-
-        header = [27 + rec_id.read_int + (compressed ? 4 : 0)].pack("C")
-        [ header, recoverable_signature.read_string(64) ].join
+        result = secp256k1_ecdsa_recoverable_signature_serialize_compact(
+          context, recoverable_signature, rec_id, internal_recoverable_signature
+        )
+        error_str = 'secp256k1_ecdsa_recoverable_signature_serialize_compact failed'
+        raise error_str unless result == 1
+        raise error_str unless rec_id.read_int != -1
+
+        header = [27 + rec_id.read_int + (compressed ? 4 : 0)].pack('C')
+        [header, recoverable_signature.read_string(64)].join
       end
     end
 
@@ -238,7 +267,7 @@ module Bitcoin
         version = signature.unpack('C')[0]
         return nil if version < 27 || version > 34
 
-        compressed = version >= 31 ? true : false
+        compressed = version >= 31
         flag = compressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED
         version -= 4 if compressed
 
@@ -247,20 +276,24 @@ module Bitcoin
         recoverable_signature = FFI::MemoryPointer.new(:uchar, 64).put_bytes(0, signature[1..-1])
 
         internal_recoverable_signature = FFI::MemoryPointer.new(:uchar, 65)
-        result = secp256k1_ecdsa_recoverable_signature_parse_compact(context, internal_recoverable_signature, recoverable_signature, recid)
+        result = secp256k1_ecdsa_recoverable_signature_parse_compact(
+          context, internal_recoverable_signature, recoverable_signature, recid
+        )
         return nil unless result == 1
 
         internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
-        result = secp256k1_ecdsa_recover(context, internal_pubkey, internal_recoverable_signature, msg32)
+        result = secp256k1_ecdsa_recover(
+          context, internal_pubkey, internal_recoverable_signature, msg32
+        )
         return nil unless result == 1
 
-        pubkey, pubkey_len = FFI::MemoryPointer.new(:uchar, 65), FFI::MemoryPointer.new(:uint64).put_uint64(0, 65)
+        pubkey = FFI::MemoryPointer.new(:uchar, 65)
+        pubkey_len = FFI::MemoryPointer.new(:uint64).put_uint64(0, 65)
         result = secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, flag)
-        raise "error serialize pubkey" unless (result == 1) || pubkey_len.read_uint64 > 0
+        raise 'error serialize pubkey' unless (result == 1) || pubkey_len.read_uint64 > 0
 
         pubkey.read_string(pubkey_len.read_uint64)
       end
     end
-
   end
 end

data/lib/bitcoin/protocol.rb

@@ -19,7 +19,6 @@ module Bitcoin
     autoload :Tx,            'bitcoin/protocol/tx'
     autoload :Block,         'bitcoin/protocol/block'
     autoload :Addr,          'bitcoin/protocol/address'
-    autoload :Alert,         'bitcoin/protocol/alert'
     autoload :Reject,        'bitcoin/protocol/reject'
     autoload :Version,       'bitcoin/protocol/version'
     autoload :AuxPow,        'bitcoin/protocol/aux_pow'
@@ -62,7 +61,7 @@ module Bitcoin
 
     def self.unpack_var_string(payload)
       size, payload = unpack_var_int(payload)
-      size > 0 ? (string, payload = payload.unpack("a#{size}a*")) : [nil, payload]
+      size > 0 ? (_, payload = payload.unpack("a#{size}a*")) : [nil, payload]
     end
 
     def self.unpack_var_string_from_io(buf)
@@ -114,7 +113,11 @@ module Bitcoin
       length   = [payload.bytesize].pack("V")
       checksum = Digest::SHA256.digest(Digest::SHA256.digest(payload))[0...4]
       pkt      = "".force_encoding(BINARY)
-      pkt << Bitcoin.network[:magic_head].force_encoding(BINARY) << cmd.force_encoding(BINARY) << length << checksum << payload.force_encoding(BINARY)
+      pkt << Bitcoin.network[:magic_head].force_encoding(BINARY)
+      pkt << cmd.force_encoding(BINARY)
+      pkt << length
+      pkt << checksum
+      pkt << payload.dup.force_encoding(BINARY)
     end
 
     def self.version_pkt(from_id, from=nil, to=nil, last_block=nil, time=nil, user_agent=nil, version=nil)

data/lib/bitcoin/protocol/address.rb

@@ -2,9 +2,7 @@
 
 module Bitcoin
   module Protocol
-
-    class Addr < Struct.new(:time, :service, :ip, :port)
-
+    Addr = Struct.new(:time, :service, :ip, :port) do
       # # IP Address / Port
       # attr_reader :ip, :port
 
@@ -17,22 +15,25 @@ module Bitcoin
       # create addr from raw binary +data+
       def initialize(data = nil)
         if data
-          self[:time], self[:service], self[:ip], self[:port] = data.unpack("VQx12a4n")
-          self[:ip] = ip.unpack("C*").join(".")
+          unpacked = data.unpack('VQx12a4n')
+          self[:time], self[:service], self[:ip], self[:port] = unpacked
+          self[:ip] = ip.unpack('C*').join('.')
         else
-          self[:time], self[:service] = Time.now.to_i, 1
-          self[:ip], self[:port] = "127.0.0.1", Bitcoin.network[:default_port]
+          self[:time] = Time.now.to_i
+          self[:service] = 1
+          self[:ip] = '127.0.0.1'
+          self[:port] = Bitcoin.network[:default_port]
         end
       end
 
       # is this address alive?
       def alive?
-        (Time.now.tv_sec-7200) <= self[:time]
+        (Time.now.tv_sec - 7200) <= self[:time]
       end
 
       def to_payload
-        ip = self[:ip].split(".").map(&:to_i)
-        [ time, service, ("\x00"*10)+"\xff\xff", *ip, port ].pack("VQa12C4n")
+        ip = self[:ip].split('.').map(&:to_i)
+        [time, service, ("\x00" * 10) + "\xff\xff", *ip, port].pack('VQa12C4n')
       end
 
       def string
@@ -40,11 +41,12 @@ module Bitcoin
       end
 
       def self.pkt(*addrs)
-        addrs = addrs.select{|i| i.is_a?(Bitcoin::Protocol::Addr) && i.ip =~ /^\d+\.\d+\.\d+\.\d+$/ }
+        addrs = addrs.select do |i|
+          i.is_a?(Bitcoin::Protocol::Addr) && i.ip =~ /^\d+\.\d+\.\d+\.\d+$/
+        end
         length = Bitcoin::Protocol.pack_var_int(addrs.size)
-        Bitcoin::Protocol.pkt("addr", length + addrs.map(&:to_payload).join)
+        Bitcoin::Protocol.pkt('addr', length + addrs.map(&:to_payload).join)
       end
     end
-
   end
 end

data/lib/bitcoin/protocol/aux_pow.rb

@@ -2,7 +2,6 @@
 
 module Bitcoin
   module Protocol
-
     # Auxiliary Proof-of-Work for merge-mined blockchains
     # See https://en.bitcoin.it/wiki/Merged_mining_specification.
     #
@@ -20,7 +19,6 @@ module Bitcoin
     #
     # TODO: decode merged-mining data from +coinbase_tx+
     class AuxPow
-
       # Coinbase transaction of the parent block, linking to the child block
       attr_accessor :coinbase_tx
 
@@ -43,7 +41,7 @@ module Bitcoin
       attr_accessor :parent_block
 
       def initialize(data)
-        parse_data (data) if data
+        parse_data data if data
       end
 
       def parse_data(data)
@@ -58,42 +56,43 @@ module Bitcoin
 
         @block_hash = data.read(32)
         coinbase_branch_count = P.unpack_var_int_from_io(data)
+
         @coinbase_branch = []
-        coinbase_branch_count.times{
+        coinbase_branch_count.times do
           break if data.eof?
           @coinbase_branch << data.read(32).reverse.hth
-        }
-        @coinbase_index = data.read(4).unpack("I")[0]
+        end
+
+        @coinbase_index = data.read(4).unpack('I')[0]
 
         @chain_branch = []
         chain_branch_count = P.unpack_var_int_from_io(data)
-        chain_branch_count.times{
+        chain_branch_count.times do
           break if data.eof?
           @chain_branch << data.read(32).reverse.hth
-        }
+        end
 
-        @chain_index = data.read(4).unpack("I")[0]
+        @chain_index = data.read(4).unpack('I')[0]
         block = data.read(80)
         @parent_block = P::Block.new(block)
 
         data
       end
 
-
       def to_payload
         payload = @coinbase_tx.to_payload
         payload << @block_hash
         payload << P.pack_var_int(@coinbase_branch.count)
         payload << @coinbase_branch.map(&:htb).map(&:reverse).join
-        payload << [@coinbase_index].pack("I")
+        payload << [@coinbase_index].pack('I')
         payload << P.pack_var_int(@chain_branch.count)
         payload << @chain_branch.map(&:htb).map(&:reverse).join
-        payload << [@chain_index].pack("I")
+        payload << [@chain_index].pack('I')
         payload << @parent_block.to_payload
         payload
       end
 
-      def self.from_hash h
+      def self.from_hash(h)
         aux_pow = new(nil)
         aux_pow.instance_eval do
           @coinbase_tx = P::Tx.from_hash(h['coinbase_tx'])
@@ -116,8 +115,6 @@ module Bitcoin
           'chain_index' => @chain_index,
           'parent_block' => @parent_block.to_hash }
       end
-
     end
-
   end
 end