openassets-ruby 0.6.4 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f362016ff8fa51b787342956a9ff9bf48781f25
-  data.tar.gz: ae953a7a6560179461d89acd2a5760f2ac6c9bb9
+  metadata.gz: 9f4f00149febc1e6b4b339fb9a9129befccff7be
+  data.tar.gz: ef6701a208bd54ed9bfc99f5d2df6ac2299c76b3
 SHA512:
-  metadata.gz: 84efa72f48d56159d10b4df97c90d5b4a8a14732d04de89c7cc2db5bbf23ae4ccb115167500550a92e02aff0dd3874c39b9f3ddc41cd01377d15911c87b9a1fb
-  data.tar.gz: 53751bbe2b3e4828a470b955426f814e9c3c58f8680119fd1064464493b7a8852fa9d4f81d5271e1f2c6687406a90f784fc2511c86606459c3f85effb6791c30
+  metadata.gz: 999d13563e91a619f001ec4941077e7825de88735a6ad460389e2956d3fe843ba0b2e0a3577731862cecbbdcfef0eeffc9d67526630ae3b3354a2a348581d831
+  data.tar.gz: e15ec20eda29fc0d2c01632457c79e8148c28b1af73be73f7a27b931f0695c3273250e02680cf7e18c11bbeb332819558d705bc503201b2d53d86cdf476ab5b5

data/.ruby-version

@@ -1 +1 @@
-ruby-2.3.0
+ruby-2.4.1

data/.travis.yml

@@ -1,5 +1,7 @@
 language: ruby
 rvm:
+  - 2.4.1
+  - 2.4.0
   - 2.3.0
   - 2.2.2
 

data/lib/openassets.rb

@@ -1,6 +1,6 @@
 require 'bitcoin'
 require 'leb128'
-require 'segwit'
+
 module OpenAssets
 
   autoload :Protocol, 'openassets/protocol'

data/lib/openassets/version.rb

@@ -1,3 +1,3 @@
 module OpenAssets
-  VERSION = '0.6.4'
+  VERSION = '0.6.5'
 end

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.10"
+  spec.add_runtime_dependency "bitcoin-ruby", "~> 0.0.11"
   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.4
+  version: 0.6.5
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-09 00:00:00.000000000 Z
+date: 2017-07-06 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.10
+        version: 0.0.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.10
+        version: 0.0.11
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -218,12 +218,6 @@ files:
 - lib/openassets/transaction/transfer_parameters.rb
 - lib/openassets/util.rb
 - lib/openassets/version.rb
-- lib/segwit.rb
-- lib/segwit/script.rb
-- lib/segwit/script_witness.rb
-- lib/segwit/tx.rb
-- lib/segwit/tx_in_witness.rb
-- lib/segwit/tx_witness.rb
 - openassets-ruby.gemspec
 homepage: https://github.com/haw-itn/openassets-ruby
 licenses:
@@ -245,7 +239,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: The implementation of the Open Assets Protocol for Ruby.

data/lib/segwit.rb

@@ -1,12 +0,0 @@
-# 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'
-    require 'segwit/script'
-    autoload :TxWitness, 'segwit/tx_witness'
-    autoload :TxInWitness, 'segwit/tx_in_witness'
-    autoload :ScriptWitness, 'segwit/script_witness'
-  end
-end

data/lib/segwit/script.rb

@@ -1,78 +0,0 @@
-# encoding: ascii-8bit
-
-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?
-    is_pubkey? || is_hash160? || is_multisig? || is_p2sh?  || is_op_return? || is_witness_v0_keyhash? || is_witness_v0_scripthash?
-  end
-
-  # 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].is_a?(String) && @chunks[1].bytesize == 20
-  end
-
-  # is this a witness script hash
-  def is_witness_v0_scripthash?
-    @chunks.length == 2 &&@chunks[0] == 0 && @chunks[1].is_a?(String) && @chunks[1].bytesize == 32
-  end
-
-  # get type of this tx
-  def type
-    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
-
-  # 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
-
-  # 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,35 +0,0 @@
-# encoding: ascii-8bit
-
-module Bitcoin
-
-  module Protocol
-
-    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
-
-  end
-
-end

data/lib/segwit/tx.rb

@@ -1,235 +0,0 @@
-# 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
-
-      # 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
-
-        @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)
-
-        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
-
-        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,38 +0,0 @@
-# encoding: ascii-8bit
-
-module Bitcoin
-
-  module Protocol
-
-    class TxInWitness
-      attr_reader :script_witness
-
-      def initialize
-        @script_witness = Bitcoin::Protocol::ScriptWitness.new
-      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,43 +0,0 @@
-# encoding: ascii-8bit
-
-module Bitcoin
-  module Protocol
-
-    class TxWitness
-
-      attr_reader :tx_in_wit
-
-      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