bitcoinrb 0.2.9 → 0.5.0

data/lib/bitcoin/message/network_addr.rb

@@ -1,3 +1,5 @@
+require 'ipaddr'
+
 module Bitcoin
   module Message
 
@@ -12,30 +14,47 @@ module Bitcoin
       # The services the node advertised in its version message.
       attr_accessor :services
 
-      attr_accessor :ip
+      attr_accessor :ip_addr # IPAddr
 
       attr_accessor :port
 
-      def initialize
-        @time = Time.now.to_i
-        @services = Bitcoin::Message::SERVICE_FLAGS[:network]
+      attr_reader :skip_time
+
+      def initialize(ip: '127.0.0.1', port: Bitcoin.chain_params.default_port, services: DEFAULT_SERVICE_FLAGS, time: Time.now.to_i)
+        @time = time
+        @ip_addr = IPAddr.new(ip)
+        @port = port
+        @services = services
       end
 
       def self.parse_from_payload(payload)
         buf = payload.is_a?(String) ? StringIO.new(payload) : payload
-        addr = new
-        addr.time = buf.read(4).unpack('V').first
+        has_time = buf.size > 26
+        addr = new(time: nil)
+        addr.time = buf.read(4).unpack('V').first if has_time
         addr.services = buf.read(8).unpack('Q').first
-        ip = IPAddr::new_ntoh(buf.read(16))
-        addr.ip = ip.ipv4_mapped? ? ip.native : ip.to_s
+        addr.ip_addr = IPAddr::new_ntoh(buf.read(16))
         addr.port = buf.read(2).unpack('n').first
         addr
       end
 
-      def to_payload
-        ip_addr = IPAddr.new (ip)
-        ip_addr = ip_addr.ipv4_mapped if ip_addr.ipv4?
-        [time, services].pack('VQ') << ip_addr.hton << [port].pack('n')
+      def self.local_addr
+        addr = new
+        addr.ip_addr = IPAddr.new('127.0.0.1')
+        addr.port = Bitcoin.chain_params.default_port
+        addr.services = DEFAULT_SERVICE_FLAGS
+        addr
+      end
+
+      def ip
+        ip_addr.ipv4_mapped? ? ip_addr.native : ip_addr.to_s
+      end
+
+      def to_payload(skip_time = false)
+        p = ''
+        p << [time].pack('V') unless skip_time
+        addr = ip_addr.ipv4? ? ip_addr.ipv4_mapped : ip_addr
+        p << [services].pack('Q') << addr.hton << [port].pack('n')
       end
 
     end

data/lib/bitcoin/message/version.rb

@@ -22,8 +22,8 @@ module Bitcoin
         @version = Bitcoin.chain_params.protocol_version
         @services = DEFAULT_SERVICE_FLAGS
         @timestamp = Time.now.to_i
-        @local_addr = "127.0.0.1:#{Bitcoin.chain_params.default_port}"
-        @remote_addr = "127.0.0.1:#{Bitcoin.chain_params.default_port}"
+        @local_addr = NetworkAddr.local_addr
+        @remote_addr = NetworkAddr.local_addr
         @nonce = SecureRandom.random_number(0xffffffffffffffff)
         @user_agent = Bitcoin::Message::USER_AGENT
         @start_height = 0
@@ -32,13 +32,13 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        version, services, timestamp, remote_addr, local_addr, nonce, rest = payload.unpack('VQQa26a26Qa*')
+        version, services, timestamp, local_addr, remote_addr, nonce, rest = payload.unpack('VQQa26a26Qa*')
         v = new
         v.version = version
         v.services = services
         v.timestamp = timestamp
-        v.remote_addr = v.unpack_addr(remote_addr)
-        v.local_addr = v.unpack_addr(local_addr)
+        v.local_addr = NetworkAddr.parse_from_payload(local_addr)
+        v.remote_addr = NetworkAddr.parse_from_payload(remote_addr)
         v.nonce = nonce
         user_agent, rest = unpack_var_string(rest)
         start_height, rest = rest.unpack('Va*')
@@ -51,8 +51,8 @@ module Bitcoin
       def to_payload
         [
           [version, services, timestamp].pack('VQQ'),
-          pack_addr(local_addr),
-          pack_addr(remote_addr),
+          local_addr.to_payload(true),
+          remote_addr.to_payload(true),
           [nonce].pack('Q'),
           pack_var_string(user_agent),
           [start_height].pack('V'),
@@ -60,25 +60,17 @@ module Bitcoin
         ].join
       end
 
-      def pack_addr(addr)
-        separator = addr.rindex(':')
-        ip = addr[0...separator]
-        port = addr[separator + 1..-1].to_i
-        ip_addr = IPAddr.new(ip)
-        ip_addr = ip_addr.ipv4_mapped if ip_addr.ipv4?
-        [1].pack('Q') << ip_addr.hton << [port].pack('n')
-        # [[1].pack('Q'), "\x00" * 10, "\xFF\xFF", sockaddr[4...8], sockaddr[2...4]].join
-      end
-
-      def unpack_addr(addr)
-        host, port = addr.unpack('x8x12a4n')
-        "#{host.unpack('C*').join('.')}:#{port}"
-      end
-
       def unpack_relay_field(payload)
         ( 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

@@ -50,7 +50,8 @@ module Bitcoin
         @bytes_recv = 0
         @relay = configuration.conf[:relay]
         current_height = @chain.latest_block.height
-        @local_version = Bitcoin::Message::Version.new(remote_addr: addr, start_height: current_height, relay: @relay)
+        remote_addr = Bitcoin::Message::NetworkAddr.new(ip: host, port: port, time: nil)
+        @local_version = Bitcoin::Message::Version.new(remote_addr: remote_addr, start_height: current_height, relay: @relay)
       end
 
       def connect
@@ -82,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
@@ -164,12 +170,7 @@ module Bitcoin
       # @return [Bitcoin::Message::NetworkAddr]
       def to_network_addr
         v = remote_version
-        addr = Bitcoin::Message::NetworkAddr.new
-        addr.time = v.timestamp
-        addr.services = v.services
-        addr.ip = host
-        addr.port = port
-        addr
+        Bitcoin::Message::NetworkAddr.new(ip: host, port: port, services: v.services, time: v.timestamp)
       end
 
       # send +addr+ message to remote peer

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,14 +3,16 @@ module Bitcoin
   # outpoint class
   class OutPoint
 
+    include Bitcoin::HexConverter
+
     COINBASE_HASH = '0000000000000000000000000000000000000000000000000000000000000000'
     COINBASE_INDEX = 4294967295
 
-    attr_reader :hash
+    attr_reader :tx_hash
     attr_reader :index
 
-    def initialize(hash, index = -1)
-      @hash = hash
+    def initialize(tx_hash, index = -1)
+      @tx_hash = tx_hash
       @index = index
     end
 
@@ -19,11 +21,11 @@ module Bitcoin
     end
 
     def coinbase?
-      hash == COINBASE_HASH && index == COINBASE_INDEX
+      tx_hash == COINBASE_HASH && index == COINBASE_INDEX
     end
 
     def to_payload
-      [hash.htb, index].pack('a32V')
+      [tx_hash.htb, index].pack('a32V')
     end
 
     def self.create_coinbase_outpoint
@@ -31,12 +33,17 @@ module Bitcoin
     end
 
     def valid?
-      index >= 0 && (!coinbase? && hash != COINBASE_HASH)
+      index >= 0 && (!coinbase? && tx_hash != COINBASE_HASH)
     end
 
     # convert hash to txid
     def txid
-      hash.rhex
+      tx_hash.rhex
+    end
+
+    def to_s
+      return "[#{index}]" unless tx_hash
+      "#{txid}[#{index}]"
     end
 
   end

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.rb

@@ -12,13 +12,15 @@ module Bitcoin
 
     # constants for PSBT
     PSBT_MAGIC_BYTES = 0x70736274
-    PSBT_GLOBAL_TYPES = {unsigned_tx: 0x00, xpub: 0x01}
+    PSBT_GLOBAL_TYPES = {unsigned_tx: 0x00, xpub: 0x01, ver: 0xfb}
     PSBT_IN_TYPES = {non_witness_utxo: 0x00, witness_utxo: 0x01, partial_sig: 0x02,
                      sighash: 0x03, redeem_script: 0x04, witness_script: 0x05,
                      bip32_derivation: 0x06, script_sig: 0x07, script_witness: 0x08}
     PSBT_OUT_TYPES = {redeem_script: 0x00, witness_script: 0x01, bip32_derivation: 0x02}
     PSBT_SEPARATOR = 0x00
 
+    SUPPORT_VERSION = 0
+
     module_function
 
     def self.serialize_to_vector(key_type, key: nil, value: nil)

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
@@ -156,7 +147,7 @@ module Bitcoin
       # @param [String] pubkey a public key with hex format.
       # @param [String] sig a signature.
       def add_sig(pubkey, sig)
-        raise ArgumentError, 'The sighash in signature is invalid.' unless sig.unpack('C*')[-1] == sighash_type
+        raise ArgumentError, 'The sighash in signature is invalid.' if sighash_type && sig.unpack('C*')[-1] != sighash_type
         raise ArgumentError, 'Duplicate Key, input partial signature for pubkey already provided.' if partial_sigs[pubkey]
         partial_sigs[pubkey] = sig
       end
@@ -168,7 +159,7 @@ module Bitcoin
         raise ArgumentError, 'The argument psbt must be an instance of Bitcoin::PSBT::Input.' unless psbi.is_a?(Bitcoin::PSBT::Input)
         raise ArgumentError, 'The Partially Signed Input\'s non_witness_utxo are different.' unless non_witness_utxo == psbi.non_witness_utxo
         raise ArgumentError, 'The Partially Signed Input\'s witness_utxo are different.' unless witness_utxo == psbi.witness_utxo
-        raise ArgumentError, 'The Partially Signed Input\'s sighash_type are different.' unless sighash_type == psbi.sighash_type
+        raise ArgumentError, 'The Partially Signed Input\'s sighash_type are different.' if sighash_type && psbi.sighash_type && sighash_type != psbi.sighash_type
         raise ArgumentError, 'The Partially Signed Input\'s redeem_script are different.' unless redeem_script == psbi.redeem_script
         raise ArgumentError, 'The Partially Signed Input\'s witness_script are different.' unless witness_script == psbi.witness_script
         combined = Bitcoin::PSBT::Input.new(non_witness_utxo: non_witness_utxo, witness_utxo: witness_utxo)
@@ -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