bitcoinrb 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3af358507bac7836acb65b028e77391acc664890
-  data.tar.gz: a9bcb5f19f17b9a2ecd1e5c0a43b3aa29c0329ec
+SHA256:
+  metadata.gz: 99f5168564a4d436b4a3a43ce30fc4cf0657f4feb0f96cfa57362de3a322846b
+  data.tar.gz: 0bf7749a29bfcebb5006a5a01f47dabeb766d98269476dfa75f2d524af6d6da2
 SHA512:
-  metadata.gz: 32e8a8c8d0a1a80ec3ffcfa373f41a5d0987d83da9616a568acb5f9982bcc25a91b406f2163242e6e45d43c0f956e47913d4a280c821cc7f724da7836192b235
-  data.tar.gz: b476e81be5caff178b14161f0873d770c91795d59b0e0b518fcc68b8f138b525c023002b3ab3846e5ae24a9b46d61eff3ff0a32fb1b37aea4386c08ade25296e
+  metadata.gz: c23353ea258a891d79fff2f91a0e8661f389dc6045ca0199955dfe3fb91cdb01be5dc857553c7073633c7f34f0603991f6761403f787aea9bf306586124ccea4
+  data.tar.gz: '0597bdd738e1ffc9b8189ec1aaf05245b2cc988bd4ce3a92ad35bf8182cfb3864b59209c7a4894cf0c6d10d5fabaf3a9f2e0da10c7afa25f595969274ca3f5e1'

data/.ruby-version

@@ -1 +1 @@
-2.4.1
+2.5.0

data/.travis.yml

@@ -2,6 +2,7 @@ language: ruby
 rvm:
   - 2.3.0
   - 2.4.1
+  - 2.5.0
 addons:
   apt:
     packages:

data/README.md

@@ -50,7 +50,46 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Chain selection
+
+The parameters of the blockchain are managed by `Bitcoin::ChainParams`. Switch chain parameters as follows:
+
+* mainnet
+
+```ruby
+Bitcoin.chain_params = :mainnet
+```
+
+This parameter is described in https://github.com/haw-itn/bitcoinrb/blob/master/lib/bitcoin/chainparams/mainnet.yml.
+
+* testnet
+
+```ruby
+Bitcoin.chain_params = :testnet
+```
+
+This parameter is described in https://github.com/haw-itn/bitcoinrb/blob/master/lib/bitcoin/chainparams/testnet.yml.
+
+* regtest
+
+```ruby
+Bitcoin.chain_params = :regtest
+```
+
+This parameter is described in https://github.com/haw-itn/bitcoinrb/blob/master/lib/bitcoin/chainparams/regtest.yml.
+
+#### Fork coin
+
+When using with fork coin, please specify the fork_id of the coin as follows.
+
+```ruby
+Bitcoin.chain_params.fork_id = 0 # 0 is bch fork id
+```
+
+Currently bitcoinrb supports only support and verification of transaction replay protection using `SIGHASH_FORK_ID`.
+For details of `SIGHASH_FORK_ID`, refer to the following.
+
+https://github.com/Bitcoin-UAHF/spec/blob/master/replay-protected-sighash.md
 
 ## Contributing
 

data/bitcoinrb.gemspec

@@ -32,6 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'eventmachine_httpserver'
   spec.add_runtime_dependency 'rest-client'
   spec.add_runtime_dependency 'iniparse'
+  spec.add_runtime_dependency 'siphash'
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/bitcoin/base58.rb

@@ -3,7 +3,6 @@ module Bitcoin
   # Base58Check encoding
   # https://en.bitcoin.it/wiki/Base58Check_encoding
   module Base58
-
     module_function
 
     ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
@@ -28,8 +27,7 @@ module Bitcoin
         raise ArgumentError, 'Value passed not a valid Base58 String.' if (char_index = ALPHABET.index(char)).nil?
         int_val += char_index * (SIZE**index)
       end
-      s = int_val.to_s(16)
-      s = (s.bytesize.odd? ? '0' + s : s)
+      s = int_val.to_even_length_hex
       s = '' if s == '00'
       leading_zero_bytes = (base58_val.match(/^([1]+)/) ? $1 : '').size
       s = ('00' * leading_zero_bytes) + s if leading_zero_bytes > 0
@@ -37,4 +35,4 @@ module Bitcoin
     end
 
   end
-end
+end

data/lib/bitcoin/bloom_filter.rb

@@ -0,0 +1,71 @@
+require "murmurhash3"
+module Bitcoin
+  class BloomFilter
+    LN2_SQUARED = 0.4804530139182014246671025263266649717305529515945455 # log(2) ** 2
+    LN2 = 0.6931471805599453094172321214581765680755001343602552 # log(2)
+
+    MAX_BLOOM_FILTER_SIZE = 36_000 # bytes
+    MAX_HASH_FUNCS = 50
+
+    attr_reader :hash_funcs, :tweak
+
+    # @param [Integer] elements_length the number of elements
+    # @param [Float] fp_rate the false positive rate chosen by the client
+    # @param [Integer] tweak A random value to add to the seed value in the hash function used by the bloom filter
+    def initialize(elements_length, fp_rate, tweak=0)
+      # The size S of the filter in bytes is given by (-1 / pow(log(2), 2) * N * log(P)) / 8
+      len = [[(-elements_length * Math.log(fp_rate) / (LN2_SQUARED * 8)).to_i, MAX_BLOOM_FILTER_SIZE].min, 1].max
+      @filter = Array.new(len, 0)
+      # The number of hash functions required is given by S * 8 / N * log(2)
+      @hash_funcs = [[(@filter.size * 8 * LN2 / elements_length).to_i, MAX_HASH_FUNCS].min, 1].max
+      @tweak = tweak
+    end
+
+    # @param [String] data The data element to add to the current filter.
+    def add(data)
+      return if full?
+      @hash_funcs.times do |i|
+        hash = to_hash(data, i)
+        set_bit(hash)
+      end
+    end
+
+    # Returns true if the given data matches the filter
+    # @param [String] data The data to check the current filter
+    # @return [Boolean] true if the given data matches the filter
+    def contains?(data)
+      return true if full?
+      @hash_funcs.times do |i|
+        hash = to_hash(data, i)
+        return false unless check_bit(hash)
+      end
+      true
+    end
+
+    def clear
+      @filter.fill(0)
+      @full = false
+    end
+
+    def to_a
+      @filter
+    end
+
+    private
+    def to_hash(data, i)
+      MurmurHash3::V32.str_hash(data, (i * 0xfba4c795 + @tweak) & 0xffffffff)  % (@filter.length * 8)
+    end
+
+    def set_bit(data)
+      @filter[data >> 3] |= (1 << (7 & data))
+    end
+
+    def check_bit(data)
+      @filter[data >> 3] & (1 << (7 & data)) != 0
+    end
+
+    def full?
+      @full |= @filter.all? {|byte| byte == 0xff}
+    end
+  end
+end

data/lib/bitcoin/chain_params.rb

@@ -26,6 +26,9 @@ module Bitcoin
     attr_reader :genesis
     attr_reader :bip44_coin_type
 
+    # fork coin id.
+    attr_accessor :fork_id
+
     # mainnet genesis
     def self.mainnet
       YAML.load(File.open("#{__dir__}/chainparams/mainnet.yml"))
@@ -60,6 +63,11 @@ module Bitcoin
       Bitcoin::Block.new(header)
     end
 
+    # whether fork coin.
+    def fork_chain?
+      !fork_id.nil?
+    end
+
   end
 
 end

data/lib/bitcoin/constants.rb

@@ -56,7 +56,7 @@ module Bitcoin
                                   SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
                                   SCRIPT_VERIFY_CHECKSEQUENCEVERIFY,
                                   SCRIPT_VERIFY_LOW_S,
-                                  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM]
+                                  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM].inject(SCRIPT_VERIFY_NONE){|flags, f| flags |= f}
 
   # for script
 
@@ -84,6 +84,13 @@ module Bitcoin
   # Signature hash types/flags
   SIGHASH_TYPE = { all: 1, none: 2, single: 3, anyonecanpay: 128 }
 
+  # SIGHASH_FORK_ID for replay protection of the fork coin
+  SIGHASH_FORK_ID = 0x40
+
+  # fork coin id.
+  FORK_ID_CASH = 0
+  FORK_ID_GOLD = 79
+
   # Maximum number length in bytes
   DEFAULT_MAX_NUM_SIZE = 4
 

data/lib/bitcoin/ext_key.rb

@@ -1,9 +1,5 @@
 module Bitcoin
 
-  def self.hmac_sha512(key, data)
-    OpenSSL::HMAC.digest(OpenSSL::Digest.new('SHA512'), key, data)
-  end
-
   # Integers modulo the order of the curve(secp256k1)
   CURVE_ORDER = 115792089237316195423570985008687907852837564279074904382605163141518161494337
 

data/lib/bitcoin/key.rb

@@ -1,3 +1,6 @@
+# Porting part of the code from bitcoin-ruby. see the license.
+# https://github.com/lian/bitcoin-ruby/blob/master/COPYING
+
 module Bitcoin
 
   # bitcoin key class
@@ -64,13 +67,10 @@ module Bitcoin
     end
 
     # sign +data+ with private key
+    # @param [String] data a data to be signed with binary format
+    # @return [String] signature data with binary format
     def sign(data)
-      sig = nil
-      until sig
-        signature = secp256k1_module.sign_data(data, priv_key)
-        sig = signature if Key.low_signature?(signature)
-      end
-      sig
+      secp256k1_module.sign_data(data, priv_key)
     end
 
     # verify signature using public key
@@ -78,7 +78,13 @@ module Bitcoin
     # @param [String] origin original message
     # @return [Boolean] verify result
     def verify(sig, origin)
-      secp256k1_module.verify_sig(origin, sig, pubkey)
+      return false unless valid_pubkey?
+      begin
+        sig = ecdsa_signature_parse_der_lax(sig)
+        secp256k1_module.verify_sig(origin, sig, pubkey)
+      rescue Exception
+        false
+      end
     end
 
     # get pay to pubkey hash address
@@ -209,6 +215,24 @@ module Bitcoin
       MIN_PRIV_KEy_MOD_ORDER <= value && value <= MAX_PRIV_KEY_MOD_ORDER
     end
 
+    # Supported violations include negative integers, excessive padding, garbage
+    # at the end, and overly long length descriptors. This is safe to use in
+    # Bitcoin because since the activation of BIP66, signatures are verified to be
+    # strict DER before being passed to this module, and we know it supports all
+    # violations present in the blockchain before that point.
+    def ecdsa_signature_parse_der_lax(sig)
+      sig_array = sig.unpack('C*')
+      len_r = sig_array[3]
+      r = sig_array[4...(len_r+4)].pack('C*').bth
+      len_s = sig_array[len_r + 5]
+      s = sig_array[(len_r + 6)...(len_r + 6 + len_s)].pack('C*').bth
+      ECDSA::Format::SignatureDerString.encode(ECDSA::Signature.new(r.to_i(16), s.to_i(16)))
+    end
+
+    def valid_pubkey?
+      !pubkey.nil? && pubkey.size > 0
+    end
+
   end
 
 end

data/lib/bitcoin/message/block_transaction_request.rb

@@ -0,0 +1,45 @@
+module Bitcoin
+  module Message
+
+    # BIP-152 Compact Block's data format.
+    # https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki#BlockTransactionsRequest
+    class BlockTransactionRequest
+
+      attr_accessor :block_hash # When matching with Bitcoin::BlockHeader#hash It is necessary to reverse the byte order.
+      attr_accessor :indexes
+
+      def initialize(block_hash, indexes)
+        @block_hash = block_hash
+        @indexes = indexes
+      end
+
+      def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        block_hash = buf.read(32).bth
+        index_len = Bitcoin.unpack_var_int_from_io(buf)
+        indexes = index_len.times.map{Bitcoin.unpack_var_int_from_io(buf)}
+        # index data differentially encoded
+        offset = 0
+        index_len.times do |i|
+          index = indexes[i]
+          index += offset
+          indexes[i] = index
+          offset = index + 1
+        end
+        self.new(block_hash, indexes)
+      end
+
+      def to_payload
+        p = block_hash.htb << Bitcoin.pack_var_int(indexes.size)
+        indexes.size.times do |i|
+          index = indexes[i]
+          index -= indexes[i-1] + 1 if i > 0
+          p << Bitcoin.pack_var_int(index)
+        end
+        p
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/block_transactions.rb

@@ -0,0 +1,31 @@
+module Bitcoin
+  module Message
+
+    # BIP-152 Compact Block's data format.
+    # https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki#BlockTransactions
+    class BlockTransactions
+
+      attr_accessor :block_hash
+      attr_accessor :transactions
+
+      def initialize(block_hash, transactions)
+        @block_hash = block_hash
+        @transactions = transactions
+      end
+
+      def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        block_hash = buf.read(32).bth
+        tx_count = Bitcoin.unpack_var_int_from_io(buf)
+        txn = tx_count.times.map{Bitcoin::Tx.parse_from_payload(buf)}
+        self.new(block_hash, txn)
+      end
+
+      def to_payload
+        block_hash.htb << Bitcoin.pack_var_int(transactions.size) << transactions.map(&:to_payload).join
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/block_txn.rb

@@ -0,0 +1,27 @@
+module Bitcoin
+  module Message
+
+    # blocktxn message.
+    # https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki#blocktxn
+    class BlockTxn < Base
+
+      COMMAND = 'blocktxn'
+
+      attr_accessor :block_transactions
+
+      def initialize(block_transactions)
+        @block_transactions = block_transactions
+      end
+
+      def self.parse_from_payload(payload)
+        self.new(BlockTransactions.parse_from_payload(payload))
+      end
+
+      def to_payload
+        block_transactions.to_payload
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/cmpct_block.rb

@@ -0,0 +1,42 @@
+module Bitcoin
+  module Message
+
+    # cmpctblock message
+    # https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki
+    class CmpctBlock < Base
+
+      COMMAND = 'cmpctblock'
+
+      attr_accessor :header_and_short_ids
+
+      def initialize(header_and_short_ids)
+        @header_and_short_ids = header_and_short_ids
+      end
+
+      # generate CmpctBlock from Block data.
+      # @param [Bitcoin::Block] block the block to generate CmpctBlock.
+      # @param [Integer] version Compact Block version specified by sendcmpct message.
+      # @param [Integer] nonce
+      # @return [Bitcoin::Message::CmpctBlock]
+      def self.from_block(block, version, nonce = SecureRandom.hex(8).to_i(16))
+        raise 'Unsupported version.' unless [1, 2].include?(version)
+        h = HeaderAndShortIDs.new(block.header, nonce)
+        block.transactions[1..-1].each do |tx|
+          h.short_ids << h.short_id(version == 1 ? tx.txid : tx.wtxid)
+        end
+        h.prefilled_txn << PrefilledTx.new(0, block.transactions.first)
+        self.new(h)
+      end
+
+      def self.parse_from_payload(payload)
+        self.new(HeaderAndShortIDs.parse_from_payload(payload))
+      end
+
+      def to_payload
+        header_and_short_ids.to_payload
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/get_block_txn.rb

@@ -0,0 +1,27 @@
+module Bitcoin
+  module Message
+
+    # getblocktxn message.
+    # https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki
+    class GetBlockTxn < Base
+
+      COMMAND = 'getblocktxn'
+
+      attr_accessor :request
+
+      def initialize(request)
+        @request = request
+      end
+
+      def self.parse_from_payload(payload)
+        self.new(BlockTransactionRequest.parse_from_payload(payload))
+      end
+
+      def to_payload
+        request.to_payload
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/header_and_short_ids.rb

@@ -0,0 +1,57 @@
+require 'siphash'
+module Bitcoin
+  module Message
+
+    # BIP-152 Compact Block's data format.
+    # https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki#HeaderAndShortIDs
+    class HeaderAndShortIDs
+      attr_accessor :header
+      attr_accessor :nonce
+      attr_accessor :short_ids
+      attr_accessor :prefilled_txn
+      attr_accessor :siphash_key
+
+      def initialize(header, nonce, short_ids = [], prefilled_txn = [])
+        @header = header
+        @nonce = nonce
+        @short_ids = short_ids
+        @prefilled_txn = prefilled_txn
+        @siphash_key = Bitcoin.sha256(header.to_payload << [nonce].pack('q*'))[0...16]
+      end
+
+      def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        header = Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
+        nonce = buf.read(8).unpack('q*').first
+        short_ids_len = Bitcoin.unpack_var_int_from_io(buf)
+        short_ids = short_ids_len.times.map do
+           buf.read(6).reverse.bth.to_i(16)
+        end
+        prefilled_txn_len = Bitcoin.unpack_var_int_from_io(buf)
+        prefilled_txn = prefilled_txn_len.times.map do
+          PrefilledTx.parse_from_io(buf)
+        end
+        self.new(header, nonce, short_ids, prefilled_txn)
+      end
+
+      def to_payload
+        p = header.to_payload
+        p << [nonce].pack('q*')
+        p << Bitcoin.pack_var_int(short_ids.size)
+        p << short_ids.map{|id|sprintf('%12x', id).htb.reverse}.join
+        p << Bitcoin.pack_var_int(prefilled_txn.size)
+        p << prefilled_txn.map(&:to_payload).join
+        p
+      end
+
+      # calculate short transaction id which specified by BIP-152.
+      # @param [String] txid a transaction id
+      # @return [Integer] 6 bytes short transaction id.
+      def short_id(txid)
+        hash = SipHash.digest(siphash_key, txid.htb.reverse).to_even_length_hex
+        [hash].pack('H*')[2...8].bth.to_i(16)
+      end
+
+    end
+  end
+end

data/lib/bitcoin/message/prefilled_tx.rb

@@ -0,0 +1,29 @@
+module Bitcoin
+  module Message
+
+    # A PrefilledTransaction structure is used in HeaderAndShortIDs to provide a list of a few transactions explicitly.
+    # https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki
+    class PrefilledTx
+
+      attr_accessor :index
+      attr_accessor :tx
+
+      def initialize(index, tx)
+        @index = index
+        @tx = tx
+      end
+
+      def self.parse_from_io(io)
+        index = Bitcoin.unpack_var_int_from_io(io)
+        tx = Bitcoin::Tx.parse_from_payload(io)
+        self.new(index, tx)
+      end
+
+      def to_payload
+        Bitcoin.pack_var_int(index) << tx.to_payload
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/send_cmpct.rb

@@ -14,7 +14,7 @@ module Bitcoin
       attr_accessor :version
       # TODO support version 2
 
-      def initialize(mode, version)
+      def initialize(mode = MODE_HIGH, version = 1)
         @mode = mode
         @version = version
       end

data/lib/bitcoin/message/version.rb

@@ -27,8 +27,8 @@ module Bitcoin
         @nonce = SecureRandom.random_number(0xffffffffffffffff)
         @user_agent = Bitcoin::Message::USER_AGENT
         @start_height = 0
-        @relay = true
         opts.each { |k, v| send "#{k}=", v }
+        @relay = opts[:relay] || false
       end
 
       def self.parse_from_payload(payload)

data/lib/bitcoin/message.rb

@@ -30,6 +30,13 @@ module Bitcoin
     autoload :Error, 'bitcoin/message/error'
     autoload :Reject, 'bitcoin/message/reject'
     autoload :SendCmpct, 'bitcoin/message/send_cmpct'
+    autoload :CmpctBlock, 'bitcoin/message/cmpct_block'
+    autoload :HeaderAndShortIDs, 'bitcoin/message/header_and_short_ids'
+    autoload :PrefilledTx, 'bitcoin/message/prefilled_tx'
+    autoload :GetBlockTxn, 'bitcoin/message/get_block_txn'
+    autoload :BlockTransactionRequest, 'bitcoin/message/block_transaction_request'
+    autoload :BlockTxn, 'bitcoin/message/block_txn'
+    autoload :BlockTransactions, 'bitcoin/message/block_transactions'
 
     USER_AGENT = "/bitcoinrb:#{Bitcoin::VERSION}/"
 

data/lib/bitcoin/network/message_handler.rb

@@ -92,8 +92,10 @@ module Bitcoin
             on_inv(Bitcoin::Message::Inv.parse_from_payload(payload))
           when Bitcoin::Message::MerkleBlock::COMMAND
             on_merkle_block(Bitcoin::Message::MerkleBlock.parse_from_payload(payload))
+          when Bitcoin::Message::CmpctBlock::COMMAND
+            on_cmpct_block(Bitcoin::Message::CmpctBlock.parse_from_payload(payload))
           else
-            logger.warn("unsupported command received. #{command}")
+            logger.warn("unsupported command received. command: #{command}, payload: #{payload.bth}")
             close("with command #{command}")
         end
       end
@@ -224,6 +226,10 @@ module Bitcoin
         logger.info("receive merkle block message. #{merkle_block.build_json}")
       end
 
+      def on_cmpct_block(cmpct_block)
+        logger.info("receive cmpct_block message. #{cmpct_block.build_json}")
+      end
+
     end
   end
 end

data/lib/bitcoin/network/peer.rb

@@ -5,7 +5,7 @@ module Bitcoin
     class Peer
 
       # Interval for pinging peers.
-      PING_INTERVAL = 30
+      PING_INTERVAL = 2 * 60
 
       attr_reader :logger
       attr_accessor :id
@@ -34,7 +34,7 @@ module Bitcoin
       attr_reader :chain
       attr_accessor :fee_rate
 
-      def initialize(host, port, pool)
+      def initialize(host, port, pool, configuration)
         @host = host
         @port = port
         @pool = pool
@@ -48,8 +48,9 @@ module Bitcoin
         @min_ping = -1
         @bytes_sent = 0
         @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)
+        @local_version = Bitcoin::Message::Version.new(remote_addr: addr, start_height: current_height, relay: @relay)
       end
 
       def connect
@@ -186,7 +187,28 @@ module Bitcoin
         conn.send_message(ping)
       end
 
-    end
+      # send filterload message.
+      def send_filter_load(bloom)
+        filter_load = Bitcoin::Message::FilterLoad.new(
+          bloom.to_a,
+          bloom.hash_funcs,
+          bloom.tweak,
+          Bitcoin::Message::FilterLoad::BLOOM_UPDATE_ALL
+        )
+        conn.send_message(filter_load)
+      end
+
+      # send filteradd message.
+      def send_filter_add(element)
+        filter_add = Bitcoin::Message::FilterAdd.new(element)
+        conn.send_message(filter_add)
+      end
 
+      # send filterclear message.
+      def send_filter_clear
+        filter_clear = Bitcoin::Message::FilterClear.new
+        conn.send_message(filter_clear)
+      end
+    end
   end
 end