bitcoinrb 0.2.9 → 0.5.0

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,11 +26,14 @@ module Bitcoin
     end
 
     class Tx
+      include Bitcoin::HexConverter
+
       attr_accessor :tx
       attr_accessor :xpubs
       attr_reader :inputs
       attr_reader :outputs
       attr_accessor :unknowns
+      attr_accessor :version_number
 
       def initialize(tx = nil)
         @tx = tx
@@ -82,6 +86,9 @@ module Bitcoin
             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
+            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]
             partial_tx.unknowns[([key_type].pack('C') + key).bth] = value
@@ -113,13 +120,15 @@ 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
 
+      # get PSBT version
+      # @return [Integer] PSBT version number
+      def version
+        version_number ? version_number : 0
+      end
+
       # Finds the UTXO for a given input index
       # @param [Integer] index input_index Index of the input to retrieve the UTXO of
       # @return [Bitcoin::TxOut] The UTXO of the input if found.
@@ -138,11 +147,10 @@ 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
@@ -166,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_s 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[0..peer.remote_version.remote_addr.rindex(':')] + '18333'
+          local_addr = "#{peer.remote_version.remote_addr.ip}:18333"
           {
             id: peer.id,
             addr: "#{peer.host}:#{peer.port}",
@@ -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
 
@@ -54,7 +55,8 @@ module Bitcoin
     # @param [String] 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)
+    def self.to_multisig_script(m, pubkeys, sort: false)
+      pubkeys = pubkeys.sort if sort
       new << m << pubkeys << pubkeys.size << OP_CHECKMULTISIG
     end
 
@@ -147,7 +149,9 @@ module Bitcoin
       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?
@@ -155,6 +159,15 @@ 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?
@@ -323,6 +336,7 @@ 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
@@ -350,7 +364,7 @@ module Bitcoin
 
     # generate hash160 hash for payload
     def to_hash160
-      Bitcoin.hash160(to_payload.bth)
+      Bitcoin.hash160(to_hex)
     end
 
     # script size
@@ -487,7 +501,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
@@ -503,12 +517,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.
@@ -541,7 +549,7 @@ 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
 

data/lib/bitcoin/script/script_interpreter.rb

@@ -61,7 +61,6 @@ module Bitcoin
       # Additional validation for spend-to-script-hash transactions
       if flag?(SCRIPT_VERIFY_P2SH) && script_pubkey.p2sh?
         return set_error(SCRIPT_ERR_SIG_PUSHONLY) unless script_sig.push_only?
-        tmp = stack
         @stack = stack_copy
         raise 'stack cannot be empty.' if stack.empty?
         begin
@@ -76,7 +75,7 @@ module Bitcoin
         if flag?(SCRIPT_VERIFY_WITNESS) && redeem_script.witness_program?
           had_witness = true
           # The scriptSig must be _exactly_ a single push of the redeemScript. Otherwise we reintroduce malleability.
-          return set_error(SCRIPT_ERR_WITNESS_MALLEATED_P2SH) unless script_sig == (Bitcoin::Script.new << redeem_script.to_payload.bth)
+          return set_error(SCRIPT_ERR_WITNESS_MALLEATED_P2SH) unless script_sig == (Bitcoin::Script.new << redeem_script.to_hex)
 
           version, program = redeem_script.witness_data
           return false unless verify_witness_program(witness, version, program)
@@ -133,7 +132,7 @@ module Bitcoin
 
       return false unless eval_script(script_pubkey, :witness_v0)
 
-      return set_error(SCRIPT_ERR_EVAL_FALSE) unless stack.size == 1
+      return set_error(SCRIPT_ERR_CLEANSTACK) unless stack.size == 1
       return set_error(SCRIPT_ERR_EVAL_FALSE) unless cast_to_bool(stack.last)
       true
     end
@@ -147,7 +146,7 @@ module Bitcoin
         op_count = 0
 
         script.chunks.each_with_index do |c, index|
-          need_exec = !flow_stack.include?(false)
+          need_exec = flow_stack.rindex(false).nil?
 
           return set_error(SCRIPT_ERR_PUSH_SIZE) if c.pushdata? && c.pushed_data.bytesize > MAX_SCRIPT_ELEMENT_SIZE
 
@@ -609,7 +608,6 @@ module Bitcoin
       return false if sig.empty?
       s = sig.unpack('C*')
       hash_type = s[-1] & (~(SIGHASH_TYPE[:anyonecanpay]))
-      hash_type &= (~(Bitcoin::SIGHASH_FORK_ID)) if Bitcoin.chain_params.fork_chain? # for fork coin.
       return false if hash_type < SIGHASH_TYPE[:all] || hash_type > SIGHASH_TYPE[:single]
       true
     end

data/lib/bitcoin/secp256k1.rb

@@ -6,6 +6,7 @@ module Bitcoin
 
     autoload :Ruby, 'bitcoin/secp256k1/ruby'
     autoload :Native, 'bitcoin/secp256k1/native'
+    autoload :RFC6979, 'bitcoin/secp256k1/rfc6979'
 
   end
 

data/lib/bitcoin/secp256k1/rfc6979.rb

@@ -0,0 +1,43 @@
+module Bitcoin
+  module Secp256k1
+    module RFC6979
+
+      INITIAL_V = '0101010101010101010101010101010101010101010101010101010101010101'.htb
+      INITIAL_K = '0000000000000000000000000000000000000000000000000000000000000000'.htb
+      ZERO_B = '00'.htb
+      ONE_B = '01'.htb
+
+      module_function
+
+      # generate temporary key k to be used when ECDSA sign.
+      # https://tools.ietf.org/html/rfc6979#section-3.2
+      # @param [String] key_data a data contains private key and message.
+      # @param [String] extra_entropy extra entropy with binary format.
+      # @return [Integer] a nonce.
+      def generate_rfc6979_nonce(key_data, extra_entropy)
+        v = INITIAL_V # 3.2.b
+        k = INITIAL_K # 3.2.c
+        # 3.2.d
+        k = Bitcoin.hmac_sha256(k, v + ZERO_B + key_data + extra_entropy)
+        # 3.2.e
+        v = Bitcoin.hmac_sha256(k, v)
+        # 3.2.f
+        k = Bitcoin.hmac_sha256(k, v + ONE_B + key_data + extra_entropy)
+        # 3.2.g
+        v = Bitcoin.hmac_sha256(k, v)
+        # 3.2.h
+        t = ''
+        10000.times do
+          v = Bitcoin.hmac_sha256(k, v)
+          t = (t + v)
+          t_num = t.bth.to_i(16)
+          return t_num if 1 <= t_num && t_num < Bitcoin::Secp256k1::GROUP.order
+          k = Bitcoin.hmac_sha256(k, v + '00'.htb)
+          v = Bitcoin.hmac_sha256(k, v)
+        end
+        raise 'A valid nonce was not found.'
+      end
+
+    end
+  end
+end

data/lib/bitcoin/secp256k1/ruby.rb

@@ -12,8 +12,8 @@ module Bitcoin
         private_key = 1 + SecureRandom.random_number(GROUP.order - 1)
         public_key = GROUP.generator.multiply_by_scalar(private_key)
         privkey = ECDSA::Format::IntegerOctetString.encode(private_key, 32)
-        pubkey = ECDSA::Format::PointOctetString.encode(public_key, compression: compressed)
-        [privkey.bth, pubkey.bth]
+        pubkey = public_key.to_hex(compressed)
+        [privkey.bth, pubkey]
       end
 
       # generate bitcoin key object
@@ -24,7 +24,7 @@ module Bitcoin
 
       def generate_pubkey(privkey, compressed: true)
         public_key = ECDSA::Group::Secp256k1.generator.multiply_by_scalar(privkey.to_i(16))
-        ECDSA::Format::PointOctetString.encode(public_key, compression: compressed).bth
+        public_key.to_hex(compressed)
       end
 
       # sign data.
@@ -35,7 +35,7 @@ module Bitcoin
         privkey = privkey.htb
         private_key = ECDSA::Format::IntegerOctetString.decode(privkey)
         extra_entropy ||= ''
-        nonce = generate_rfc6979_nonce(data, privkey, extra_entropy)
+        nonce = RFC6979.generate_rfc6979_nonce(privkey + data, extra_entropy)
 
         # port form ecdsa gem.
         r_point = GROUP.new_point(nonce)
@@ -87,37 +87,6 @@ module Bitcoin
         end
       end
 
-      INITIAL_V = '0101010101010101010101010101010101010101010101010101010101010101'.htb
-      INITIAL_K = '0000000000000000000000000000000000000000000000000000000000000000'.htb
-      ZERO_B = '00'.htb
-      ONE_B = '01'.htb
-
-      # generate temporary key k to be used when ECDSA sign.
-      # https://tools.ietf.org/html/rfc6979#section-3.2
-      def generate_rfc6979_nonce(data, privkey, extra_entropy)
-        v = INITIAL_V # 3.2.b
-        k = INITIAL_K # 3.2.c
-        # 3.2.d
-        k = Bitcoin.hmac_sha256(k, v + ZERO_B + privkey + data + extra_entropy)
-        # 3.2.e
-        v = Bitcoin.hmac_sha256(k, v)
-        # 3.2.f
-        k = Bitcoin.hmac_sha256(k, v + ONE_B + privkey + data + extra_entropy)
-        # 3.2.g
-        v = Bitcoin.hmac_sha256(k, v)
-        # 3.2.h
-        t = ''
-        10000.times do
-          v = Bitcoin.hmac_sha256(k, v)
-          t = (t + v)
-          t_num = t.bth.to_i(16)
-          return t_num if 1 <= t_num && t_num < GROUP.order
-          k = Bitcoin.hmac_sha256(k, v + '00'.htb)
-          v = Bitcoin.hmac_sha256(k, v)
-        end
-        raise 'A valid nonce was not found.'
-      end
     end
-
   end
 end

data/lib/bitcoin/slip39.rb

@@ -0,0 +1,93 @@
+module Bitcoin
+  module SLIP39
+
+    WORDS = File.readlines("#{__dir__}/slip39/wordlist/english.txt").map(&:strip)
+
+    module_function
+
+    def bits_to_bytes(n)
+      (n + 7) / 8
+    end
+
+    def bits_to_words(n)
+      (n + RADIX_BITS - 1) / RADIX_BITS
+    end
+
+    # The length of the radix in bits.
+    RADIX_BITS = 10
+    # The number of words in the wordlist.
+    RADIX = 2 ** RADIX_BITS
+    # The length of the random identifier in bits.
+    ID_LENGTH_BITS = 15
+    # The length of the iteration exponent in bits.
+    ITERATION_EXP_LENGTH_BITS = 5
+    # The length of the random identifier and iteration exponent in words.
+    ID_EXP_LENGTH_WORDS = bits_to_words(ID_LENGTH_BITS + ITERATION_EXP_LENGTH_BITS)
+    # The maximum number of shares that can be created.
+    MAX_SHARE_COUNT = 16
+    # The length of the RS1024 checksum in words.
+    CHECKSUM_LENGTH_WORDS = 3
+    # The length of the digest of the shared secret in bytes.
+    DIGEST_LENGTH_BYTES = 4
+    # The customization string used in the RS1024 checksum and in the PBKDF2 salt.
+    CUSTOMIZATION_STRING = 'shamir'.bytes
+    # The length of the mnemonic in words without the share value.
+    METADATA_LENGTH_WORDS = ID_EXP_LENGTH_WORDS + 2 + CHECKSUM_LENGTH_WORDS
+    # The minimum allowed entropy of the master secret.
+    MIN_STRENGTH_BITS = 128
+    # The minimum allowed length of the mnemonic in words.
+    MIN_MNEMONIC_LENGTH_WORDS = METADATA_LENGTH_WORDS + bits_to_words(MIN_STRENGTH_BITS)
+    # The minimum number of iterations to use in PBKDF2.
+    BASE_ITERATION_COUNT = 10000
+    # The number of rounds to use in the Feistel cipher.
+    ROUND_COUNT = 4
+    # The index of the share containing the shared secret.
+    SECRET_INDEX = 255
+    # The index of the share containing the digest of the shared secret.
+    DIGEST_INDEX = 254
+
+    EXP_TABLE = [
+        1, 3, 5, 15, 17, 51, 85, 255, 26, 46, 114, 150, 161, 248, 19,
+        53, 95, 225, 56, 72, 216, 115, 149, 164, 247, 2, 6, 10, 30, 34,
+        102, 170, 229, 52, 92, 228, 55, 89, 235, 38, 106, 190, 217, 112, 144,
+        171, 230, 49, 83, 245, 4, 12, 20, 60, 68, 204, 79, 209, 104, 184,
+        211, 110, 178, 205, 76, 212, 103, 169, 224, 59, 77, 215, 98, 166, 241,
+        8, 24, 40, 120, 136, 131, 158, 185, 208, 107, 189, 220, 127, 129, 152,
+        179, 206, 73, 219, 118, 154, 181, 196, 87, 249, 16, 48, 80, 240, 11,
+        29, 39, 105, 187, 214, 97, 163, 254, 25, 43, 125, 135, 146, 173, 236,
+        47, 113, 147, 174, 233, 32, 96, 160, 251, 22, 58, 78, 210, 109, 183,
+        194, 93, 231, 50, 86, 250, 21, 63, 65, 195, 94, 226, 61, 71, 201,
+        64, 192, 91, 237, 44, 116, 156, 191, 218, 117, 159, 186, 213, 100, 172,
+        239, 42, 126, 130, 157, 188, 223, 122, 142, 137, 128, 155, 182, 193, 88,
+        232, 35, 101, 175, 234, 37, 111, 177, 200, 67, 197, 84, 252, 31, 33,
+        99, 165, 244, 7, 9, 27, 45, 119, 153, 176, 203, 70, 202, 69, 207,
+        74, 222, 121, 139, 134, 145, 168, 227, 62, 66, 198, 81, 243, 14, 18,
+        54, 90, 238, 41, 123, 141, 140, 143, 138, 133, 148, 167, 242, 13, 23,
+        57, 75, 221, 124, 132, 151, 162, 253, 28, 36, 108, 180, 199, 82, 246
+    ]
+
+    LOG_TABLE = [
+        0, 0, 25, 1, 50, 2, 26, 198, 75, 199, 27, 104, 51, 238, 223, 3,
+        100, 4, 224, 14, 52, 141, 129, 239, 76, 113, 8, 200, 248, 105, 28,
+        193, 125, 194, 29, 181, 249, 185, 39, 106, 77, 228, 166, 114, 154, 201,
+        9, 120, 101, 47, 138, 5, 33, 15, 225, 36, 18, 240, 130, 69, 53,
+        147, 218, 142, 150, 143, 219, 189, 54, 208, 206, 148, 19, 92, 210, 241,
+        64, 70, 131, 56, 102, 221, 253, 48, 191, 6, 139, 98, 179, 37, 226,
+        152, 34, 136, 145, 16, 126, 110, 72, 195, 163, 182, 30, 66, 58, 107,
+        40, 84, 250, 133, 61, 186, 43, 121, 10, 21, 155, 159, 94, 202, 78,
+        212, 172, 229, 243, 115, 167, 87, 175, 88, 168, 80, 244, 234, 214, 116,
+        79, 174, 233, 213, 231, 230, 173, 232, 44, 215, 117, 122, 235, 22, 11,
+        245, 89, 203, 95, 176, 156, 169, 81, 160, 127, 12, 246, 111, 23, 196,
+        73, 236, 216, 67, 31, 45, 164, 118, 123, 183, 204, 187, 62, 90, 251,
+        96, 177, 134, 59, 82, 161, 108, 170, 85, 41, 157, 151, 178, 135, 144,
+        97, 190, 220, 252, 188, 149, 207, 205, 55, 63, 91, 209, 83, 57, 132,
+        60, 65, 162, 109, 71, 20, 42, 158, 93, 86, 242, 211, 171, 68, 17, 146,
+        217, 35, 32, 46, 137, 180, 124, 184, 38, 119, 153, 227, 165, 103, 74, 237,
+        222, 197, 49, 254, 24, 13, 99, 140, 128, 192, 247, 112, 7
+    ]
+
+    autoload :SSS, 'bitcoin/slip39/sss'
+    autoload :Share, 'bitcoin/slip39/share'
+
+  end
+end