bitcoinrb 0.3.2 → 0.8.0

data/lib/bitcoin/message/send_cmpct.rb

@@ -21,8 +21,8 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        mode = buf.read(1).unpack('c').first
-        version = buf.read(8).unpack('Q').first
+        mode = buf.read(1).unpack1('c')
+        version = buf.read(8).unpack1('Q')
         new(mode, version)
       end
 

data/lib/bitcoin/message/tx.rb

@@ -16,7 +16,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        tx = Bitcoin::Tx.parse_from_payload(payload)
+        tx = Bitcoin::Tx.parse_from_payload(payload, strict: true)
         new(tx, tx.witness?)
       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/message_sign.rb

@@ -0,0 +1,47 @@
+module Bitcoin
+
+  module MessageSign
+
+    class Error < StandardError; end
+
+    module_function
+
+    # Sign a message.
+    # @param [Bitcoin::Key] key Private key to sign with.
+    # @param [String] message The message to sign.
+    # @return [String] Signature, base64 encoded.
+    def sign_message(key, message, prefix: Bitcoin.chain_params.message_magic)
+      digest = message_hash(message, prefix: prefix)
+      compact_sig = key.sign_compact(digest)
+      Base64.strict_encode64(compact_sig)
+    end
+
+    # Verify a signed message.
+    # @param [String] address Signer's bitcoin address, it must refer to a public key.
+    # @param [String] signature The signature in base64 format.
+    # @param [String] message The message that was signed.
+    # @return [Boolean] Verification result.
+    def verify_message(address, signature, message, prefix: Bitcoin.chain_params.message_magic)
+      validate_address!(address)
+      sig = Base64.decode64(signature)
+      raise ArgumentError, 'Invalid signature length' unless sig.bytesize == Bitcoin::Key::COMPACT_SIGNATURE_SIZE
+      digest = message_hash(message, prefix: prefix)
+      pubkey = Bitcoin::Key.recover_compact(digest, sig)
+      return false unless pubkey
+      pubkey.to_p2pkh == address
+    end
+
+    # Hashes a message for signing and verification.
+    def message_hash(message, prefix: Bitcoin.chain_params.message_magic)
+      Bitcoin.double_sha256(Bitcoin.pack_var_string(prefix) << Bitcoin.pack_var_string(message))
+    end
+
+    def validate_address!(address)
+      raise ArgumentError, 'Invalid address' unless Bitcoin.valid_address?(address)
+      script = Bitcoin::Script.parse_from_addr(address)
+      raise ArgumentError, 'Address has no key' unless script.p2pkh?
+    end
+
+    private_class_method :validate_address!
+  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
@@ -39,7 +39,7 @@ module Bitcoin
     # @return [Array] the array of mnemonic word.
     def to_mnemonic(entropy)
       raise ArgumentError, 'entropy is empty.' if entropy.nil? || entropy.empty?
-      e = entropy.htb.unpack('B*').first
+      e = entropy.htb.unpack1('B*')
       seed = e + checksum(e)
       mnemonic_index = seed.chars.each_slice(11).map{|i|i.join.to_i(2)}
       word_master = load_words
@@ -61,7 +61,7 @@ module Bitcoin
     # @param [String] entropy an entropy with bit string format
     # @return [String] an entropy checksum with bit string format
     def checksum(entropy)
-      b = Bitcoin.sha256([entropy].pack('B*')).unpack('B*').first
+      b = Bitcoin.sha256([entropy].pack('B*')).unpack1('B*')
       b.slice(0, (entropy.length/32))
     end
 
@@ -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,7 @@ 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
+            Socket.getaddrinfo("#{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/configuration.rb

@@ -4,8 +4,10 @@ module Bitcoin
   module Node
     class Configuration
 
-      attr_reader :conf
+      attr_reader :conf # Hash
 
+      # initialize configuration
+      # @param [Hash] opts parameter for node.
       def initialize(opts = {})
         # TODO apply configuration file.
         opts[:network] = :mainnet unless opts[:network]

data/lib/bitcoin/node/spv.rb

@@ -13,6 +13,14 @@ module Bitcoin
       attr_accessor :wallet
       attr_accessor :bloom
 
+      # Initialize spv settings
+      # @param [Bitcoin::Node::Configuration] configuration configuration for spv.
+      #
+      # ```ruby
+      # config = Bitcoin::Node::Configuration.new(network: :mainnet)
+      # spv = Bitcoin::Node::SPV.new(config)
+      # spv.run
+      # ````
       def initialize(configuration)
         @chain = Bitcoin::Store::SPVChain.new
         @configuration = configuration
@@ -45,7 +53,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/opcodes.rb

@@ -136,6 +136,8 @@ module Bitcoin
     OP_NOP9 = 0xb8
     OP_NOP10 = 0xb9
 
+    OP_CHECKSIGADD = 0xba # BIP 342 opcodes (Tapscript)
+
     # https://en.bitcoin.it/wiki/Script#Pseudo-words
     OP_PUBKEYHASH = 0xfd
     OP_PUBKEY = 0xfe
@@ -145,6 +147,9 @@ module Bitcoin
     OPCODES_MAP = Hash[*(constants.grep(/^OP_/) - [:OP_NOP2, :OP_NOP3, :OP_CHECKLOCKTIMEVERIFY, :OP_CHECKSEQUENCEVERIFY]).map { |c| [const_get(c), c.to_s] }.flatten]
     NAME_MAP = Hash[*constants.grep(/^OP_/).map { |c| [c.to_s, const_get(c)] }.flatten]
 
+    OP_SUCCESSES = [0x50, 0x62, 0x89, 0x8a, 0x8d, 0x8e, (0x7e..0x81).to_a,
+                    (0x83..0x86).to_a, (0x95..0x99).to_a, (0xbb..0xfe).to_a].flatten
+
     def opcode_to_name(opcode)
       return OPCODES_MAP[opcode].delete('OP_') if opcode == OP_0 || (opcode <= OP_16 && opcode >= OP_1)
       OPCODES_MAP[opcode]
@@ -156,7 +161,8 @@ module Bitcoin
     end
 
     # whether opcode is predefined opcode
-    def defined?(opcode)
+    def defined?(opcode, allow_success = false)
+      return true if allow_success && op_success?(opcode)
       !opcode_to_name(opcode).nil?
     end
 
@@ -174,5 +180,12 @@ module Bitcoin
       nil
     end
 
+    # Check whether +opcode+ is OP_SUCCESSx or not?
+    # @param [Integer] opcode an opcode.
+    # @return [Boolean] if +opcode+ is OP_SUCCESSx return true, otherwise false.
+    def op_success?(opcode)
+      OP_SUCCESSES.include?(opcode)
+    end
+
   end
 end

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, Errors::Messages::INVALID_PUBLIC_KEY unless Bitcoin::Key.new(priv_key: nil, pubkey: sign + public_key).fully_valid_pubkey?
+      raise ArgumentError, Errors::Messages::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/payments/payment.pb.rb

@@ -17,7 +17,7 @@ module Bitcoin
       end
 
       def transactions
-        @values[:transactions].map{|raw_tx|Bitcoin::Tx.parse_from_payload(raw_tx)}
+        @values[:transactions].map{|raw_tx|Bitcoin::Tx.parse_from_payload(raw_tx, strict: true)}
       end
 
     end

data/lib/bitcoin/psbt/hd_key_path.rb

@@ -12,7 +12,7 @@ module Bitcoin
         pubkey = pubkey.encoding == Encoding::ASCII_8BIT ? pubkey : pubkey.htb
         raise ArgumentError, 'Size of key was not the expected size for the type BIP32 keypath.' unless [Bitcoin::Key::PUBLIC_KEY_SIZE, Bitcoin::Key::COMPRESSED_PUBLIC_KEY_SIZE].include?(pubkey.bytesize)
         pubkey = Bitcoin::Key.new(pubkey: pubkey.bth)
-        raise ArgumentError, 'Invalid pubkey' unless pubkey.fully_valid_pubkey?
+        raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless pubkey.fully_valid_pubkey?
         @pubkey = pubkey.pubkey
         @info = info
       end

data/lib/bitcoin/psbt/input.rb

@@ -36,7 +36,7 @@ module Bitcoin
             found_sep = true
             break
           end
-          key_type = buf.read(1).unpack('C').first
+          key_type = buf.read(1).unpack1('C')
           key = buf.read(key_len - 1)
           value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
 
@@ -44,7 +44,7 @@ module Bitcoin
           when PSBT_IN_TYPES[:non_witness_utxo]
             raise ArgumentError, 'Invalid non-witness utxo typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, input non-witness utxo already provided.' if input.non_witness_utxo
-            input.non_witness_utxo = Bitcoin::Tx.parse_from_payload(value)
+            input.non_witness_utxo = Bitcoin::Tx.parse_from_payload(value, strict: true)
           when PSBT_IN_TYPES[:witness_utxo]
             raise ArgumentError, 'Invalid input witness utxo typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, input witness utxo already provided.' if input.witness_utxo
@@ -54,13 +54,13 @@ module Bitcoin
               raise ArgumentError, 'Size of key was not the expected size for the type partial signature pubkey.'
             end
             pubkey = Bitcoin::Key.new(pubkey: key.bth)
-            raise ArgumentError, 'Invalid pubkey.' unless pubkey.fully_valid_pubkey?
+            raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless pubkey.fully_valid_pubkey?
             raise ArgumentError, 'Duplicate Key, input partial signature for pubkey already provided.' if input.partial_sigs[pubkey.pubkey]
             input.partial_sigs[pubkey.pubkey] = value
           when PSBT_IN_TYPES[:sighash]
             raise ArgumentError, 'Invalid input sighash type typed key.' unless key_len == 1
             raise ArgumentError 'Duplicate Key, input sighash type already provided.' if input.sighash_type
-            input.sighash_type = value.unpack('I').first
+            input.sighash_type = value.unpack1('I')
           when PSBT_IN_TYPES[:redeem_script]
             raise ArgumentError, 'Invalid redeemscript typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, input redeemScript already provided.' if input.redeem_script
@@ -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