bitcoin-ruby 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bacd4496251a558a0f1eac2b07a9760db13dde1
-  data.tar.gz: dd2be23dff65df8f413edc45e10b5c8c1dc12743
+  metadata.gz: 392936a305872b186484815f8a1c6c91725029d1
+  data.tar.gz: f44d55252bf1c614e5679b80113cfd59ca94815e
 SHA512:
-  metadata.gz: 429192b346b5c1e9b022787b4b0b9b3201791cba0981aece83092cbbb8297c19a40f0bb7d686c6011cab84d0219e914e5f76e8c8af5fb7512f8b4f3ddbf1b9ed
-  data.tar.gz: b66dc9ce517c43952554e7eed44dd38d2b96931db305cce6c08e4a742ff5669136e0fd557287e8cce519ed410c60376ea5862b1e9a4592c55778b52324dca2b7
+  metadata.gz: 2dab50ef851a4ba5a202099052ce566f86416cfdad002289668d76d109cdc32298fb0f3f99713522dee1d1dfa4bbac0335db3a9f4dd15b53bd7b9daaed9fc633
+  data.tar.gz: 06b920e486a56d4c22ad20ac2da62f2d3c89da1a60f561c01e82bf7cf953bc8db9e70bed8de2e01b1517843c72132fe9cc68403624b897bbcbc2cf3845baee86

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
-  - 2.2.0
-  - 2.3.2
-  - 2.4.1
+  - 2.2.9
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (c) 2017 Julian Langschaedel <meta.rb@gmail.com>
+Copyright (c) 2018 Julian Langschaedel <meta.rb@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bitcoin-ruby (0.0.14)
+    bitcoin-ruby (0.0.15)
 
 GEM
   remote: https://rubygems.org/

data/README.rdoc

@@ -4,22 +4,13 @@ This is a ruby library for interacting with the bitcoin protocol/network.
 
 Some of the main features are:
 
+* Bitcoin::Key provides a high-level API for creating and handling keys/addresses
 * Bitcoin::Util provides the basic bitcoin utility functions for base58, ECC, etc.
 * Bitcoin::Protocol can parse/create all protocol messages
 * Bitcoin::Script implementation, create/run scripts and verify signatures
-* Bitcoin::Key provides a high-level API for creating and handling keys/addresses
 * Bitcoin::Builder provides a high-level API for creating transactions (and blocks)
 * Bitcoin::Litecoin implements all the litecoin-specific differences
 
-== Related Projects
-
-* toshi[https://github.com/coinbase/toshi]
-* bitcoin-ruby-blockchain[http://github.com/mhanne/bitcoin-ruby-blockchain]
-* bitcoin-ruby-node[http://github.com/mhanne/bitcoin-ruby-node]
-* bitcoin-ruby-wallet[http://github.com/mhanne/bitcoin-ruby-wallet]
-* bitcoin-ruby-gui[http://github.com/mhanne/bitcoin-ruby-gui]
-* namecoin-ruby[http://github.com/mhanne/namecoin-ruby]
-
 == Compatible with...
 
 * ruby 1.9.3
@@ -30,13 +21,9 @@ Some of the main features are:
 
 == Installation
 
-We assume you already have a ruby 1.9 or 2.0 compatible interpreter and rubygems environment.
-
- git clone https://github.com/lian/bitcoin-ruby.git; cd bitcoin-ruby
-
-if you want to have it available system-wide, just build the gem and install it:
-
- gem build bitcoin-ruby.gemspec && gem install bitcoin-ruby-0.0.11.gem
+ gem install bitcoin-ruby
+ # OR
+ git clone https://github.com/lian/bitcoin-ruby.git; cd bitcoin-ruby; bundle install
 
 Note that some aspects of the library (such as networking, storage, etc.) need
 additional dependencies which are not specified in the gemspec. The core requirements are
@@ -58,18 +45,13 @@ see EXAMPLES.
 
 Generate a Bitcoin::Key
 
- key = Bitcoin::generate_key
- key #=> [<privkey>, <pubkey>]
-
-Get the address from a public key
-
- address = Bitcoin::pubkey_to_address(key[1])
- address #=> <bitcoin address>
-
-Check if an address is valid
-
- Bitcoin::valid_address?(address) #=> true
-
+ key = Bitcoin::Key.generate
+ key.priv
+ key.pub
+ key.addr
+ sig = key.sign("data")
+ key.verify("data", sig)
+ recovered_key = Bitcoin::Key.from_base58(key.to_base58)
 
 === Blocks / Transactions parsing
 

data/lib/bitcoin.rb

@@ -8,6 +8,7 @@ require 'securerandom'
 
 module Bitcoin
 
+  autoload :Bech32,     'bitcoin/bech32'
   autoload :Connection, 'bitcoin/connection'
   autoload :Protocol,   'bitcoin/protocol'
   autoload :P,          'bitcoin/protocol'
@@ -58,10 +59,7 @@ module Bitcoin
     # check if given +address+ is valid.
     # this means having a correct version byte, length and checksum.
     def valid_address?(address)
-      hex = decode_base58(address) rescue nil
-      return false unless hex && hex.bytesize == 50
-      return false unless [address_version, p2sh_version].include?(hex[0...2])
-      address_checksum?(address)
+      address_type(address) != nil
     end
 
     # check if given +pubkey+ is valid.
@@ -74,17 +72,42 @@ module Bitcoin
 
     # get hash160 for given +address+. returns nil if address is invalid.
     def hash160_from_address(address)
-      return nil  unless valid_address?(address)
-      decode_base58(address)[2...42]
+      case address_type(address)
+      when :witness_v0_keyhash
+        _, witness_program_hex = decode_segwit_address(address)
+        witness_program_hex
+      when :hash160, :p2sh
+        decode_base58(address)[2...42]
+      end
     end
 
     # get type of given +address+.
     def address_type(address)
-      return nil unless valid_address?(address)
-      case decode_base58(address)[0...2]
-      when address_version; :hash160
-      when p2sh_version;    :p2sh
+      segwit_decoded = decode_segwit_address(address)
+      if segwit_decoded
+        witness_version, witness_program_hex = segwit_decoded
+        witness_program = [witness_program_hex].pack("H*")
+
+        if witness_version == 0 && witness_program.bytesize == 20
+          return :witness_v0_keyhash
+        end
+
+        if witness_version == 0 && witness_program.bytesize == 32
+          return :witness_v0_scripthash
+        end
+      end
+
+      hex = decode_base58(address) rescue nil
+      if hex && hex.bytesize == 50 && address_checksum?(address)
+        case hex[0...2]
+        when address_version
+          return :hash160
+        when p2sh_version
+          return :p2sh
+        end
       end
+
+      nil
     end
 
     def sha256(hex)
@@ -113,6 +136,49 @@ module Bitcoin
       return Bitcoin.hash160_to_p2sh_address(Bitcoin.hash160(redeem_script.hth)), redeem_script
     end
 
+
+    def encode_segwit_address(version, program_hex)
+      hrp = Bitcoin.network[:bech32_hrp]
+      raise "Invalid network" if hrp.nil?
+
+      program = [program_hex].pack("H*")
+
+      return nil if version > 16
+      length = program.size
+      return nil if version == 0 && length != 20 && length != 32
+      return nil if length < 2 || length > 40
+
+      data = [ version ] + Bitcoin::Bech32.convert_bits(program.unpack("C*"), from_bits: 8, to_bits: 5, pad: true)
+
+      address = Bitcoin::Bech32.encode(hrp, data)
+
+      return address.nil? ? nil : address
+    end
+
+    def decode_segwit_address(address)
+      hrp = Bitcoin.network[:bech32_hrp]
+      return nil if hrp.nil?
+
+      actual_hrp, data  = Bitcoin::Bech32.decode(address)
+
+      return nil if actual_hrp.nil?
+      length = data.size
+      return nil if length == 0 || length > 65
+      return nil if hrp != actual_hrp
+      return nil if data[0] > 16
+
+
+      program = Bitcoin::Bech32.convert_bits(data[1..-1], from_bits: 5, to_bits: 8, pad: false)
+      return nil if program.nil?
+
+      length = program.size
+      return nil if length < 2 || length > 40
+      return nil if data[0] == 0 && length != 20 && length != 32
+
+      program_hex = program.pack("C*").unpack("H*").first
+      return [data[0], program_hex]
+    end
+
     def int_to_base58(int_val, leading_zero_bytes=0)
       alpha = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
       base58_val, base = '', alpha.size
@@ -439,7 +505,6 @@ module Bitcoin
 
   extend Util
 
-
   module  BinaryExtensions
     # bin-to-hex
     def bth; unpack("H*")[0]; end
@@ -557,6 +622,7 @@ module Bitcoin
       privkey_version: "80",
       extended_privkey_version: "0488ade4",
       extended_pubkey_version: "0488b21e",
+      bech32_hrp: "bc",
       default_port: 8333,
       protocol_version: 70001,
       coinbase_maturity: 100,
@@ -614,6 +680,7 @@ module Bitcoin
       privkey_version: "ef",
       extended_privkey_version: "04358394",
       extended_pubkey_version: "043587cf",
+      bech32_hrp: "tb",
       default_port: 18333,
       bip34_height: 21111,
       dns_seeds: [ ],
@@ -625,6 +692,7 @@ module Bitcoin
     })
 
   NETWORKS[:regtest] = NETWORKS[:testnet].merge({
+      bech32_hrp: "bcrt",
       default_port: 18444,
       genesis_hash: "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
       proof_of_work_limit: 0x207fffff,
@@ -660,6 +728,7 @@ module Bitcoin
       address_version: "30",
       p2sh_version: "32",
       privkey_version: "b0",
+      bech32_hrp: "ltc",
       extended_privkey_version: "019d9cfe",
       extended_pubkey_version: "019da462",
       default_port: 9333,
@@ -710,6 +779,7 @@ module Bitcoin
       address_version: "6f",
       p2sh_version: "3a",
       privkey_version: "ef",
+      bech32_hrp: "tltc",
       extended_privkey_version: "0436ef7d",
       extended_pubkey_version: "0436f6e1",
       default_port: 19335,
@@ -733,6 +803,7 @@ module Bitcoin
       address_version: "1e",
       p2sh_version: "16",
       privkey_version: "9e",
+      bech32_hrp: nil,
       extended_privkey_version: "02fac398",
       extended_pubkey_version: "02facafd",
       default_port: 22556,
@@ -835,6 +906,7 @@ module Bitcoin
       project: :namecoin,
       magic_head: "\xF9\xBE\xB4\xFE",
       address_version: "34",
+      bech32_hrp: nil,
       default_port: 8334,
       protocol_version: 35000,
       min_tx_fee: 50_000,

data/lib/bitcoin/bech32.rb

@@ -0,0 +1,172 @@
+# encoding: ascii-8bit
+# Ruby reference implementation: https://github.com/sipa/bech32/tree/master/ref/c
+module Bitcoin; end
+module Bitcoin::Bech32
+
+  CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l".unpack("C*")
+  CHARSET_REV = [
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    15, -1, 10, 17, 21, 20, 26, 30,  7,  5, -1, -1, -1, -1, -1, -1,
+    -1, 29, -1, 24, 13, 25,  9,  8, 23, -1, 18, 22, 31, 27, 19, -1,
+     1,  0,  3, 16, 11, 28, 12, 14,  6,  4,  2, -1, -1, -1, -1, -1,
+    -1, 29, -1, 24, 13, 25,  9,  8, 23, -1, 18, 22, 31, 27, 19, -1,
+     1,  0,  3, 16, 11, 28, 12, 14,  6,  4,  2, -1, -1, -1, -1, -1
+  ]
+
+  class << self
+
+    def polymod_step(pre)
+      b = pre >> 25
+      return ((pre & 0x1FFFFFF) << 5) ^ \
+          (-((b >> 0) & 1) & 0x3b6a57b2) ^ \
+          (-((b >> 1) & 1) & 0x26508e6d) ^ \
+          (-((b >> 2) & 1) & 0x1ea119fa) ^ \
+          (-((b >> 3) & 1) & 0x3d4233dd) ^ \
+          (-((b >> 4) & 1) & 0x2a1462b3)
+    end
+
+    def encode(hrp, data)
+      buf = []
+      chk = 1
+
+      hrp.unpack("C*").each do |ch|
+        return nil if ch < 33 || ch > 126
+        return nil if ch >= 'A'.ord && ch <= 'Z'.ord
+        chk = polymod_step(chk) ^ (ch >> 5)
+      end
+
+      return nil if (hrp.bytesize + 7 + data.size) > 90
+
+      chk = polymod_step(chk)
+      hrp.unpack("C*").each do |ch|
+        chk = polymod_step(chk) ^ (ch & 0x1f)
+        buf << ch
+      end
+
+      buf << '1'.ord
+
+      data.each do |i|
+        return nil if (i >> 5) != 0
+        chk = polymod_step(chk) ^ i
+        buf << CHARSET[i]
+      end
+
+      6.times do |n|
+        chk = polymod_step(chk)
+      end
+
+      chk ^= 1
+
+      6.times do |i|
+        buf << CHARSET[(chk >> ((5 - i) * 5)) & 0x1f]
+      end
+
+      return buf.pack("C*")
+    end
+
+    def decode(input)
+      chk = 1
+      input_len = input.bytesize
+      have_lower, have_upper = false, false
+
+      return nil if input_len < 8 || input_len > 90
+
+      data_len = 0
+      while data_len < input_len && input[(input_len - 1) - data_len] != '1' do
+        data_len += 1
+      end
+
+      hrp_len = input_len - (1 + data_len)
+      return nil if hrp_len < 1 || data_len < 6
+
+      data_len -= 6
+
+      hrp = []
+      hrp_len.times do |i|
+        ch = input[i].ord
+        return nil if ch < 33 || ch > 126
+
+        if ch >= 'a'.ord && ch <= 'z'.ord
+          have_lower = true
+        elsif ch >= 'A'.ord && ch <= 'Z'.ord
+          have_upper = true
+          ch = (ch - 'A'.ord) + 'a'.ord
+        end
+
+        hrp << ch
+        chk = polymod_step(chk) ^ (ch >> 5)
+      end
+
+      chk = polymod_step(chk)
+
+      hrp_len.times do |i|
+        chk = polymod_step(chk) ^ (input[i].ord & 0x1f)
+      end
+
+      data = []
+      i = hrp_len + 1
+      while i < input_len do
+        ch = input[i].ord
+        v = ((ch & 0x80) != 0) ? -1 : CHARSET_REV[ch]
+
+        have_lower = true if ch >= 'a'.ord && ch <= 'z'.ord
+        have_upper = true if ch >= 'A'.ord && ch <= 'Z'.ord
+        return nil if v == -1
+
+        chk = polymod_step(chk) ^ v
+        if (i + 6) < input_len
+          data << v
+        end
+        i += 1
+      end
+
+      return nil if have_lower && have_upper
+      return nil if chk != 1
+
+      return [hrp.pack("C*"), data]
+    end
+
+    # Utility for converting bytes of data between bases. These is used for
+    # BIP 173 address encoding/decoding to convert between sequences of bytes
+    # representing 8-bit values and groups of 5 bits. Conversions may be padded
+    # with trailing 0 bits to the nearest byte boundary. Returns nil if
+    # conversion requires padding and pad is false.
+    #
+    # For example:
+    #
+    #   convert_bits("\xFF\xFF", from_bits: 8, to_bits: 5, pad: true)
+    #     => "\x1F\x1F\x1F\10"
+    #
+    # See https://github.com/bitcoin/bitcoin/blob/595a7bab23bc21049526229054ea1fff1a29c0bf/src/utilstrencodings.h#L154
+    def convert_bits(chunks, from_bits:, to_bits:, pad:)
+      output_mask = (1 << to_bits) - 1
+      buffer_mask = (1 << (from_bits + to_bits - 1)) - 1
+
+      buffer = 0
+      bits = 0
+
+      output = []
+      chunks.each do |chunk|
+        buffer = ((buffer << from_bits) | chunk) & buffer_mask
+        bits += from_bits
+        while bits >= to_bits
+          bits -= to_bits
+          output << ((buffer >> bits) & output_mask)
+        end
+      end
+
+      if pad && bits > 0
+        output << ((buffer << (to_bits - bits)) & output_mask)
+      end
+
+      if !pad && (bits >= from_bits || ((buffer << (to_bits - bits)) & output_mask) != 0)
+        return nil
+      end
+
+      output
+    end
+
+  end
+end