bitcoinrb 0.2.9 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db45450b62847b14f755e93063e237e6f521a30de9125659dd2325b1b445d5b2
-  data.tar.gz: b1e446e457bdad6cc7d5449ffd7a97cf26fba50f0ec85659aa53584a01ac998d
+  metadata.gz: 52fe21b51d659b4d5a45abbe8207727101813f1f30d7e0cf3438dad43ad3be8d
+  data.tar.gz: b8d94902ad2733c963f23507bdde7f018560cf8cd2ceef17bc349f78373b67ec
 SHA512:
-  metadata.gz: 67767d3f68b7b1656730a43e1dce32c9dff0b43cdd603f813e6de1c4a1b3fe4c5c51784d6afb356db42a2cc230c2fa559e1ebc2f0992afe3bb55b3d635a05ffe
-  data.tar.gz: 4d38a01b81e90b79836c47cfd4912b6f70aba0ca257627fc0aba368ace227ee475b3205263e011c84fc00b43de4e33719b72c65fdddcb81210f5f35b19ba3bbd
+  metadata.gz: 62f1c0c37657b0f3a1df74d902c42d53a0134cbf254968db70d3814bd1190937c049fc9362bc2f7a6b7570958909bf8ce7fb080ee40d1ff3a6ce410f77305ff7
+  data.tar.gz: 7306ece331df7d9fffd781d0d8bcabcd1f6fc0d6ca64271acbc6138de6ebcb1e7bd843021ef432067136c5ec28bdad4613cb42356daeb6246bf17c3f51ea4526

data/.ruby-version

@@ -1 +1 @@
-2.6.2
+2.6.3

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
-  - 2.4.5
+  - 2.4.6
   - 2.5.5
-  - 2.6.2
+  - 2.6.3
 addons:
   apt:
     packages:

data/lib/bitcoin.rb

@@ -52,6 +52,8 @@ module Bitcoin
   autoload :BitStreamWriter, 'bitcoin/bit_stream'
   autoload :BitStreamReader, 'bitcoin/bit_stream'
   autoload :KeyPath, 'bitcoin/key_path'
+  autoload :Descriptor, 'bitcoin/descriptor'
+  autoload :SLIP39, 'bitcoin/slip39'
 
   require_relative 'bitcoin/constants'
 
@@ -110,6 +112,11 @@ module Bitcoin
       [self].pack('H*')
     end
 
+    # binary convert to integer
+    def bti
+      bth.to_i(16)
+    end
+
     # reverse hex string endian
     def rhex
       htb.reverse.bth
@@ -154,6 +161,12 @@ module Bitcoin
       self[offset..-1]
     end
 
+    # whether value is hex or not hex
+    # @return [Boolean] return true if data is hex
+    def valid_hex?
+      !self[/\H/]
+    end
+
   end
 
   class ::Object
@@ -191,6 +204,15 @@ module Bitcoin
     def itb
       to_even_length_hex.htb
     end
+
+    # convert bit string
+    def to_bits(length = nil )
+      if length
+        to_s(2).rjust(length, '0')
+      else
+        to_s(2)
+      end
+    end
   end
 
   class ::ECDSA::Signature

data/lib/bitcoin/descriptor.rb

@@ -0,0 +1,147 @@
+module Bitcoin
+
+  module Descriptor
+
+    include Bitcoin::Opcodes
+
+    # generate P2PK output for the given public key.
+    # @param [String] key private key or public key with hex format
+    # @return [Bitcoin::Script] P2PK script.
+    def pk(key)
+      Bitcoin::Script.new << extract_pubkey(key) << OP_CHECKSIG
+    end
+
+    # generate P2PKH output for the given public key.
+    # @param [String] key private key or public key with hex format.
+    # @return [Bitcoin::Script] P2PKH script.
+    def pkh(key)
+      Bitcoin::Script.to_p2pkh(Bitcoin.hash160(extract_pubkey(key)))
+    end
+
+    # generate P2PKH output for the given public key.
+    # @param [String] key private key or public key with hex format.
+    # @return [Bitcoin::Script] P2WPKH script.
+    def wpkh(key)
+      pubkey = extract_pubkey(key)
+      raise ArgumentError, "Uncompressed key are not allowed." unless compressed_key?(pubkey)
+      Bitcoin::Script.to_p2wpkh(Bitcoin.hash160(pubkey))
+    end
+
+    # generate P2SH embed the argument.
+    # @param [String or Script] script script to be embed.
+    # @return [Bitcoin::Script] P2SH script.
+    def sh(script)
+      script = script.to_hex if script.is_a?(Bitcoin::Script)
+      raise ArgumentError, "P2SH script is too large, 547 bytes is larger than #{Bitcoin::MAX_SCRIPT_ELEMENT_SIZE} bytes." if script.htb.bytesize > Bitcoin::MAX_SCRIPT_ELEMENT_SIZE
+      Bitcoin::Script.to_p2sh(Bitcoin.hash160(script))
+    end
+
+    # generate P2WSH embed the argument.
+    # @param [String or Script] script script to be embed.
+    # @return [Bitcoin::Script] P2WSH script.
+    def wsh(script)
+      script = Bitcoin::Script(script.htb) if script.is_a?(String)
+      raise ArgumentError, "P2SH script is too large, 547 bytes is larger than #{Bitcoin::MAX_SCRIPT_ELEMENT_SIZE} bytes." if script.to_payload.bytesize > Bitcoin::MAX_SCRIPT_ELEMENT_SIZE
+      raise ArgumentError, "Uncompressed key are not allowed." if script.get_pubkeys.any?{|p|!compressed_key?(p)}
+      Bitcoin::Script.to_p2wsh(script)
+    end
+
+    # an alias for the collection of `pk(KEY)` and `pkh(KEY)`.
+    # If the key is compressed, it also includes `wpkh(KEY)` and `sh(wpkh(KEY))`.
+    # @param [String] key private key or public key with hex format.
+    # @return [Array[Bitcoin::Script]]
+    def combo(key)
+      result = [pk(key), pkh(key)]
+      pubkey = extract_pubkey(key)
+      if compressed_key?(pubkey)
+        result << wpkh(key)
+        result << sh(result.last)
+      end
+      result
+    end
+
+    # generate multisig output for given keys.
+    # @param [Integer] threshold the threshold of multisig.
+    # @param [Array[String]] keys an array of keys.
+    # @return [Bitcoin::Script] multisig script.
+    def multi(threshold, *keys, sort: false)
+      raise ArgumentError, 'Multisig threshold is not valid.' unless threshold.is_a?(Integer)
+      raise ArgumentError, 'Multisig threshold cannot be 0, must be at least 1.' unless threshold > 0
+      raise ArgumentError, 'Multisig threshold cannot be larger than the number of keys.' if threshold > keys.size
+      raise ArgumentError, 'Multisig must have between 1 and 16 keys, inclusive.' if keys.size > 16
+      pubkeys = keys.map{|key| extract_pubkey(key) }
+      Bitcoin::Script.to_multisig_script(threshold, pubkeys, sort: sort)
+    end
+
+    # generate sorted multisig output for given keys.
+    # @param [Integer] threshold the threshold of multisig.
+    # @param [Array[String]] keys an array of keys.
+    # @return [Bitcoin::Script] multisig script.
+    def sortedmulti(threshold, *keys)
+      multi(threshold, *keys, sort: true)
+    end
+
+    private
+
+    # extract public key from KEY format.
+    # @param [String] key KEY string.
+    # @return [String] public key.
+    def extract_pubkey(key)
+      if key.start_with?('[') # BIP32 fingerprint
+        raise ArgumentError, 'Invalid key origin.' if key.count('[') > 1 || key.count(']') > 1
+        info = key[1...key.index(']')] # TODO
+        fingerprint, *paths = info.split('/')
+        raise ArgumentError, 'Fingerprint is not hex.' unless fingerprint.valid_hex?
+        raise ArgumentError, 'Fingerprint is not 4 bytes.' unless fingerprint.size == 8
+        key = key[(key.index(']') + 1)..-1]
+      else
+        raise ArgumentError, 'Invalid key origin.' if key.include?(']')
+      end
+
+      # check BIP32 derivation path
+      key, *paths = key.split('/')
+
+      if key.start_with?('xprv')
+        key = Bitcoin::ExtKey.from_base58(key)
+        key = derive_path(key, paths, true) if paths
+      elsif key.start_with?('xpub')
+        key = Bitcoin::ExtPubkey.from_base58(key)
+        key = derive_path(key, paths, false) if paths
+      else
+        begin
+          key = Bitcoin::Key.from_wif(key)
+        rescue ArgumentError
+          key_type =  compressed_key?(key) ? Bitcoin::Key::TYPES[:compressed] : Bitcoin::Key::TYPES[:uncompressed]
+          key = Bitcoin::Key.new(pubkey: key, key_type: key_type)
+        end
+      end
+      key = key.is_a?(Bitcoin::Key) ? key : key.key
+      raise ArgumentError, 'Invalid pubkey.' unless key.fully_valid_pubkey?
+      key.pubkey
+    end
+
+    def compressed_key?(key)
+      %w(02 03).include?(key[0..1]) && [key].pack("H*").bytesize == 33
+    end
+
+    def derive_path(key, paths, is_private)
+      paths.each do |path|
+        raise ArgumentError, 'xpub can not derive hardened key.' if !is_private && path.end_with?("'")
+        if is_private
+          hardened = path.end_with?("'")
+          path = hardened ? path[0..-2] : path
+          raise ArgumentError, 'Key path value is not a valid value.' unless path =~ /^[0-9]+$/
+          raise ArgumentError, 'Key path value is out of range.' if !hardened && path.to_i >= Bitcoin::HARDENED_THRESHOLD
+          key = key.derive(path.to_i, hardened)
+        else
+          raise ArgumentError, 'Key path value is not a valid value.' unless path =~ /^[0-9]+$/
+          raise ArgumentError, 'Key path value is out of range.' if path.to_i >= Bitcoin::HARDENED_THRESHOLD
+          key = key.derive(path.to_i)
+        end
+      end
+      key
+    end
+
+  end
+
+end

data/lib/bitcoin/key.rb

@@ -227,8 +227,12 @@ module Bitcoin
     # fully validate whether this is a valid public key (more expensive than IsValid())
     def fully_valid_pubkey?
       return false unless valid_pubkey?
-      point = ECDSA::Format::PointOctetString.decode(pubkey.htb, ECDSA::Group::Secp256k1)
-      ECDSA::Group::Secp256k1.valid_public_key?(point)
+      begin
+        point = ECDSA::Format::PointOctetString.decode(pubkey.htb, ECDSA::Group::Secp256k1)
+        ECDSA::Group::Secp256k1.valid_public_key?(point)
+      rescue ECDSA::Format::DecodeError
+        false
+      end
     end
 
     private

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,21 +60,6 @@ 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

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
@@ -164,12 +165,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/out_point.rb

@@ -6,11 +6,11 @@ module Bitcoin
     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 +19,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 +31,12 @@ 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
 
   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)