bitcoinrb 0.4.0 → 0.5.0

data/lib/bitcoin/message/cfilter.rb

@@ -0,0 +1,35 @@
+module Bitcoin
+  module Message
+
+    # cfilter message for BIP-157
+    # https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki#cfilter
+    class CFilter < Base
+
+      COMMAND = 'cfilter'
+
+      attr_accessor :filter_type
+      attr_accessor :block_hash   # little endian
+      attr_accessor :filter       # little endian
+
+      def initialize(filter_type, block_hash, filter)
+        @filter_type = filter_type
+        @block_hash = block_hash
+        @filter = filter
+      end
+
+      def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        type = buf.read(1).unpack("C").first
+        hash = buf.read(32).bth
+        len = Bitcoin.unpack_var_int_from_io(buf)
+        filter = buf.read(len).bth
+        self.new(type, hash, filter)
+      end
+
+      def to_payload
+        [filter_type, block_hash].pack('CH*') + Bitcoin.pack_var_string(filter.htb)
+      end
+    end
+
+  end
+end

data/lib/bitcoin/message/get_cfcheckpt.rb

@@ -0,0 +1,29 @@
+module Bitcoin
+  module Message
+
+    # getcfcheckpt message for BIP-157
+    # https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki#getcfcheckpt
+    class GetCFCheckpt < Base
+
+      COMMAND = 'getcfcheckpt'
+
+      attr_accessor :filter_type
+      attr_accessor :stop_hash    # little endian
+
+      def initialize(filter_type, stop_hash)
+        @filter_type = filter_type
+        @stop_hash = stop_hash
+      end
+
+      def self.parse_from_payload(payload)
+        type, hash = payload.unpack('CH*')
+        self.new(type, hash)
+      end
+
+      def to_payload
+        [filter_type, stop_hash].pack('CH*')
+      end
+
+    end
+  end
+end

data/lib/bitcoin/message/get_cfheaders.rb

@@ -0,0 +1,24 @@
+module Bitcoin
+  module Message
+
+    # getcfheaders message for BIP-157
+    # https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki#getcfheaders
+    class GetCFHeaders < Base
+      include CFParser
+      extend CFParser
+
+      COMMAND = 'getcfheaders'
+
+      attr_accessor :filter_type
+      attr_accessor :start_height
+      attr_accessor :stop_hash    # little endian
+
+      def initialize(filter_type, start_height, stop_hash)
+        @filter_type = filter_type
+        @start_height = start_height
+        @stop_hash = stop_hash
+      end
+
+    end
+  end
+end

data/lib/bitcoin/message/get_cfilters.rb

@@ -0,0 +1,25 @@
+module Bitcoin
+  module Message
+
+    # getcfilters message for BIP-157
+    # https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki#getcfilters
+    class GetCFilters < Base
+      include CFParser
+      extend CFParser
+
+      COMMAND = 'getcfilters'
+
+      attr_accessor :filter_type
+      attr_accessor :start_height
+      attr_accessor :stop_hash    # little endian
+
+      def initialize(filter_type, start_height, stop_hash)
+        @filter_type = filter_type
+        @start_height = start_height
+        @stop_hash = stop_hash
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/version.rb

@@ -64,6 +64,13 @@ module Bitcoin
         ( version >= 70001 && payload ) ? unpack_boolean(payload) : [ true, nil ]
       end
 
+      # Check whether +service_flag+ support this version.
+      # @param [Integer] service_flag the service flags.
+      # @return [Boolean] whether support +service_flag+
+      def support?(service_flag)
+        (services & service_flag) != 0
+      end
+
     end
   end
 end

data/lib/bitcoin/mnemonic.rb

@@ -6,11 +6,11 @@ module Bitcoin
 
     WORD_DIR = "#{__dir__}/mnemonic/wordlist"
 
-    attr_reader :word_list
+    attr_reader :language
 
-    def initialize(word_list)
-      raise ArgumentError, 'specified language is not supported.' unless Mnemonic.word_lists.include?(word_list)
-      @word_list = word_list
+    def initialize(language)
+      raise ArgumentError, 'specified language is not supported.' unless Mnemonic.word_lists.include?(language)
+      @language = language
     end
 
     # get support language list
@@ -69,7 +69,7 @@ module Bitcoin
 
     # load word list contents
     def load_words
-      File.readlines("#{WORD_DIR}/#{word_list}.txt").map(&:strip)
+      File.readlines("#{WORD_DIR}/#{language}.txt").map(&:strip)
     end
 
   end

data/lib/bitcoin/network/peer.rb

@@ -83,10 +83,15 @@ module Bitcoin
 
       def post_handshake
         @connected = true
-        pool.handle_new_peer(self)
-        # require remote peer to use headers message instead fo inv message.
-        conn.send_message(Bitcoin::Message::SendHeaders.new)
-        EM.add_periodic_timer(PING_INTERVAL) {send_ping}
+        if remote_version.support?(Bitcoin::Message::SERVICE_FLAGS[:bloom])
+          pool.handle_new_peer(self)
+          # require remote peer to use headers message instead fo inv message.
+          conn.send_message(Bitcoin::Message::SendHeaders.new)
+          EM.add_periodic_timer(PING_INTERVAL) {send_ping}
+        else
+          close("peer does not support NODE_BLOOM.")
+          pool.pending_peers.delete(self)
+        end
       end
 
       # start block header download

data/lib/bitcoin/network/peer_discovery.rb

@@ -30,7 +30,9 @@ module Bitcoin
         logger.debug 'discover peer address from DNS seeds.'
         dns_seeds.map { |seed|
           begin
-            Socket.getaddrinfo(seed, Bitcoin.chain_params.default_port).map{|a|a[2]}.uniq
+            # x5 is a prefix for finding nodes that support NODE_BLOOM.
+            # https://github.com/bitcoin/bitcoin/pull/8083#issuecomment-221552835
+            Socket.getaddrinfo("x5.#{seed}", Bitcoin.chain_params.default_port).map{|a|a[2]}.uniq
           rescue SocketError => e
             logger.error "SocketError occurred when load DNS seed: #{seed}, error: #{e.message}"
             nil

data/lib/bitcoin/node/cli.rb

@@ -1,4 +1,4 @@
-require 'rest-client'
+require 'net/http'
 require 'thor'
 require 'json'
 
@@ -92,15 +92,19 @@ module Bitcoin
             :id => 'jsonrpc'
         }
         begin
-          RestClient::Request.execute(method: :post, url: config.server_url, payload: data.to_json,
-                                      headers: {content_type: :json}) do |response, request, result|
-            return false if !result.kind_of?(Net::HTTPSuccess) && response.empty?
-            begin
-              json = JSON.parse(response.to_str)
-              puts JSON.pretty_generate(json)
-            rescue Exception
-              puts response.to_str
-            end
+          uri = URI.parse(config.server_url)
+          http = Net::HTTP.new(uri.hostname, uri.port)
+          http.use_ssl = uri.scheme === "https"
+          request = Net::HTTP::Post.new('/')
+          request.content_type = 'application/json'
+          request.body = data.to_json
+          response = http.request(request)
+          body = response.body
+          begin
+          json = JSON.parse(body.to_str)
+          puts JSON.pretty_generate(json)
+          rescue Exception
+            puts body.to_str
           end
         rescue Exception => e
           puts e.message

data/lib/bitcoin/node/spv.rb

@@ -45,7 +45,7 @@ module Bitcoin
       # broadcast a transaction
       def broadcast(tx)
         pool.broadcast(tx)
-        logger.debug "broadcast tx: #{tx.to_payload.bth}"
+        logger.debug "broadcast tx: #{tx.to_hex}"
       end
 
       # add filter element to bloom filter.

data/lib/bitcoin/out_point.rb

@@ -3,6 +3,8 @@ module Bitcoin
   # outpoint class
   class OutPoint
 
+    include Bitcoin::HexConverter
+
     COINBASE_HASH = '0000000000000000000000000000000000000000000000000000000000000000'
     COINBASE_INDEX = 4294967295
 

data/lib/bitcoin/payment_code.rb

@@ -0,0 +1,92 @@
+module Bitcoin
+
+  # BIP47 payment code
+  class PaymentCode < ExtKey
+
+    include Bitcoin::HexConverter
+
+    attr_accessor :x_value
+    attr_accessor :sign
+
+    VERSION_BYTE = '47'
+    SUPPORT_VERSIONS = ['01']
+    SUPPORT_SIGNS = ['02', '03']
+
+    def initialize
+      @version = '01'
+      @features_bits = '00'
+      @reserve_field = '0' * 26
+    end
+
+    # generate master key from seed.
+    # @params [String] seed a seed data with hex format.
+    def self.generate_master(seed)
+      master_ext_key = super.derive(47, harden=true).derive(0, harden=true).derive(0, harden=true)
+      compressed_pubkey = master_ext_key.pub
+
+      payment_code = PaymentCode.new
+      payment_code.depth = master_ext_key.depth
+      payment_code.key = master_ext_key.key
+      payment_code.sign = compressed_pubkey[0..1]
+      payment_code.x_value = compressed_pubkey[2..-1]
+      payment_code.chain_code = master_ext_key.chain_code
+      payment_code
+    end
+
+    # Base58 encoded payment code
+    def to_base58
+      payment_code_with_version_byte = VERSION_BYTE + to_hex
+      Bitcoin::Base58.encode(payment_code_with_version_byte + Bitcoin.calc_checksum(payment_code_with_version_byte))
+    end
+
+    # serialize payment code
+    def to_payload
+      @version.htb << @features_bits.htb << @sign.htb << @x_value.htb << @chain_code << @reserve_field.htb
+    end
+
+    # get notification address
+    def notification_address
+      ext_pubkey.derive(0).addr
+    end
+
+    # decode base58 encoded payment code
+    # @params [String] base58_payment_code base58 encoded payment code
+    def self.from_base58(base58_payment_code)
+      hex = Bitcoin::Base58.decode(base58_payment_code)
+      version = hex[2..3]
+      sign = hex[6..7]
+      public_key = hex[8..71]
+      payment_code = hex[0...-8]
+
+      raise ArgumentError, 'invalid version byte' unless hex[0..1] == VERSION_BYTE
+      raise ArgumentError, 'invalid version' unless PaymentCode.support_version?(version)
+      raise ArgumentError, 'invalid sign' unless PaymentCode.support_sign?(sign)
+      raise ArgumentError, 'invalid public key' unless Bitcoin::Key.new(priv_key: nil, pubkey: sign + public_key).fully_valid_pubkey?
+      raise ArgumentError, 'invalid checksum' unless Bitcoin.calc_checksum(payment_code) == hex[-8..-1]
+
+      x_value = payment_code[8..71]
+      chain_code_hex = payment_code[72..135]
+
+      payment_code_pubkey = PaymentCode.new
+      payment_code_pubkey.depth = 3
+      payment_code_pubkey.sign = sign
+      payment_code_pubkey.x_value = x_value
+      payment_code_pubkey.chain_code = [chain_code_hex].pack('H*')
+
+      payment_code_pubkey.to_payload
+    end
+
+    # check whether +version+ is supported version bytes.
+    def self.support_version?(version)
+      SUPPORT_VERSIONS.include?(version)
+    end
+
+    # check whether +sign+ is supported version bytes.
+    def self.support_sign?(sign)
+      SUPPORT_SIGNS.include?(sign)
+    end
+
+  end
+
+end
+  

data/lib/bitcoin/psbt/input.rb

@@ -93,7 +93,8 @@ module Bitcoin
 
       def to_payload
         payload = ''
-        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:non_witness_utxo], value: non_witness_utxo.to_payload) if non_witness_utxo
+        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:non_witness_utxo], value:
+            (witness_utxo && valid_witness_input?) ? non_witness_utxo.serialize_old_format : non_witness_utxo.to_payload) if non_witness_utxo
         payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:witness_utxo], value: witness_utxo.to_payload) if witness_utxo
         if final_script_sig.nil? && final_script_witness.nil?
           payload << partial_sigs.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:partial_sig], key: k.htb, value: v)}.join
@@ -109,15 +110,6 @@ module Bitcoin
         payload
       end
 
-      # Sanity check
-      # @return [Boolean]
-      def sane?
-        return false if non_witness_utxo && witness_utxo
-        return false if witness_script && witness_utxo.nil?
-        return false if final_script_witness && witness_utxo.nil?
-        true
-      end
-
       # Check whether input's scriptPubkey is correct witness.
       # @return [Boolean]
       def valid_witness_input?
@@ -141,7 +133,6 @@ module Bitcoin
       # @param [Bitcoin::TxOut] utxo utxo object which input refers.
       # @return [Boolean]
       def ready_to_sign?(utxo)
-        return false unless sane?
         return valid_witness_input? if witness_utxo
         valid_non_witness_input?(utxo) # non_witness_utxo
       end
@@ -177,8 +168,8 @@ module Bitcoin
         combined.witness_script = witness_script
         combined.sighash_type = sighash_type
         sigs = Hash[partial_sigs.merge(psbi.partial_sigs)]
-        redeem_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if redeem_script && redeem_script.multisig?
-        witness_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if witness_script && witness_script.multisig?
+        redeem_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if redeem_script&.multisig?
+        witness_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if witness_script&.multisig?
         combined.hd_key_paths = hd_key_paths.merge(psbi.hd_key_paths)
         combined
       end
@@ -190,7 +181,7 @@ module Bitcoin
         if non_witness_utxo
           self.final_script_sig = Bitcoin::Script.new << Bitcoin::Opcodes::OP_0 if redeem_script.multisig?
           partial_sigs.values.each {|sig|final_script_sig << sig}
-          final_script_sig << redeem_script.to_payload.bth
+          final_script_sig << redeem_script.to_hex
           self.partial_sigs = {}
           self.hd_key_paths = {}
           self.redeem_script = nil

data/lib/bitcoin/psbt/tx.rb

@@ -2,6 +2,7 @@ module Bitcoin
   module PSBT
 
     class GlobalXpub
+      include Bitcoin::HexConverter
 
       attr_reader :xpub # Bitcoin::ExtPubkey
       attr_reader :info # Bitcoin::PSBT::KeyOriginInfo
@@ -16,7 +17,7 @@ module Bitcoin
       end
 
       def to_h
-        {xpub: xpub.to_payload.bth}.merge(info.to_h)
+        {xpub: xpub.to_hex}.merge(info.to_h)
       end
 
       def to_s
@@ -25,6 +26,8 @@ module Bitcoin
     end
 
     class Tx
+      include Bitcoin::HexConverter
+
       attr_accessor :tx
       attr_accessor :xpubs
       attr_reader :inputs
@@ -117,10 +120,6 @@ module Bitcoin
 
         raise ArgumentError, 'Outputs provided does not match the number of outputs in transaction.' unless partial_tx.outputs.size == partial_tx.tx.out.size
 
-        partial_tx.inputs.each do |input|
-          raise ArgumentError, 'PSBT is not sane.' unless input.sane?
-        end
-
         partial_tx
       end
 
@@ -149,11 +148,9 @@ module Bitcoin
         payload << PSBT.serialize_to_vector(PSBT_GLOBAL_TYPES[:unsigned_tx], value: tx.to_payload)
         payload << xpubs.map(&:to_payload).join
         payload << PSBT.serialize_to_vector(PSBT_GLOBAL_TYPES[:ver], value: [version_number].pack('V')) if version_number
-
         payload << unknowns.map {|k,v|Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v}.join
 
         payload << PSBT_SEPARATOR.itb
-
         payload << inputs.map(&:to_payload).join
         payload << outputs.map(&:to_payload).join
         payload
@@ -177,14 +174,12 @@ module Bitcoin
             utxo = prev_tx.out[tx_in.out_point.index]
             raise ArgumentError, 'redeem script does not match utxo.' if redeem_script && !utxo.script_pubkey.include?(redeem_script.to_hash160)
             raise ArgumentError, 'witness script does not match redeem script.' if redeem_script && witness_script && !redeem_script.include?(witness_script.to_sha256)
-            if utxo.script_pubkey.witness_program? || (redeem_script && redeem_script.witness_program?)
-              inputs[i].witness_utxo = utxo
-            else
-              inputs[i].non_witness_utxo = prev_tx
-            end
+            inputs[i].witness_utxo = utxo if utxo.script_pubkey.witness_program? || redeem_script&.witness_program?
+            inputs[i].non_witness_utxo = prev_tx
             inputs[i].redeem_script = redeem_script if redeem_script
             inputs[i].witness_script = witness_script if witness_script
             inputs[i].hd_key_paths = hd_key_paths.map(&:pubkey).zip(hd_key_paths).to_h
+            break
           end
         end
       end