openassets-ruby 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b5679dc5dd4ae230e09b81012fe13e7db057548
-  data.tar.gz: c1796a40aa77821f6ae961202a0d4bcb9ebff79c
+  metadata.gz: b3cd49e63faf8301ee4caf26be682202e5e5a051
+  data.tar.gz: a3b67aa95ec1f0b25065eb05723a0b497fdecb7e
 SHA512:
-  metadata.gz: 7b6a6bd8a6c3f078d097d7f7c78a2f292ee55bc021f9576dc89c1a91981daf043a4b91302dd03fa10cf6885c63f64c95622018837c13122aba9c0362100317f1
-  data.tar.gz: 3037ef079b58c44834699f196fbd117374f8a4ff5b01dbbe09e28f3409b371886ff930767d6d8829d854519824cee83b90d4eb89c1a1fcd4cb7239036b6dfe51
+  metadata.gz: ebbb8bb25821768cfeeed8a95057dbba49652c81bc357f243ba67e6cc0ad0fb843d5d02b0c6b865b32b569dee95712641983c7332bdc97d9063404ff0b903700
+  data.tar.gz: c6fb0224a52a92f34466a677423769566158e912b52bc1ce677ff87999396c81d27764ffb252b172c25a9826be8276892ec3cd373741ad9dfc93ab51a270b66d

data/lib/openassets/version.rb

@@ -1,3 +1,3 @@
 module OpenAssets
-  VERSION = '0.6.1'
+  VERSION = '0.6.2'
 end

data/lib/segwit/script.rb

@@ -1,36 +1,78 @@
-module SegwitScript
+# encoding: ascii-8bit
 
-  # override Bitcoin::Script#is_standard?
-  # Add P2WPKH and P2WSH to the standard
+require 'bitcoin'
+
+class Bitcoin::Script
+  # Returns a script that deleted the script before the index specified by separator_index.
+  def subscript_codeseparator(separator_index)
+    buf = []
+    process_separator_index = 0
+    (chunks || @chunks).each{|chunk|
+      buf << chunk if process_separator_index == separator_index
+      process_separator_index += 1 if chunk == OP_CODESEPARATOR and process_separator_index < separator_index
+    }
+    to_binary(buf)
+  end
+
+  # check if script is in one of the recognized standard formats
   def is_standard?
-    super || is_witness_v0_keyhash? || is_witness_v0_scripthash?
+    is_pubkey? || is_hash160? || is_multisig? || is_p2sh?  || is_op_return? || is_witness_v0_keyhash? || is_witness_v0_scripthash?
   end
 
-  # see https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#Witness_program
+  # is this a witness script(witness_v0_keyhash or witness_v0_scripthash)
+  def is_witness?
+    is_witness_v0_keyhash? || is_witness_v0_scripthash?
+  end
+
+  # is this a witness pubkey script
   def is_witness_v0_keyhash?
-    @chunks.length == 2 &&@chunks[0] == 0 && @chunks[1].bytesize == 20
+    @chunks.length == 2 &&@chunks[0] == 0 && @chunks[1].is_a?(String) && @chunks[1].bytesize == 20
   end
 
-  # see https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#Witness_program
+  # is this a witness script hash
   def is_witness_v0_scripthash?
-    @chunks.length == 2 &&@chunks[0] == 0 && @chunks[1].bytesize == 32
+    @chunks.length == 2 &&@chunks[0] == 0 && @chunks[1].is_a?(String) && @chunks[1].bytesize == 32
   end
 
-  # override Bitcoin::Script#type
-  # Add type witness_v0_keyhash and witness_v0_scripthash
+  # get type of this tx
   def type
-    base = super
-    if base == :unknown
-      return :witness_v0_keyhash if is_witness_v0_keyhash?
-      return :witness_v0_scripthash if is_witness_v0_scripthash?
-      :unknown
-    else
-      base
+    if is_hash160?;                 :hash160
+    elsif is_pubkey?;               :pubkey
+    elsif is_multisig?;             :multisig
+    elsif is_p2sh?;                 :p2sh
+    elsif is_op_return?;            :op_return
+    elsif is_witness_v0_keyhash?;   :witness_v0_keyhash
+    elsif is_witness_v0_scripthash?;:witness_v0_scripthash
+    else;                           :unknown
     end
   end
 
-end
+  # get the hash160 for this hash160 or pubkey script
+  def get_hash160
+    return @chunks[2..-3][0].unpack("H*")[0]  if is_hash160?
+    return @chunks[-2].unpack("H*")[0]        if is_p2sh?
+    return Bitcoin.hash160(get_pubkey)        if is_pubkey?
+    return @chunks[1].unpack("H*")[0]         if is_witness_v0_keyhash?
+    return @chunks[1].unpack("H*")[0]         if is_witness_v0_scripthash?
+  end
 
-class Bitcoin::Script
-  prepend SegwitScript
+  # generate p2wpkh tx for given +address+. returns a raw binary script of the form:
+  # 0 <hash160>
+  def self.to_witness_hash160_script(hash160)
+    return nil  unless hash160
+    #  witness ver  length  hash160
+    [ ["00",         "14",  hash160].join ].pack("H*")
+  end
+
+  # generate p2wsh output script for given +p2sh+ sha256. returns a raw binary script of the form:
+  # 0 <p2sh>
+  def self.to_witness_p2sh_script(p2sh)
+    return nil  unless p2sh
+    #  witness ver  length  sha256
+    [ [ "00",        "20",   p2sh].join].pack("H*")
+  end
+
+  def codeseparator_count
+    @chunks.select{|c|c == Bitcoin::Script::OP_CODESEPARATOR}.length
+  end
 end

data/lib/segwit/script_witness.rb

@@ -1,23 +1,35 @@
-class Bitcoin::Protocol::ScriptWitness
+# encoding: ascii-8bit
 
-  # witness stack
-  attr_reader :stack
+module Bitcoin
 
-  def initialize
-    @stack = []
-  end
+  module Protocol
 
-  def empty?
-    stack.empty?
-  end
+    class ScriptWitness
+
+      # witness stack
+      attr_reader :stack
+
+      def initialize
+        @stack = []
+      end
+
+      # check empty
+      def empty?
+        stack.empty?
+      end
+
+      # output script in raw binary format
+      def to_payload
+        payload = Bitcoin::Protocol.pack_var_int(stack.size)
+        stack.each{|e|
+          payload << Bitcoin::Protocol.pack_var_int(e.htb.bytesize)
+          payload << e.htb
+        }
+        payload
+      end
+
+    end
 
-  # output script in raw binary format
-  def to_payload
-    payload = Bitcoin::Protocol.pack_var_int(stack.size)
-    stack.each{|e|
-      payload << Bitcoin::Protocol.pack_var_int(e.htb.bytesize)
-      payload << e.htb
-    }
-    payload
   end
+
 end

data/lib/segwit/tx.rb

@@ -1,76 +1,235 @@
-# extension for Bitcoin::Protocol::Tx to support segwit
-class Bitcoin::Protocol::Tx
-  include Bitcoin::Util
-
-  attr_reader :witness
-
-  def initialize(data=nil)
-    @ver, @lock_time, @in, @out, @scripts, @witness = 1, 0, [], [], [], Bitcoin::Protocol::TxWitness.new
-    @enable_bitcoinconsensus = !!ENV['USE_BITCOINCONSENSUS']
-    if data
-      begin
-        parse_witness_data_from_io(data) unless parse_data_from_io(data).is_a?(TrueClass)
-      rescue Exception
-        parse_witness_data_from_io(data)
+# encoding: ascii-8bit
+
+require 'bitcoin/script'
+
+module Bitcoin
+  module Protocol
+
+    class Tx
+
+      # witness (TxWitness)
+      attr_reader :witness
+
+      # create tx from raw binary +data+
+      def initialize(data=nil)
+        @ver, @lock_time, @in, @out, @scripts, @witness = 1, 0, [], [], [], TxWitness.new
+        @enable_bitcoinconsensus = !!ENV['USE_BITCOINCONSENSUS']
+        if data
+          begin
+            parse_witness_data_from_io(data) unless parse_data_from_io(data).is_a?(TrueClass)
+          rescue Exception
+            parse_witness_data_from_io(data)
+          end
+        end
       end
-    end
-  end
 
-  # get witness hash
-  def witness_hash
-    hash_from_payload(to_witness_payload)
-  end
+      # parse witness raw binary data
+      # serialization format is defined by https://github.com/bitcoin/bips/blob/master/bip-0144.mediawiki
+      def parse_witness_data_from_io(data)
+        buf = data.is_a?(String) ? StringIO.new(data) : data
 
-  # parse raw data which include witness data
-  # serialization format is defined by https://github.com/bitcoin/bips/blob/master/bip-0144.mediawiki
-  def parse_witness_data_from_io(data)
-    buf = data.is_a?(String) ? StringIO.new(data) : data
-
-    @ver = buf.read(4).unpack("V").first
-
-    @marker = buf.read(1).unpack("c").first
-
-    @flag = buf.read(1).unpack("c").first
-
-    in_size = Bitcoin::Protocol.unpack_var_int_from_io(buf)
-    @in = []
-    in_size.times{
-      break if buf.eof?
-      @in << Bitcoin::Protocol::TxIn.from_io(buf)
-    }
-
-    out_size = Bitcoin::Protocol.unpack_var_int_from_io(buf)
-    @out = []
-    out_size.times{
-      break if buf.eof?
-      @out << Bitcoin::Protocol::TxOut.from_io(buf)
-    }
-
-    @witness = Bitcoin::Protocol::TxWitness.new
-    in_size.times{
-      witness_count = Bitcoin::Protocol.unpack_var_int_from_io(buf)
-      in_witness = Bitcoin::Protocol::TxInWitness.new
-      witness_count.times{
-        length = Bitcoin::Protocol.unpack_var_int_from_io(buf)
-        in_witness.add_stack(buf.read(length).unpack("H*").first)
-      }
-      @witness.add_witness(in_witness)
-    }
-
-    @lock_time = buf.read(4).unpack("V").first
-
-    @hash = hash_from_payload(to_payload)
-  end
+        @ver = buf.read(4).unpack("V").first
 
-  # output transaction in raw binary format with witness
-  def to_witness_payload
-    pin = ""
-    @in.each{|input| pin << input.to_payload }
-    pout = ""
-    @out.each{|output| pout << output.to_payload }
-    payload = [@ver].pack("V") << [0].pack("c") << [1].pack("c") << Bitcoin::Protocol.pack_var_int(@in.size) << pin <<
-        Bitcoin::Protocol.pack_var_int(@out.size) << pout << @witness.to_payload << [@lock_time].pack("V")
-    payload
-  end
+        @marker = buf.read(1).unpack("c").first
+
+        @flag = buf.read(1).unpack("c").first
+
+        in_size = Bitcoin::Protocol.unpack_var_int_from_io(buf)
+        @in = []
+        in_size.times{
+          break if buf.eof?
+          @in << Bitcoin::Protocol::TxIn.from_io(buf)
+        }
+
+        out_size = Bitcoin::Protocol.unpack_var_int_from_io(buf)
+        @out = []
+        out_size.times{
+          break if buf.eof?
+          @out << Bitcoin::Protocol::TxOut.from_io(buf)
+        }
+
+        @witness = Bitcoin::Protocol::TxWitness.new
+        in_size.times{
+          witness_count = Bitcoin::Protocol.unpack_var_int_from_io(buf)
+          in_witness = Bitcoin::Protocol::TxInWitness.new
+          witness_count.times{
+            length = Bitcoin::Protocol.unpack_var_int_from_io(buf)
+            in_witness.add_stack(buf.read(length).unpack("H*").first)
+          }
+          @witness.add_witness(in_witness)
+        }
+
+        @lock_time = buf.read(4).unpack("V").first
+
+        @hash = hash_from_payload(to_payload)
+
+        if buf.eof?
+          true
+        else
+          data.is_a?(StringIO) ? buf : buf.read
+        end
+      end
+
+      alias :parse_witness_data  :parse_witness_data_from_io
+
+      # output transaction in raw binary format with witness
+      def to_witness_payload
+        pin = ""
+        @in.each{|input| pin << input.to_payload }
+        pout = ""
+        @out.each{|output| pout << output.to_payload }
+        [@ver].pack("V") << [0].pack("c") << [1].pack("c") << Bitcoin::Protocol.pack_var_int(@in.size) << pin <<
+            Bitcoin::Protocol.pack_var_int(@out.size) << pout << @witness.to_payload << [@lock_time].pack("V")
+      end
+
+      # generate a witness signature hash for input +input_idx+.
+      # https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki
+      def signature_hash_for_witness_input(input_idx, witness_program, prev_out_value, witness_script = nil, hash_type=nil, skip_separator_index = 0)
+        return "\x01".ljust(32, "\x00") if input_idx >= @in.size # ERROR: SignatureHash() : input_idx=%d out of range
+
+        hash_type ||= SIGHASH_TYPE[:all]
+
+        script = Bitcoin::Script.new(witness_program)
+        raise "ScriptPubkey does not contain witness program." unless script.is_witness?
+
+        hash_prevouts = Digest::SHA256.digest(Digest::SHA256.digest(@in.map{|i| [i.prev_out_hash, i.prev_out_index].pack("a32V")}.join))
+        hash_sequence = Digest::SHA256.digest(Digest::SHA256.digest(@in.map{|i|i.sequence}.join))
+        outpoint = [@in[input_idx].prev_out_hash, @in[input_idx].prev_out_index].pack("a32V")
+        amount = [prev_out_value].pack("Q")
+        nsequence = @in[input_idx].sequence
+
+        if script.is_witness_v0_keyhash?
+          script_code = [["1976a914", script.get_hash160, "88ac"].join].pack("H*")
+        elsif script.is_witness_v0_scripthash?
+          raise "witness script does not match script pubkey" unless Bitcoin::Script.to_witness_p2sh_script(Digest::SHA256.digest(witness_script).bth) == witness_program
+          script = skip_separator_index > 0 ? Bitcoin::Script.new(witness_script).subscript_codeseparator(skip_separator_index) : witness_script
+          script_code = Bitcoin::Protocol.pack_var_string(script)
+        end
 
-end
+        hash_outputs = Digest::SHA256.digest(Digest::SHA256.digest(@out.map{|o|o.to_payload}.join))
+
+        case (hash_type & 0x1f)
+          when SIGHASH_TYPE[:single]
+            hash_outputs = input_idx >= @out.size ? "\x00".ljust(32, "\x00") : Digest::SHA256.digest(Digest::SHA256.digest(@out[input_idx].to_payload))
+            hash_sequence = "\x00".ljust(32, "\x00")
+          when SIGHASH_TYPE[:none]
+            hash_sequence = hash_outputs = "\x00".ljust(32, "\x00")
+        end
+
+        if (hash_type & SIGHASH_TYPE[:anyonecanpay]) != 0
+          hash_prevouts = hash_sequence ="\x00".ljust(32, "\x00")
+        end
+
+        buf = [ [@ver].pack("V"), hash_prevouts, hash_sequence, outpoint,
+                script_code, amount, nsequence, hash_outputs, [@lock_time, hash_type].pack("VV")].join
+
+        Digest::SHA256.digest( Digest::SHA256.digest( buf ) )
+      end
+
+      # verify witness input signature +in_idx+ against the corresponding
+      # output in +outpoint_tx+
+      # outpoint
+      #
+      # options are: verify_sigpushonly, verify_minimaldata, verify_cleanstack, verify_dersig, verify_low_s, verify_strictenc
+      def verify_witness_input_signature(in_idx, outpoint_tx_or_script, prev_out_amount, block_timestamp=Time.now.to_i, opts={})
+        if @enable_bitcoinconsensus
+          return bitcoinconsensus_verify_script(in_idx, outpoint_tx_or_script, block_timestamp, opts)
+        end
+
+        outpoint_idx  = @in[in_idx].prev_out_index
+        script_sig    = ''
+
+        # If given an entire previous transaction, take the script from it
+        script_pubkey = if outpoint_tx_or_script.respond_to?(:out)
+          Bitcoin::Script.new(outpoint_tx_or_script.out[outpoint_idx].pk_script)
+        else
+          # Otherwise, it's already a script.
+          Bitcoin::Script.new(outpoint_tx_or_script)
+        end
+
+        if script_pubkey.is_p2sh?
+          redeem_script = Bitcoin::Script.new(@in[in_idx].script_sig).get_pubkey
+          script_pubkey = Bitcoin::Script.new(redeem_script.htb) if Bitcoin.hash160(redeem_script) == script_pubkey.get_hash160 # P2SH-P2WPKH or P2SH-P2WSH
+        end
+
+        witness.tx_in_wit[in_idx].stack.each{|s|script_sig << Bitcoin::Script.pack_pushdata(s.htb)}
+        code_separator_index = 0
+
+        if script_pubkey.is_witness_v0_keyhash? # P2WPKH
+          @scripts[in_idx] = Bitcoin::Script.new(script_sig, Bitcoin::Script.to_hash160_script(script_pubkey.get_hash160))
+        elsif script_pubkey.is_witness_v0_scripthash? # P2WSH
+          witness_hex = witness.tx_in_wit[in_idx].stack.last
+          witness_script = Bitcoin::Script.new(witness_hex.htb)
+          return false unless Bitcoin.sha256(witness_hex) == script_pubkey.get_hash160
+          @scripts[in_idx] = Bitcoin::Script.new(script_sig, Bitcoin::Script.to_p2sh_script(Bitcoin.hash160(witness_hex)))
+        else
+          return false
+        end
+
+        return false if opts[:verify_sigpushonly] && !@scripts[in_idx].is_push_only?(script_sig)
+        return false if opts[:verify_minimaldata] && !@scripts[in_idx].pushes_are_canonical?
+        sig_valid = @scripts[in_idx].run(block_timestamp, opts) do |pubkey,sig,hash_type,subscript|
+          if script_pubkey.is_witness_v0_keyhash?
+            hash = signature_hash_for_witness_input(in_idx, script_pubkey.to_payload, prev_out_amount, nil, hash_type)
+          elsif script_pubkey.is_witness_v0_scripthash?
+            hash = signature_hash_for_witness_input(in_idx, script_pubkey.to_payload, prev_out_amount, witness_hex.htb, hash_type, code_separator_index)
+            code_separator_index += 1 if witness_script.codeseparator_count > code_separator_index
+          end
+          Bitcoin.verify_signature( hash, sig, pubkey.unpack("H*")[0] )
+        end
+        # BIP62 rule #6
+        return false if opts[:verify_cleanstack] && !@scripts[in_idx].stack.empty?
+
+        return sig_valid
+      end
+
+      # convert to ruby hash (see also #from_hash)
+      def to_hash(options = {})
+        @hash ||= hash_from_payload(to_payload)
+        h = {
+          'hash' => @hash, 'ver' => @ver, # 'nid' => normalized_hash,
+          'vin_sz' => @in.size, 'vout_sz' => @out.size,
+          'lock_time' => @lock_time, 'size' => (@payload ||= to_payload).bytesize,
+          'in'  =>  @in.map.with_index{|i, index|
+            h = i.to_hash(options)
+            h.merge!('witness' => @witness.tx_in_wit[index].stack) if @witness.tx_in_wit[index]
+            h
+          },
+          'out' => @out.map{|o| o.to_hash(options) }
+        }
+        h['nid'] = normalized_hash  if options[:with_nid]
+        h
+      end
+
+      # parse ruby hash (see also #to_hash)
+      def self.from_hash(h, do_raise=true)
+        tx = new(nil)
+        tx.ver, tx.lock_time = (h['ver'] || h['version']), h['lock_time']
+        ins  = h['in']  || h['inputs']
+        outs = h['out'] || h['outputs']
+        ins .each{|input|
+          tx.add_in(TxIn.from_hash(input))
+          tx.witness.add_witness(TxInWitness.from_hash(input['witness'])) if input['witness']
+        }
+        outs.each{|output|  tx.add_out TxOut.from_hash(output) }
+        tx.instance_eval{ @hash = hash_from_payload(@payload = to_payload) }
+        if h['hash'] && (h['hash'] != tx.hash)
+          raise "Tx hash mismatch! Claimed: #{h['hash']}, Actual: #{tx.hash}" if do_raise
+        end
+        tx
+      end
+
+      # convert ruby hash to raw binary
+      def self.binary_from_hash(h)
+        tx = from_hash(h)
+        tx.witness.empty? ? tx.to_payload : tx.to_witness_payload
+      end
+
+      # get witness hash
+      def witness_hash
+        hash_from_payload(to_witness_payload)
+      end
+
+    end
+  end
+end

data/lib/segwit/tx_in_witness.rb

@@ -1,22 +1,38 @@
-class Bitcoin::Protocol::TxInWitness
+# encoding: ascii-8bit
 
-  attr_reader :script_witness
+module Bitcoin
 
-  def initialize
-    @script_witness = Bitcoin::Protocol::ScriptWitness.new
-  end
+  module Protocol
 
-  def add_stack(script)
-    script_witness.stack << script
-  end
+    class TxInWitness
+      attr_reader :script_witness
 
-  #  output witness script in raw binary format with witness
-  def to_payload
-    script_witness.to_payload
-  end
+      def initialize
+        @script_witness = Bitcoin::Protocol::ScriptWitness.new
+      end
 
-  def stack
-    script_witness.stack
-  end
+      # add witness script to stack
+      def add_stack(script)
+        script_witness.stack << script
+      end
+
+      #  output witness script in raw binary format with witness
+      def to_payload
+        script_witness.to_payload
+      end
 
+      # get witness script stack
+      def stack
+        script_witness.stack
+      end
+
+      def self.from_hash(witnesses)
+        w = TxInWitness.new
+        witnesses.each{|item|w.add_stack(item)}
+        w
+      end
+
+    end
+
+  end
 end

data/lib/segwit/tx_witness.rb

@@ -1,22 +1,43 @@
-class Bitcoin::Protocol::TxWitness
+# encoding: ascii-8bit
 
-  attr_reader :tx_in_wit
+module Bitcoin
+  module Protocol
 
-  def initialize
-    @tx_in_wit = []
-  end
+    class TxWitness
 
-  # Add witness
-  # @param[Bitcoin::Protocol::TxInWitness] tx_in_wit witness object
-  def add_witness(tx_in_wit)
-    (@tx_in_wit ||= []) << tx_in_wit
-  end
+      attr_reader :tx_in_wit
 
-  # output witness in raw binary format
-  def to_payload
-    payload = ""
-    tx_in_wit.each{|w|payload << w.to_payload}
-    payload
-  end
+      def initialize
+        @tx_in_wit = []
+      end
+
+      # Add witness
+      # @param[Bitcoin::Protocol::TxInWitness] tx_in_wit witness object
+      def add_witness(tx_in_wit)
+        (@tx_in_wit ||= []) << tx_in_wit
+      end
+
+      # add empty witness
+      def add_empty_witness
+        add_witness(TxInWitness.new)
+      end
 
+      # output witness in raw binary format
+      def to_payload
+        payload = ""
+        @tx_in_wit.each{|w|payload << w.to_payload}
+        payload
+      end
+
+      def size
+        tx_in_wit.length
+      end
+
+      def empty?
+        size == 0
+      end
+
+    end
+
+  end
 end

data/lib/segwit.rb

@@ -1,3 +1,6 @@
+# This is a temporary implementation until bitcoin-ruby formally supports Segregated Witness.
+# This implementation ported from the implementation of the pull request below.
+# https://github.com/lian/bitcoin-ruby/pull/203
 module Bitcoin
   module Protocol
     require 'segwit/tx'

data/openassets-ruby.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.add_runtime_dependency "bitcoin-ruby", "~> 0.0.7"
+  spec.add_runtime_dependency "bitcoin-ruby", "~> 0.0.10"
   spec.add_runtime_dependency "ffi", "~>1.9.8"
   spec.add_runtime_dependency "rest-client", "~>1.8.0"
   spec.add_runtime_dependency "httpclient"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openassets-ruby
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-17 00:00:00.000000000 Z
+date: 2017-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bitcoin-ruby
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.7
+        version: 0.0.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.7
+        version: 0.0.10
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement