bitcoinrb 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f552597dfd50a5df7cee6e6c29c10789afbbe5e78ad316af9833f25e99f15e76
-  data.tar.gz: 9044c1daafb7c4badee574cdd326a922354b64376b9b871da3b2f5ad6a8aa4e6
+  metadata.gz: 895222030c0d0673f1524e112cf42d8cbb8e248558ba356e156a92b7482d4344
+  data.tar.gz: cca9f6a8777925fcf39c47a835549b1894554e2d3c67400ba330487731677a89
 SHA512:
-  metadata.gz: '09d270868f51f4a08af65dbedce68d87d1863bb8f82dbf32c8999eb40bad432910325d5d17efc7c8d23f2f0398614cca8d4852dd3a52bd232ab0576bb0e7ee61'
-  data.tar.gz: 0b958912e698973c4e1b4af4f9737a046b3d07566064bdd759ec7fa4c336a33861ec060a90f7bc9181c5a8a7f6fe91240359232ee0cefbcfc799580f59e861e5
+  metadata.gz: cbb089fdfa71ac6a9c60591789c18b78af3fac81e6ba82ac264a50cd1d464b814f8989ca62fdde78910640e241f2b7e8c516b20b9e67eb979efae86c43b9b0ab
+  data.tar.gz: bf0b6f27f6e4819569f3d814194b202f18d829bf315591ce8fa75db0846b2ef372ca45294537918ff7d161b37947f91be05562200d7028bc39b598ec83f01b26

data/.ruby-version

@@ -1 +1 @@
-2.5.3
+2.6.0

data/.travis.yml

@@ -3,6 +3,7 @@ rvm:
   - 2.3.8
   - 2.4.5
   - 2.5.3
+  - 2.6.0
 addons:
   apt:
     packages:

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017-2018 HAW International, Inc. / chaintope, Inc.
+Copyright (c) 2017-2019 HAW International, Inc. / chaintope, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -13,7 +13,9 @@ Bitcoinrb supports following feature:
 * De/serialization of Bitcoin protocol network messages
 * De/serialization of blocks and transactions
 * Key generation and verification for ECDSA, including [BIP-32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) and [BIP-39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) supports.
+* ECDSA signature(RFC6979 -Deterministic ECDSA, LOW-S, LOW-R support)
 * Segwit support (parsing segwit payload, Bech32 address, sign for segwit tx, etc..)
+* PSBT(Partially Signed Bitcoin Transaction) support
 * [WIP] SPV node
 * [WIP] 0ff-chain protocol
 

data/lib/bitcoin.rb

@@ -47,6 +47,10 @@ module Bitcoin
   autoload :BloomFilter, 'bitcoin/bloom_filter'
   autoload :Payments, 'bitcoin/payments'
   autoload :PSBT, 'bitcoin/psbt'
+  autoload :GCSFilter, 'bitcoin/gcs_filter'
+  autoload :BlockFilter, 'bitcoin/block_filter'
+  autoload :BitStreamWriter, 'bitcoin/bit_stream'
+  autoload :BitStreamReader, 'bitcoin/bit_stream'
 
   require_relative 'bitcoin/constants'
 

data/lib/bitcoin/bit_stream.rb

@@ -0,0 +1,71 @@
+module Bitcoin
+
+  class BitStreamWriter
+
+    MAX_BIT = 2**64
+
+    attr_reader :stream
+    attr_accessor :buffer
+    attr_accessor :offset
+
+    def initialize
+      @stream = ''
+      @buffer = 0
+      @offset = 0
+    end
+
+    def write(data, nbits)
+      raise "nbits must be between 0 and 64" if nbits < 0 || nbits > 64
+      while nbits > 0
+        bits = [8 - offset, nbits].min
+        tmp = (data << (64 - nbits)) & 0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111
+        self.buffer |= (tmp >> (64 - 8 + offset))
+        self.offset += bits
+        nbits -= bits
+        flush if offset == 8
+      end
+    end
+
+    def flush
+      return if offset == 0
+      self.stream << [buffer.to_even_length_hex].pack('H*')
+      self.offset = 0
+      self.buffer = 0
+    end
+
+  end
+
+  class BitStreamReader
+
+    attr_reader :stream
+    attr_accessor :buffer
+    attr_accessor :offset
+
+    def initialize(payload)
+      @offset = 8
+      @buffer = 0
+      @stream = StringIO.new(payload)
+    end
+
+    # offset
+    def read(nbits)
+      raise 'nbits must be between 0 and 64' if nbits < 0 || nbits > 64
+      data = 0
+      while nbits > 0
+        if offset == 8
+          self.buffer = stream.read(1).bth.to_i(16)
+          self.offset = 0
+        end
+        bits = [8 - offset, nbits].min
+        data <<= bits
+        tmp = (buffer << offset) & 255
+        data = data | (tmp >> (8 - bits))
+        self.offset += bits
+        nbits -= bits
+      end
+      data
+    end
+
+  end
+
+end

data/lib/bitcoin/block_filter.rb

@@ -0,0 +1,83 @@
+module Bitcoin
+
+  # Compact Block Filter
+  # https://github.com/bitcoin/bips/blob/master/bip-0158.mediawiki
+  # This implementation ported the implementation of Bitcoin Core's blockfilter.cpp.
+  # https://github.com/bitcoin/bitcoin/blob/master/src/blockfilter.cpp
+  class BlockFilter
+
+    TYPE = {basic: 0}
+
+    # basic filter params
+    BASIC_FILTER_P = 19
+    BASIC_FILTER_M = 784931
+
+    attr_accessor :filter_type
+    attr_accessor :filter
+    attr_accessor :block_hash
+
+    # Constructor
+    # @param [Integer] filter_type
+    # @param [Bitcoin::GCSFilter] filter a GCS filter.
+    # @param [String] block_hash a block hash with hex format.
+    # @return [Bitcoin::BlockFilter]
+    def initialize(filter_type, filter, block_hash)
+      @filter_type = filter_type
+      @filter = filter
+      @block_hash = block_hash
+    end
+
+    # Build BlockFilter from the block data.
+    # @param [Integer] filter_type a filter type(basic or extended).
+    # @param [Bitcoin::Block] block target block object.
+    # @param [Array[Bitcoin::Script]] prev_out_scripts The previous output script (the script being spent) for each input, except for the coinbase transaction.
+    # @return [Bitcoin::BlockFilter] block filter object.
+    def self.build_from_block(filter_type, block, prev_out_scripts)
+      block_hash = block.block_hash.htb[0...16]
+      filter = case filter_type
+               when TYPE[:basic]
+                 GCSFilter.new(block_hash, BASIC_FILTER_P, BASIC_FILTER_M, elements: build_basic_filter_elements(block, prev_out_scripts))
+               else
+                 raise "unknown filter type: #{filter_type}."
+               end
+      BlockFilter.new(filter_type, filter, block.block_hash)
+    end
+
+
+    # calculate filter hash.
+    # @return [String] this filter hash with hex format.
+    def filter_hash
+      Bitcoin.double_sha256(encoded_filter.htb).bth
+    end
+
+    # calculate filter header which calculates from previous filter header and current filter hash.
+    # @param [String] prev_header a previous header with hex format.
+    # @return [String] header of this filter with hex format.
+    def header(prev_header)
+      Bitcoin.double_sha256(filter_hash.htb + prev_header.htb).bth
+    end
+
+    # get encoded filter.
+    def encoded_filter
+      filter.encoded
+    end
+
+    # build basic filter elements
+    # @param [Bitcoin::Block] block current block
+    # @param [Array[Bitcoin::Script]] prev_out_scripts The previous output script (the script being spent) for each input, except for the coinbase transaction.
+    # @return [Array[String]] basic filter elements
+    def self.build_basic_filter_elements(block, prev_out_scripts)
+      elements = []
+      block.transactions.each do |tx|
+        elements += tx.outputs.select{|o|
+          !o.script_pubkey.empty? && !o.script_pubkey.op_return?}.map{|o| o.script_pubkey.to_payload}
+      end
+      elements += prev_out_scripts.select{|s|!s.empty? && !s.op_return?}.map(&:to_payload)
+      elements.uniq
+    end
+
+    private_class_method :build_basic_filter_elements
+
+  end
+
+end

data/lib/bitcoin/gcs_filter.rb

@@ -0,0 +1,135 @@
+require 'siphash'
+
+module Bitcoin
+
+  # Golomb-coded set filter
+  # see https://github.com/bitcoin/bips/blob/master/bip-0158.mediawiki
+  class GCSFilter
+
+    attr_reader :p # Golomb-Rice coding parameter
+    attr_reader :m # Inverse false positive rate
+    attr_reader :n # Number of elements in the filter
+    attr_reader :key # SipHash key
+    attr_reader :encoded # encoded filter with hex format.
+
+    # initialize Filter object.
+    # @param [String] key the 128-bit key used to randomize the SipHash outputs.
+    # @param [Integer] p the bit parameter of the Golomb-Rice coding.
+    # @param [Integer] m which determines the false positive rate.
+    # @param [Array] elements the filter elements.
+    # @param [String] encoded_filter encoded filter with hex format.
+    # @return [Bitcoin::GCSFilter]
+    def initialize(key, p, m, elements: nil, encoded_filter: nil)
+      raise 'specify either elements or encoded_filter.' if elements.nil? && encoded_filter.nil?
+      raise 'p must be <= 32' if p > 32
+      @key = key
+      @p = p
+      @m = m
+      if elements
+        raise 'elements size must be < 2**32.' if elements.size >= (2**32)
+        @n = elements.size
+        encoded = Bitcoin.pack_var_int(@n)
+        bit_writer = Bitcoin::BitStreamWriter.new
+        unless elements.empty?
+          last_value = 0
+          hashed_set = elements.map{|e| hash_to_range(e) }.sort
+          hashed_set.each do |v|
+            delta = v - last_value
+            golomb_rice_encode(bit_writer, p, delta)
+            last_value = v
+          end
+        end
+        bit_writer.flush
+        encoded << bit_writer.stream
+        @encoded = encoded.bth
+      else
+        @encoded = encoded_filter
+        @n, payload = Bitcoin.unpack_var_int(encoded_filter.htb)
+      end
+    end
+
+    # Range of element hashes, F = N * M
+    def f
+      n * m
+    end
+
+    # Hash a data element to an integer in the range [0, F).
+    # @param [String] element with binary format.
+    # @return [Integer]
+    def hash_to_range(element)
+      hash = SipHash.digest(key, element)
+      map_into_range(hash, f)
+    end
+
+    # Checks if the element may be in the set. False positives are possible with probability 1/M.
+    # @param [String] element with binary format
+    # @return [Boolean] whether element in set.
+    def match?(element)
+      query = hash_to_range(element)
+      match_internal?([query], 1)
+    end
+
+    # Checks if any of the given elements may be in the set. False positives are possible with probability 1/M per element checked.
+    # This is more efficient that checking Match on multiple elements separately.
+    # @param [Array] elements list of elements with binary format.
+    # @return [Boolean] whether element in set.
+    def match_any?(elements)
+      queries = elements.map{|e| hash_to_range(e) }.sort
+      match_internal?(queries, queries.size)
+    end
+
+    private
+
+    # hash are then mapped uniformly over the desired range by multiplying with F and taking the top 64 bits of the 128-bit result.
+    # https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
+    # https://stackoverflow.com/a/26855440
+    def map_into_range(x, y)
+      (x * y) >> 64
+    end
+
+    # Checks if the elements may be in the set.
+    # @param [Array[Integer]] hashes the query hash list.
+    # @param [Integer] size query size.
+    # @return [Boolean] whether elements in set.
+    def match_internal?(hashes, size)
+      n, payload = Bitcoin.unpack_var_int(encoded.htb)
+      bit_reader = Bitcoin::BitStreamReader.new(payload)
+      value = 0
+      hashes_index = 0
+      n.times do
+        delta = golomb_rice_decode(bit_reader, p)
+        value += delta
+        loop do
+          return false if hashes_index == size
+          return true if hashes[hashes_index] == value
+          break if hashes[hashes_index] > value
+          hashes_index += 1
+        end
+      end
+      false
+    end
+
+    # encode golomb rice
+    def golomb_rice_encode(bit_writer, p, x)
+      q = x >> p
+      while q > 0
+        nbits = q <= 64 ? q : 64
+        bit_writer.write(-1, nbits) # 18446744073709551615 is 2**64 - 1 = ~0ULL in cpp.
+        q -= nbits
+      end
+      bit_writer.write(0, 1)
+      bit_writer.write(x, p)
+    end
+
+    # decode golomb rice
+    def golomb_rice_decode(bit_reader, p)
+      q = 0
+      while bit_reader.read(1) == 1
+        q +=1
+      end
+      r = bit_reader.read(p)
+      (q << p) + r
+    end
+
+  end
+end

data/lib/bitcoin/rpc/request_handler.rb

@@ -105,14 +105,14 @@ module Bitcoin
       # wallet api
 
       # create wallet
-      def createwallet(wallet_id = 1, wallet_path_prefix = Bitcoin::Wallet::Base::DEFAULT_PATH_PREFIX)
+      def createwallet(wallet_id = 1, wallet_path_prefix = Bitcoin::Wallet::Base.default_path_prefix)
         wallet = Bitcoin::Wallet::Base.create(wallet_id, wallet_path_prefix)
         node.wallet = wallet unless node.wallet
         {wallet_id: wallet.wallet_id, mnemonic: wallet.master_key.mnemonic}
       end
 
       # get wallet list.
-      def listwallets(wallet_path_prefix = Bitcoin::Wallet::Base::DEFAULT_PATH_PREFIX)
+      def listwallets(wallet_path_prefix = Bitcoin::Wallet::Base.default_path_prefix)
         Bitcoin::Wallet::Base.wallet_paths(wallet_path_prefix)
       end
 

data/lib/bitcoin/script/script.rb

@@ -130,7 +130,11 @@ module Bitcoin
             end
           end
         else
-          s << opcode.ord
+          if Opcodes.defined?(opcode.ord)
+            s << opcode.ord
+          else
+            s.chunks << (opcode + buf.read) # If opcode is invalid, put all remaining data in last chunk.
+          end
         end
       end
       s
@@ -331,7 +335,8 @@ module Bitcoin
               end
             end
           else
-            Opcodes.opcode_to_name(c.ord)
+            opcode = Opcodes.opcode_to_name(c.ord)
+            opcode ? opcode : 'OP_UNKNOWN [error]'
           end
         end
       }.join(' ')

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/lib/bitcoin/wallet/base.rb

@@ -8,15 +8,19 @@ module Bitcoin
       attr_reader :db
       attr_reader :path
 
-      DEFAULT_PATH_PREFIX = "#{Bitcoin.base_dir}/db/wallet/"
       VERSION = 1
 
+      # get wallet dir path
+      def self.default_path_prefix
+        "#{Bitcoin.base_dir}/db/wallet/"
+      end
+
       # Create new wallet. If wallet already exist, throw error.
       # The wallet generates a seed using SecureRandom and store to db at initialization.
       # @param [String] wallet_id new wallet id.
       # @param [String] path_prefix wallet file path prefix.
       # @return [Bitcoin::Wallet::Base] the wallet
-      def self.create(wallet_id = 1, path_prefix = DEFAULT_PATH_PREFIX)
+      def self.create(wallet_id = 1, path_prefix = default_path_prefix)
         raise ArgumentError, "wallet_id : #{wallet_id} already exist." if self.exist?(wallet_id, path_prefix)
         w = self.new(wallet_id, path_prefix)
         # generate seed
@@ -29,23 +33,24 @@ module Bitcoin
 
       # load wallet with specified +wallet_id+
       # @return [Bitcoin::Wallet::Base] the wallet
-      def self.load(wallet_id, path_prefix = DEFAULT_PATH_PREFIX)
+      def self.load(wallet_id, path_prefix = default_path_prefix)
         raise ArgumentError, "wallet_id : #{wallet_id} dose not exist." unless self.exist?(wallet_id, path_prefix)
         self.new(wallet_id, path_prefix)
       end
 
       # get wallets path
       # @return [Array] Array of paths for each wallet dir.
-      def self.wallet_paths(path_prefix = DEFAULT_PATH_PREFIX)
+      def self.wallet_paths(path_prefix = default_path_prefix)
         Dir.glob("#{path_prefix}wallet*/").sort
       end
 
       # get current wallet
-      def self.current_wallet(path_prefix = DEFAULT_PATH_PREFIX)
-        path = wallet_paths.first # TODO default wallet selection
+      def self.current_wallet(path_prefix = default_path_prefix)
+        path = wallet_paths(path_prefix).first # TODO default wallet selection
         return nil unless path
-        wallet_id = path.delete(path_prefix + '/wallet').delete('/').to_i
-        self.load(wallet_id, path_prefix)
+        path.slice!(path_prefix + 'wallet')
+        path.slice!('/')
+        self.load(path.to_i, path_prefix)
       end
 
       # get account list based on BIP-44

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-13 00:00:00.000000000 Z
+date: 2019-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -303,7 +303,9 @@ files:
 - exe/bitcoinrbd
 - lib/bitcoin.rb
 - lib/bitcoin/base58.rb
+- lib/bitcoin/bit_stream.rb
 - lib/bitcoin/block.rb
+- lib/bitcoin/block_filter.rb
 - lib/bitcoin/block_header.rb
 - lib/bitcoin/bloom_filter.rb
 - lib/bitcoin/chain_params.rb
@@ -312,6 +314,7 @@ files:
 - lib/bitcoin/chainparams/testnet.yml
 - lib/bitcoin/constants.rb
 - lib/bitcoin/ext_key.rb
+- lib/bitcoin/gcs_filter.rb
 - lib/bitcoin/key.rb
 - lib/bitcoin/logger.rb
 - lib/bitcoin/merkle_tree.rb
@@ -436,8 +439,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: "[WIP]The implementation of Bitcoin Protocol for Ruby."