bitcoinrb 0.3.0 → 0.6.0

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
 
@@ -39,6 +41,11 @@ module Bitcoin
       tx_hash.rhex
     end
 
+    def to_s
+      return "[#{index}]" unless tx_hash
+      "#{txid}[#{index}]"
+    end
+
   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, 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/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))
 
@@ -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

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))
 
@@ -78,13 +81,13 @@ module Bitcoin
           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