tapyrus 0.1.0 → 0.2.4

data/lib/tapyrus/store/spv_chain.rb

@@ -3,10 +3,12 @@ module Tapyrus
   module Store
 
     KEY_PREFIX = {
-        entry: 'e',   # key: block hash, value: Tapyrus::Store::ChainEntry payload
-        height: 'h',  # key: block height, value: block hash.
-        best: 'B',    # value: best block hash.
-        next: 'n'     # key: block hash, value: A hash of the next block of the specified hash
+        entry: 'e',             # key: block hash, value: Tapyrus::Store::ChainEntry payload
+        height: 'h',            # key: block height, value: block hash.
+        best: 'B',              # value: best block hash.
+        next: 'n',              # key: block hash, value: A hash of the next block of the specified hash
+        agg_pubkey: 'a',        # key: index, value: Activated block height | aggregated public key.
+        latest_agg_pubkey: 'g'  # value: latest agg pubkey index.
     }
 
     class SPVChain
@@ -14,10 +16,14 @@ module Tapyrus
       attr_reader :db
       attr_reader :logger
 
-      def initialize(db = Tapyrus::Store::DB::LevelDB.new)
+      # initialize spv chain
+      # @param[Tapyrus::Store::DB::LevelDB] db
+      # @param[Tapyrus::Block] genesis genesis block
+      def initialize(db = Tapyrus::Store::DB::LevelDB.new, genesis: nil)
+        raise ArgumentError, 'genesis block should be specified.' unless genesis
         @db = db # TODO multiple db switch
         @logger = Tapyrus::Logger.create(:debug)
-        initialize_block
+        initialize_block(genesis)
       end
 
       # get latest block in the store.
@@ -45,9 +51,9 @@ module Tapyrus
       # @return [Tapyrus::Store::ChainEntry] appended block header entry.
       def append_header(header)
         logger.info("append header #{header.block_id}")
-        raise "this header is invalid. #{header.block_hash}" unless header.valid?
         best_block = latest_block
         current_height = best_block.height
+        raise "this header is invalid. #{header.block_hash}" unless header.valid?(db.agg_pubkey_with_height(current_height + 1))
         if best_block.block_hash == header.prev_hash
           entry = Tapyrus::Store::ChainEntry.new(header, current_height + 1)
           db.save_entry(entry)
@@ -83,14 +89,26 @@ module Tapyrus
         time[time.size / 2]
       end
 
+      # Add aggregated public key.
+      # @param [Integer] active_height
+      # @param [String] agg_pubkey aggregated public key with hex format.
+      def add_agg_pubkey(active_height, agg_pubkey)
+        db.add_agg_pubkey(active_height, agg_pubkey)
+      end
+
+      # get aggregated public key keys.
+      # @return [Array[Array(height, agg_pubkey)]] the list of public keys.
+      def agg_pubkeys
+        db.agg_pubkeys
+      end
+
       private
 
       # if database is empty, put genesis block.
-      def initialize_block
+      # @param [Tapyrus::Block] genesis genesis block
+      def initialize_block(genesis)
         unless latest_block
-          block = Tapyrus.chain_params.genesis_block
-          genesis = ChainEntry.new(block.header, 0)
-          db.save_entry(genesis)
+          db.save_entry(ChainEntry.new(genesis.header, 0))
         end
       end
 

data/lib/tapyrus/tx.rb

@@ -5,18 +5,14 @@ module Tapyrus
 
   # Transaction class
   class Tx
+    include Tapyrus::HexConverter
 
     MAX_STANDARD_VERSION = 2
 
     # The maximum weight for transactions we're willing to relay/mine
     MAX_STANDARD_TX_WEIGHT = 400000
 
-    MARKER = 0x00
-    FLAG = 0x01
-
-    attr_accessor :version
-    attr_accessor :marker
-    attr_accessor :flag
+    attr_accessor :features
     attr_reader :inputs
     attr_reader :outputs
     attr_accessor :lock_time
@@ -24,30 +20,19 @@ module Tapyrus
     def initialize
       @inputs = []
       @outputs = []
-      @version = 1
+      @features = 1
       @lock_time = 0
     end
 
     alias_method :in, :inputs
     alias_method :out, :outputs
 
-    def self.parse_from_payload(payload, non_witness: false)
+    def self.parse_from_payload(payload)
       buf = payload.is_a?(String) ? StringIO.new(payload) : payload
       tx = new
-      tx.version = buf.read(4).unpack('V').first
+      tx.features = buf.read(4).unpack('V').first
 
       in_count = Tapyrus.unpack_var_int_from_io(buf)
-      witness = false
-      if in_count.zero? && !non_witness
-        tx.marker = 0
-        tx.flag = buf.read(1).unpack('c').first
-        if tx.flag.zero?
-          buf.pos -= 1
-        else
-          in_count = Tapyrus.unpack_var_int_from_io(buf)
-          witness = true
-        end
-      end
 
       in_count.times do
         tx.inputs << TxIn.parse_from_payload(buf)
@@ -58,101 +43,46 @@ module Tapyrus
         tx.outputs << TxOut.parse_from_payload(buf)
       end
 
-      if witness
-        in_count.times do |i|
-          tx.inputs[i].script_witness = Tapyrus::ScriptWitness.parse_from_payload(buf)
-        end
-      end
-
       tx.lock_time = buf.read(4).unpack('V').first
 
       tx
     end
 
     def hash
-      to_payload.bth.to_i(16)
+      to_hex.to_i(16)
     end
 
     def tx_hash
-      Tapyrus.double_sha256(serialize_old_format).bth
+      Tapyrus.double_sha256(to_payload).bth
     end
 
     def txid
-      buf = [version].pack('V')
+      buf = [features].pack('V')
       buf << Tapyrus.pack_var_int(inputs.length) << inputs.map{|i|i.to_payload(use_malfix: true)}.join
       buf << Tapyrus.pack_var_int(outputs.length) << outputs.map(&:to_payload).join
       buf << [lock_time].pack('V')
       Tapyrus.double_sha256(buf).reverse.bth
     end
 
-    def witness_hash
-      Tapyrus.double_sha256(to_payload).bth
-    end
-
-    def wtxid
-      witness_hash.rhex
-    end
-
-    # get the witness commitment of coinbase tx.
-    # if this tx does not coinbase or not have commitment, return nil.
-    def witness_commitment
-      return nil unless coinbase_tx?
-      outputs.each do |output|
-        commitment = output.script_pubkey.witness_commitment
-        return commitment if commitment
-      end
-      nil
-    end
-
     def to_payload
-      witness? ? serialize_witness_format : serialize_old_format
-    end
-
-    # convert tx to hex format.
-    # @return [String] tx with hex format.
-    def to_hex
-      to_payload.bth
-    end
-
-    def coinbase_tx?
-      inputs.length == 1 && inputs.first.coinbase?
-    end
-
-    def witness?
-      !inputs.find { |i| !i.script_witness.empty? }.nil?
-    end
-
-    def ==(other)
-      to_payload == other.to_payload
-    end
-
-    # serialize tx with old tx format
-    def serialize_old_format
-      buf = [version].pack('V')
+      buf = [features].pack('V')
       buf << Tapyrus.pack_var_int(inputs.length) << inputs.map(&:to_payload).join
       buf << Tapyrus.pack_var_int(outputs.length) << outputs.map(&:to_payload).join
       buf << [lock_time].pack('V')
       buf
     end
 
-    # serialize tx with segwit tx format
-    # https://github.com/bitcoin/bips/blob/master/bip-0144.mediawiki
-    def serialize_witness_format
-      buf = [version, MARKER, FLAG].pack('Vcc')
-      buf << Tapyrus.pack_var_int(inputs.length) << inputs.map(&:to_payload).join
-      buf << Tapyrus.pack_var_int(outputs.length) << outputs.map(&:to_payload).join
-      buf << witness_payload << [lock_time].pack('V')
-      buf
+    def coinbase_tx?
+      inputs.length == 1 && inputs.first.coinbase?
     end
 
-    def witness_payload
-      inputs.map { |i| i.script_witness.to_payload }.join
+    def ==(other)
+      to_payload == other.to_payload
     end
 
     # check this tx is standard.
     def standard?
-      return false if version > MAX_STANDARD_VERSION
-      return false if weight > MAX_STANDARD_TX_WEIGHT
+      return false if features > MAX_STANDARD_VERSION
       inputs.each do |i|
         # Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed keys (remember the 520 byte limit on redeemScript size).
         # That works out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627
@@ -177,21 +107,6 @@ module Tapyrus
       to_payload.bytesize
     end
 
-    # The virtual transaction size (differs from size for witness transactions)
-    def vsize
-      (weight.to_f / 4).ceil
-    end
-
-    # calculate tx weight
-    # weight = (legacy tx payload) * 3 + (witness tx payload)
-    def weight
-      if witness?
-        serialize_old_format.bytesize * (WITNESS_SCALE_FACTOR - 1) + serialize_witness_format.bytesize
-      else
-        serialize_old_format.bytesize * WITNESS_SCALE_FACTOR
-      end
-    end
-
     # get signature hash
     # @param [Integer] input_index input index.
     # @param [Integer] hash_type signature hash type
@@ -205,13 +120,7 @@ module Tapyrus
       raise ArgumentError, 'does not exist input corresponding to input_index.' if input_index >= inputs.size
       raise ArgumentError, 'script_pubkey must be specified.' unless output_script
       raise ArgumentError, 'unsupported sig version specified.' unless SIG_VERSION.include?(sig_version)
-
-      if sig_version == :witness_v0 || Tapyrus.chain_params.fork_chain?
-        raise ArgumentError, 'amount must be specified.' unless amount
-        sighash_for_witness(input_index, output_script, hash_type, amount, skip_separator_index)
-      else
-        sighash_for_legacy(input_index, output_script, hash_type)
-      end
+      sighash_for_legacy(input_index, output_script, hash_type)
     end
 
     # verify input signature.
@@ -220,25 +129,15 @@ module Tapyrus
     # @param [Integer] amount the amount of tapyrus, require for witness program only.
     # @param [Array] flags the flags used when execute script interpreter.
     def verify_input_sig(input_index, script_pubkey, amount: nil, flags: STANDARD_SCRIPT_VERIFY_FLAGS)
-      script_sig = inputs[input_index].script_sig
-      has_witness = inputs[input_index].has_witness?
-
       if script_pubkey.p2sh?
         flags << SCRIPT_VERIFY_P2SH
-        redeem_script = Script.parse_from_payload(script_sig.chunks.last)
-        script_pubkey = redeem_script if redeem_script.p2wpkh?
-      end
-
-      if has_witness || Tapyrus.chain_params.fork_chain?
-        verify_input_sig_for_witness(input_index, script_pubkey, amount, flags)
-      else
-        verify_input_sig_for_legacy(input_index, script_pubkey, flags)
       end
+      verify_input_sig_for_legacy(input_index, script_pubkey, flags)
     end
 
     def to_h
       {
-          txid: txid, hash: witness_hash.rhex, version: version, size: size, vsize: vsize, locktime: lock_time,
+          txid: txid, hash: tx_hash, features: features, size: size, locktime: lock_time,
           vin: inputs.map(&:to_h), vout: outputs.map.with_index{|tx_out, index| tx_out.to_h.merge({n: index})}
       }
     end
@@ -285,40 +184,12 @@ module Tapyrus
         ins = [ins[index]]
       end
 
-      buf = [[version].pack('V'), Tapyrus.pack_var_int(ins.size),
+      buf = [[features].pack('V'), Tapyrus.pack_var_int(ins.size),
           ins, out_size, outs, [lock_time, hash_type].pack('VV')].join
 
       Tapyrus.double_sha256(buf)
     end
 
-    # generate sighash with BIP-143 format
-    # https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki
-    def sighash_for_witness(index, script_pubkey_or_script_code, hash_type, amount, skip_separator_index)
-      hash_prevouts = Tapyrus.double_sha256(inputs.map{|i|i.out_point.to_payload}.join)
-      hash_sequence = Tapyrus.double_sha256(inputs.map{|i|[i.sequence].pack('V')}.join)
-      outpoint = inputs[index].out_point.to_payload
-      amount = [amount].pack('Q')
-      nsequence = [inputs[index].sequence].pack('V')
-      hash_outputs = Tapyrus.double_sha256(outputs.map{|o|o.to_payload}.join)
-
-      script_code = script_pubkey_or_script_code.to_script_code(skip_separator_index)
-
-      case (hash_type & 0x1f)
-      when SIGHASH_TYPE[:single]
-        hash_outputs = index >= outputs.size ? "\x00".ljust(32, "\x00") : Tapyrus.double_sha256(outputs[index].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
-      hash_type |= (Tapyrus.chain_params.fork_id << 8) if Tapyrus.chain_params.fork_chain?
-      buf = [ [version].pack('V'), hash_prevouts, hash_sequence, outpoint,
-              script_code ,amount, nsequence, hash_outputs, [@lock_time, hash_type].pack('VV')].join
-      Tapyrus.double_sha256(buf)
-    end
 
     # verify input signature for legacy tx.
     def verify_input_sig_for_legacy(input_index, script_pubkey, flags)
@@ -329,19 +200,6 @@ module Tapyrus
       interpreter.verify_script(script_sig, script_pubkey)
     end
 
-    # verify input signature for witness tx.
-    def verify_input_sig_for_witness(input_index, script_pubkey, amount, flags)
-      flags |= SCRIPT_VERIFY_WITNESS
-      flags |= SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
-      checker = Tapyrus::TxChecker.new(tx: self, input_index: input_index, amount: amount)
-      interpreter = Tapyrus::ScriptInterpreter.new(checker: checker, flags: flags)
-      i = inputs[input_index]
-
-      script_sig = i.script_sig
-      witness = i.script_witness
-      interpreter.verify_script(script_sig, script_pubkey, witness)
-    end
-
   end
 
 end

data/lib/tapyrus/tx_in.rb

@@ -9,7 +9,6 @@ module Tapyrus
     attr_accessor :out_point
     attr_accessor :script_sig
     attr_accessor :sequence
-    attr_accessor :script_witness
 
     # Setting nSequence to this value for every input in a transaction disables nLockTime.
     SEQUENCE_FINAL = 0xffffffff
@@ -24,10 +23,9 @@ module Tapyrus
     # If TxIn#sequence encodes a relative lock-time, this mask is applied to extract that lock-time from the sequence field.
     SEQUENCE_LOCKTIME_MASK = 0x0000ffff
 
-    def initialize(out_point: nil, script_sig: Tapyrus::Script.new, script_witness: ScriptWitness.new, sequence: SEQUENCE_FINAL)
+    def initialize(out_point: nil, script_sig: Tapyrus::Script.new, sequence: SEQUENCE_FINAL)
       @out_point = out_point
       @script_sig = script_sig
-      @script_witness = script_witness
       @sequence = sequence
     end
 
@@ -37,11 +35,10 @@ module Tapyrus
       hash, index = buf.read(36).unpack('a32V')
       i.out_point = OutPoint.new(hash.bth, index)
       sig_length = Tapyrus.unpack_var_int_from_io(buf)
-      sig = buf.read(sig_length)
-      if i.coinbase?
-        i.script_sig.chunks[0] = sig
+      if sig_length == 0
+        i.script_sig = Script.new
       else
-        i.script_sig = Script.parse_from_payload(sig)
+        i.script_sig = Script.parse_from_payload(buf.read(sig_length))
       end
       i.sequence = buf.read(4).unpack('V').first
       i
@@ -61,15 +58,11 @@ module Tapyrus
       p
     end
 
-    def has_witness?
-      !script_witness.empty?
-    end
 
     def to_h
       sig = script_sig.to_h
       sig.delete(:type)
       h = {txid: out_point.txid, vout: out_point.index,  script_sig: sig }
-      h[:txinwitness] = script_witness.stack.map(&:bth) if has_witness?
       h[:sequence] = sequence
       h
     end

data/lib/tapyrus/tx_out.rb

@@ -7,6 +7,7 @@ module Tapyrus
   class TxOut
 
     include OpenAssets::MarkerOutput
+    include Tapyrus::Color::ColoredOutput
 
     attr_accessor :value
     attr_accessor :script_pubkey
@@ -62,7 +63,7 @@ module Tapyrus
     def dust_threshold
       return 0 if script_pubkey.unspendable?
       n_size = size
-      n_size += script_pubkey.witness_program? ? (32 + 4 + 1 + (107 / Tapyrus::WITNESS_SCALE_FACTOR) + 4) : (32 + 4 + 1 + 107 + 4)
+      n_size += (32 + 4 + 1 + 107 + 4)
       fee = n_size * Tapyrus.chain_params.dust_relay_fee / 1000
       if fee == 0 && n_size != 0
         fee = Tapyrus.chain_params.dust_relay_fee > 0 ? 1 : -1

data/lib/tapyrus/util.rb

@@ -130,4 +130,12 @@ module Tapyrus
 
   end
 
+  module HexConverter
+
+    def to_hex
+      to_payload.bth
+    end
+
+  end
+
 end

data/lib/tapyrus/validation.rb

@@ -13,11 +13,6 @@ module Tapyrus
         return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vout-empty')
       end
 
-      # Size limits (this doesn't take the witness into account, as that hasn't been checked for malleability)
-      if tx.serialize_old_format.bytesize * Tapyrus::WITNESS_SCALE_FACTOR > Tapyrus::MAX_BLOCK_WEIGHT
-        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-oversize')
-      end
-
       # Check for negative or overflow output values
       amount = 0
       tx.outputs.each do |o|
@@ -34,7 +29,7 @@ module Tapyrus
       end
 
       if tx.coinbase_tx?
-        if tx.inputs[0].script_sig.size < 2 || tx.inputs[0].script_sig.size > 100
+        if tx.inputs[0].out_point.index == 0xffffffff || tx.inputs[0].script_sig.size > 100
           return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-cb-length')
         end
       else