bitcoinrb 0.3.2 → 0.8.0

data/lib/bitcoin/psbt/output.rb

@@ -26,7 +26,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))
           case key_type

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
@@ -52,7 +55,7 @@ module Bitcoin
       # @return [Bitcoin::PartiallySignedTx]
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        raise ArgumentError, 'Invalid PSBT magic bytes.' unless buf.read(4).unpack('N').first == PSBT_MAGIC_BYTES
+        raise ArgumentError, 'Invalid PSBT magic bytes.' unless buf.read(4).unpack1('N') == PSBT_MAGIC_BYTES
         raise ArgumentError, 'Invalid PSBT separator.' unless buf.read(1).bth.to_i(16) == 0xff
         partial_tx = self.new
         found_sep = false
@@ -63,7 +66,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))
 
@@ -71,20 +74,20 @@ module Bitcoin
           when PSBT_GLOBAL_TYPES[:unsigned_tx]
             raise ArgumentError, 'Invalid global transaction typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, unsigned tx already provided.' if partial_tx.tx
-            partial_tx.tx = Bitcoin::Tx.parse_from_payload(value, non_witness: true)
+            partial_tx.tx = Bitcoin::Tx.parse_from_payload(value, non_witness: true, strict: true)
             partial_tx.tx.in.each do |tx_in|
               raise ArgumentError, 'Unsigned tx does not have empty scriptSigs and scriptWitnesses.' if !tx_in.script_sig.empty? || !tx_in.script_witness.empty?
             end
           when PSBT_GLOBAL_TYPES[:xpub]
             raise ArgumentError, 'Size of key was not the expected size for the type global xpub.' unless key.size == Bitcoin::BIP32_EXTKEY_WITH_VERSION_SIZE
             xpub = Bitcoin::ExtPubkey.parse_from_payload(key)
-            raise ArgumentError, 'Invalid pubkey.' unless xpub.key.fully_valid_pubkey?
+            raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless xpub.key.fully_valid_pubkey?
             raise ArgumentError, 'Duplicate key, global xpub already provided' if partial_tx.xpubs.any?{|x|x.xpub == xpub}
             info = Bitcoin::PSBT::KeyOriginInfo.parse_from_payload(value)
             raise ArgumentError, "global xpub's depth and the number of indexes not matched." unless xpub.depth == info.key_paths.size
             partial_tx.xpubs << Bitcoin::PSBT::GlobalXpub.new(xpub, info)
           when PSBT_GLOBAL_TYPES[:ver]
-            partial_tx.version_number = value.unpack('V').first
+            partial_tx.version_number = value.unpack1('V')
             raise ArgumentError, "An unsupported version was detected." if SUPPORT_VERSION < partial_tx.version_number
           else
             raise ArgumentError, 'Duplicate Key, key for unknown value already provided.' if partial_tx.unknowns[key]
@@ -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

data/lib/bitcoin/rpc/bitcoin_core_client.rb

@@ -1,4 +1,4 @@
-require 'rest-client'
+require 'net/http'
 
 module Bitcoin
   module RPC
@@ -53,20 +53,30 @@ module Bitcoin
             :params => params,
             :id => 'jsonrpc'
         }
-        post(server_url, @config[:timeout], @config[:open_timeout], data.to_json, content_type: :json) do |respdata, request, result|
-          raise result.message if !result.kind_of?(Net::HTTPSuccess) && respdata.empty?
-          response = JSON.parse(respdata.gsub(/\\u([\da-fA-F]{4})/) { [$1].pack('H*').unpack('n*').pack('U*').encode('ISO-8859-1').force_encoding('UTF-8') })
-          raise response['error'] if response['error']
-          response['result']
-        end
+        uri = URI.parse(server_url)
+        http = Net::HTTP.new(uri.hostname, uri.port)
+        http.use_ssl = uri.scheme === "https"
+        request = Net::HTTP::Post.new(uri.path.empty? ? '/' : uri.path)
+        request.basic_auth(uri.user, uri.password)
+        request.content_type = 'application/json'
+        request.body = data.to_json
+        response = http.request(request)
+        body = response.body
+        response = Bitcoin::Ext::JsonParser.new(body.gsub(/\\u([\da-fA-F]{4})/) { [$1].pack('H*').unpack('n*').pack('U*').encode('ISO-8859-1').force_encoding('UTF-8') }).parse
+        raise response['error'].to_json if response['error']
+        response['result']
       end
-
-      def post(url, timeout, open_timeout, payload, headers={}, &block)
-        RestClient::Request.execute(method: :post, url: url, timeout: timeout,
-                                    open_timeout: open_timeout, payload: payload, headers: headers, &block)
+      
+      # Call CLI command on Ruby-like method names.
+      # e.g. generate_to_address, send_to_address, get_wallet_info
+      def method_missing(name, *args)
+        if name.to_s.include?('_')
+          send(name.to_s.gsub('_', '').to_sym, args)
+        else
+          super
+        end
       end
 
     end
-
   end
 end

data/lib/bitcoin/rpc/request_handler.rb

@@ -42,14 +42,14 @@ module Bitcoin
               nextblockhash: node.chain.next_hash(block_hash).rhex
           }
         else
-          entry.header.to_payload.bth
+          entry.header.to_hex
         end
       end
 
       # Returns connected peer information.
       def getpeerinfo
         node.pool.peers.map do |peer|
-          local_addr = "#{peer.remote_version.remote_addr.ip}:18333"
+          local_addr = "#{peer.remote_version.remote_addr.addr_string}:18333"
           {
             id: peer.id,
             addr: "#{peer.host}:#{peer.port}",
@@ -75,7 +75,7 @@ module Bitcoin
 
       # broadcast transaction
       def sendrawtransaction(hex_tx)
-        tx = Bitcoin::Tx.parse_from_payload(hex_tx.htb)
+        tx = Bitcoin::Tx.parse_from_payload(hex_tx.htb, strict: true)
         # TODO check wether tx is valid
         node.broadcast(tx)
         tx.txid
@@ -84,7 +84,7 @@ module Bitcoin
       # decode tx data.
       def decoderawtransaction(hex_tx)
         begin
-          Bitcoin::Tx.parse_from_payload(hex_tx.htb).to_h
+          Bitcoin::Tx.parse_from_payload(hex_tx.htb, strict: true ).to_h
         rescue Exception
           raise ArgumentError.new('TX decode failed')
         end
@@ -96,7 +96,7 @@ module Bitcoin
           script = Bitcoin::Script.parse_from_payload(hex_script.htb)
           h = script.to_h
           h.delete(:hex)
-          h[:p2sh] = script.to_p2sh.addresses.first unless script.p2sh?
+          h[:p2sh] = script.to_p2sh.to_addr unless script.p2sh?
           h
         rescue Exception
           raise ArgumentError.new('Script decode failed')

data/lib/bitcoin/script/script.rb

@@ -6,6 +6,7 @@ module Bitcoin
   # bitcoin script
   class Script
     include Bitcoin::Opcodes
+    include Bitcoin::HexConverter
 
     attr_accessor :chunks
 
@@ -20,7 +21,7 @@ module Bitcoin
 
     # generate P2WPKH script
     def self.to_p2wpkh(pubkey_hash)
-      new << WITNESS_VERSION << pubkey_hash
+      new << WITNESS_VERSION_V0 << pubkey_hash
     end
 
     # generate m of n multisig p2sh script
@@ -51,7 +52,7 @@ module Bitcoin
     end
 
     # generate m of n multisig script
-    # @param [String] m the number of signatures required for multisig
+    # @param [Integer] m the number of signatures required for multisig
     # @param [Array] pubkeys array of public keys that compose multisig
     # @return [Script] multisig script.
     def self.to_multisig_script(m, pubkeys, sort: false)
@@ -63,7 +64,7 @@ module Bitcoin
     # @param [Script] redeem_script target redeem script
     # @param [Script] p2wsh script
     def self.to_p2wsh(redeem_script)
-      new << WITNESS_VERSION << redeem_script.to_sha256
+      new << WITNESS_VERSION_V0 << redeem_script.to_sha256
     end
 
     # generate script from string.
@@ -86,17 +87,21 @@ module Bitcoin
     def self.parse_from_addr(addr)
       begin
         segwit_addr = Bech32::SegwitAddr.new(addr)
-        raise 'Invalid hrp.' unless Bitcoin.chain_params.bech32_hrp == segwit_addr.hrp
+        raise ArgumentError, 'Invalid address.' unless Bitcoin.chain_params.bech32_hrp == segwit_addr.hrp
         Bitcoin::Script.parse_from_payload(segwit_addr.to_script_pubkey.htb)
       rescue Exception => e
+        begin
         hex, addr_version = Bitcoin.decode_base58_address(addr)
+        rescue
+          raise ArgumentError, 'Invalid address.'
+        end
         case addr_version
         when Bitcoin.chain_params.address_version
           Bitcoin::Script.to_p2pkh(hex)
         when Bitcoin.chain_params.p2sh_version
           Bitcoin::Script.to_p2sh(hex)
         else
-          throw e
+          raise ArgumentError, 'Invalid address.'
         end
       end
     end
@@ -109,25 +114,28 @@ module Bitcoin
         if opcode.pushdata?
           pushcode = opcode.ord
           packed_size = nil
+          if buf.eof?
+            s.chunks << opcode
+            return s
+          end
           len = case pushcode
                   when OP_PUSHDATA1
                     packed_size = buf.read(1)
-                    packed_size.unpack('C').first
+                    packed_size.unpack1('C')
                   when OP_PUSHDATA2
                     packed_size = buf.read(2)
-                    packed_size.unpack('v').first
+                    packed_size.unpack1('v')
                   when OP_PUSHDATA4
                     packed_size = buf.read(4)
-                    packed_size.unpack('V').first
+                    packed_size.unpack1('V')
                   else
-                    pushcode if pushcode < OP_PUSHDATA1
+                    pushcode < OP_PUSHDATA1 ? pushcode : 0
                 end
-          if len
-            s.chunks << [len].pack('C') if buf.eof?
-            unless buf.eof?
-              chunk = (packed_size ? (opcode + packed_size) : (opcode)) + buf.read(len)
-              s.chunks << chunk
-            end
+          if buf.eof?
+            s.chunks << [len].pack('C')
+          else buf.eof?
+            chunk = (packed_size ? (opcode + packed_size) : (opcode)) + buf.read(len)
+            s.chunks << chunk
           end
         else
           if Opcodes.defined?(opcode.ord)
@@ -140,15 +148,21 @@ module Bitcoin
       s
     end
 
-    def to_payload
-      chunks.join
+    # Output script payload.
+    # @param [Boolean] length_prefixed Flag whether the length of the payload should be given at the beginning.(default: false)
+    # @return [String] payload
+    def to_payload(length_prefixed = false)
+      p = chunks.join
+      length_prefixed ? (Bitcoin.pack_var_int(p.length) << p) : p
     end
 
     def empty?
       chunks.size == 0
     end
 
+    # @deprecated
     def addresses
+      puts "WARNING: Bitcoin::Script#addresses is deprecated. Use Bitcoin::Script#to_addr instead."
       return [p2pkh_addr] if p2pkh?
       return [p2sh_addr] if p2sh?
       return [bech32_addr] if witness_program?
@@ -156,29 +170,51 @@ module Bitcoin
       []
     end
 
+    # convert to address
+    # @return [String] if script type is p2pkh or p2sh or witness program, return address, otherwise nil.
+    def to_addr
+      return p2pkh_addr if p2pkh?
+      return p2sh_addr if p2sh?
+      return bech32_addr if witness_program?
+      nil
+    end
+
     # check whether standard script.
     def standard?
-      p2pkh? | p2sh? | p2wpkh? | p2wsh? | multisig? | standard_op_return?
+      p2pkh? | p2sh? | p2wpkh? | p2wsh? | p2tr? | multisig? | standard_op_return?
     end
 
-    # whether this script is a P2PKH format script.
+    # Check whether this script is a P2PKH format script.
+    # @return [Boolean] if P2PKH return true, otherwise false
     def p2pkh?
       return false unless chunks.size == 5
       [OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG] ==
           (chunks[0..1]+ chunks[3..4]).map(&:ord) && chunks[2].bytesize == 21
     end
 
-    # whether this script is a P2WPKH format script.
+    # Check whether this script is a P2WPKH format script.
+    # @return [Boolean] if P2WPKH return true, otherwise false
     def p2wpkh?
       return false unless chunks.size == 2
-      chunks[0].ord == WITNESS_VERSION && chunks[1].bytesize == 21
+      chunks[0].ord == WITNESS_VERSION_V0 && chunks[1].bytesize == 21
     end
 
+    # Check whether this script is a P2WPSH format script.
+    # @return [Boolean] if P2WPSH return true, otherwise false
     def p2wsh?
       return false unless chunks.size == 2
-      chunks[0].ord == WITNESS_VERSION && chunks[1].bytesize == 33
+      chunks[0].ord == WITNESS_VERSION_V0 && chunks[1].bytesize == 33
+    end
+
+    # Check whether this script is a P2TR format script.
+    # @return [Boolean] if P2TR return true, otherwise false
+    def p2tr?
+      return false unless chunks.size == 2
+      chunks[0].ord == WITNESS_VERSION_V1 && chunks[1].bytesize == 33
     end
 
+    # Check whether this script is a P2SH format script.
+    # @return [Boolean] if P2SH return true, otherwise false
     def p2sh?
       return false unless chunks.size == 3
       OP_HASH160 == chunks[0].ord && OP_EQUAL == chunks[2].ord && chunks[1].bytesize == 21
@@ -230,7 +266,7 @@ module Bitcoin
       return false if opcode != OP_0 && (opcode < OP_1 || opcode > OP_16)
       return false unless chunks[1].pushdata?
 
-      if size == (chunks[1][0].unpack('C').first + 2)
+      if size == (chunks[1][0].unpack1('C') + 2)
         program_size = chunks[1].pushed_data.bytesize
         return program_size >= 2 && program_size <= 40
       end
@@ -324,16 +360,21 @@ module Bitcoin
         when Integer
           opcode_to_name(c)
         when String
+          return c if c.empty?
           if c.pushdata?
             v = Opcodes.opcode_to_small_int(c.ord)
             if v
               v
             else
               data = c.pushed_data
-              if data.bytesize <= 4
-                Script.decode_number(data.bth) # for scriptnum
+              if data
+                if data.bytesize <= 4
+                  Script.decode_number(data.bth) # for scriptnum
+                else
+                  data.bth
+                end
               else
-                data.bth
+                c.bth
               end
             end
           else
@@ -351,7 +392,7 @@ module Bitcoin
 
     # generate hash160 hash for payload
     def to_hash160
-      Bitcoin.hash160(to_payload.bth)
+      Bitcoin.hash160(to_hex)
     end
 
     # script size
@@ -380,8 +421,8 @@ module Bitcoin
       hex = '0' + hex unless (hex.length % 2).zero?
       v = hex.htb.reverse # change endian
 
-      v = v << (negative ? 0x80 : 0x00) unless (v[-1].unpack('C').first & 0x80) == 0
-      v[-1] = [v[-1].unpack('C').first | 0x80].pack('C') if negative
+      v = v << (negative ? 0x80 : 0x00) unless (v[-1].unpack1('C') & 0x80) == 0
+      v[-1] = [v[-1].unpack1('C') | 0x80].pack('C') if negative
       v.bth
     end
 
@@ -389,7 +430,7 @@ module Bitcoin
     def self.decode_number(s)
       v = s.htb.reverse
       return 0 if v.length.zero?
-      mbs = v[0].unpack('C').first
+      mbs = v[0].unpack1('C')
       v[0] = [mbs - 0x80].pack('C') unless (mbs & 0x80) == 0
       result = v.bth.to_i(16)
       result = -result unless (mbs & 0x80) == 0
@@ -474,7 +515,7 @@ module Bitcoin
     end
 
     def ==(other)
-      return false unless other
+      return false unless other.is_a?(Script)
       chunks == other.chunks
     end
 
@@ -488,7 +529,7 @@ module Bitcoin
     end
 
     def to_h
-      h = {asm: to_s, hex: to_payload.bth, type: type}
+      h = {asm: to_s, hex: to_hex, type: type}
       addrs = addresses
       unless addrs.empty?
         h[:req_sigs] = multisig? ? Bitcoin::Opcodes.opcode_to_small_int(chunks[0].bth.to_i(16)) :addrs.size
@@ -504,12 +545,6 @@ module Bitcoin
       (size > 0 && op_return?) || size > Bitcoin::MAX_SCRIPT_SIZE
     end
 
-    # convert payload to hex data.
-    # @return [String] script with hex format.
-    def to_hex
-      to_payload.bth
-    end
-
     private
 
     # generate p2pkh address. if script dose not p2pkh, return nil.
@@ -542,10 +577,32 @@ module Bitcoin
     def bech32_addr
       segwit_addr = Bech32::SegwitAddr.new
       segwit_addr.hrp = Bitcoin.chain_params.bech32_hrp
-      segwit_addr.script_pubkey = to_payload.bth
+      segwit_addr.script_pubkey = to_hex
       segwit_addr.addr
     end
 
+    # Check whether push data length is valid.
+    # @return [Boolean] if valid return true, otherwise false.
+    def valid_pushdata_length?(chunk)
+      buf = StringIO.new(chunk)
+      opcode = buf.read(1).ord
+      offset = 1
+      len = case opcode
+            when OP_PUSHDATA1
+              offset += 1
+              buf.read(1).unpack1('C')
+            when OP_PUSHDATA2
+              offset += 2
+              buf.read(2).unpack1('v')
+            when OP_PUSHDATA4
+              offset += 4
+              buf.read(4).unpack1('V')
+            else
+              opcode
+            end
+      chunk.bytesize == len + offset
+    end
+
   end
 
 end