tapyrus 0.2.0 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1625f752a1848cec88c87af856ade34417b9f8aa618ee31db66387e60d8e7b8b
-  data.tar.gz: b30ed36b3f4e74f96b57866261b0be40c74883dcfa6605d68a73da99316bb746
+  metadata.gz: 6eacc6d47ecb8c8f955e1713d0245b95185857a313189e232102a24e9dcf43c6
+  data.tar.gz: a961c657873aa82e7f917f55c8b00ea80175b9eb2eb363d72c3c1621f7bee9dc
 SHA512:
-  metadata.gz: 743afb61fcd03ab089bf3124e007d23789b87eac5f35176b3430966814b4ada178f49960dba7240df5f02d7bdfd4b9ef9639c0ca7a9c26d89f9abd498c0ee5ce
-  data.tar.gz: 1300203703bd438cf1e5a54967f9dcc1ee04d7a698a1678ad24b4ef8f3c18b568993790c40de537655d8b20fb06dec35dfaaeef8fe7d1fcc2886366876e18501
+  metadata.gz: 32adab54eb182f5f24536a0b48a89c05756901ba623b054916d7ba5ccc3e034f70147e578917bf847eabdb93070db3b7c628fe3ecc60ebc810ad4603497ec367
+  data.tar.gz: e7c802d4cd4081f0dcbf10c317551c47c7ab90ae764e341dfb55e7f32f91bfb28a0680d1ef915ae322ed15ca1524824df690c9e32e7d29fe27df8e080164f5bf

data/README.md

@@ -12,7 +12,7 @@ Tapyrusrb supports following feature:
 * Tapyrus script interpreter
 * De/serialization of Tapyrus 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.
+* Key generation and verification for Schnorr and 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)
 * [WIP] SPV node
 * [WIP] 0ff-chain protocol

data/lib/schnorr.rb

@@ -76,7 +76,7 @@ module Schnorr
   # @return (Integer) digest e.
   def create_challenge(x, p, message)
     r_x = ECDSA::Format::IntegerOctetString.encode(x, GROUP.byte_length)
-    p_str= ECDSA::Format::PointOctetString.encode(p, compression:true)
+    p_str= p.to_hex.htb
     (ECDSA.normalize_digest(Digest::SHA256.digest(r_x + p_str + message), GROUP.bit_length)) % GROUP.order
   end
 

data/lib/tapyrus.rb

@@ -48,8 +48,10 @@ module Tapyrus
   autoload :KeyPath, 'tapyrus/key_path'
   autoload :SLIP39, 'tapyrus/slip39'
   autoload :Color, 'tapyrus/script/color'
+  autoload :Errors, 'tapyrus/errors'
 
   require_relative 'tapyrus/constants'
+  require_relative 'tapyrus/ext/ecdsa'
 
   extend Util
 
@@ -207,11 +209,4 @@ module Tapyrus
     end
   end
 
-  class ::ECDSA::Signature
-    # convert signature to der string.
-    def to_der
-      ECDSA::Format::SignatureDerString.encode(self)
-    end
-  end
-
 end

data/lib/tapyrus/block.rb

@@ -1,5 +1,6 @@
 module Tapyrus
   class Block
+    include Tapyrus::Util
 
     attr_accessor :header
     attr_accessor :transactions
@@ -32,14 +33,9 @@ module Tapyrus
     end
 
     # return this block height. block height is included in coinbase.
-    # if block version under 1, height does not include in coinbase, so return nil.
+    # @return [Integer] block height.
     def height
-      return nil if header.features < 2
-      coinbase_tx = transactions[0]
-      return nil unless coinbase_tx.coinbase_tx?
-      buf = StringIO.new(coinbase_tx.inputs[0].script_sig.to_payload)
-      len = Tapyrus.unpack_var_int_from_io(buf)
-      buf.read(len).reverse.bth.to_i(16)
+      transactions.first.in.first.out_point.index
     end
 
   end

data/lib/tapyrus/block_header.rb

@@ -3,61 +3,69 @@ module Tapyrus
   # Block Header
   class BlockHeader
     include Tapyrus::HexConverter
+    extend Tapyrus::Util
+    include Tapyrus::Util
+
+    X_FILED_TYPES = {none: 0, aggregate_pubkey: 1}
 
     attr_accessor :features
     attr_accessor :prev_hash
     attr_accessor :merkle_root
-    attr_accessor :time # unix timestamp
-    attr_accessor :bits
-    attr_accessor :nonce
+    attr_accessor :im_merkle_root # merkel root of immulable merkle tree which consist of immutable txid.
+    attr_accessor :time           # unix timestamp
+    attr_accessor :x_field_type
+    attr_accessor :x_field
+    attr_accessor :proof
 
-    def initialize(features, prev_hash, merkle_root, time, bits, nonce)
+    def initialize(features, prev_hash, merkle_root, im_merkle_root, time, x_field_type, x_field, proof = nil)
       @features = features
       @prev_hash = prev_hash
       @merkle_root = merkle_root
+      @im_merkle_root = im_merkle_root
       @time = time
-      @bits = bits
-      @nonce = nonce
+      @x_field_type = x_field_type
+      @x_field = x_field
+      @proof = proof
     end
 
     def self.parse_from_payload(payload)
-      features, prev_hash, merkle_root, time, bits, nonce = payload.unpack('Va32a32VVV')
-      new(features, prev_hash.bth, merkle_root.bth, time, bits, nonce)
-    end
-
-    def to_payload
-      [features, prev_hash.htb, merkle_root.htb, time, bits, nonce].pack('Va32a32VVV')
+      buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+      features, prev_hash, merkle_root, im_merkle_root, time, x_filed_type = buf.read(105).unpack('Va32a32a32Vc')
+      x_field = buf.read(unpack_var_int_from_io(buf)) unless x_filed_type == X_FILED_TYPES[:none]
+      proof = buf.read(unpack_var_int_from_io(buf))
+      new(features, prev_hash.bth, merkle_root.bth, im_merkle_root.bth, time, x_filed_type, x_field ? x_field.bth : x_field, proof.bth)
     end
 
-    # compute difficulty target from bits.
-    def difficulty_target
-      exponent = ((bits >> 24) & 0xff)
-      mantissa = bits & 0x7fffff
-      mantissa *= -1 if (bits & 0x800000) > 0
-      (mantissa * 2 ** (8 * (exponent - 3)))
+    def to_payload(skip_proof = false)
+      payload = [features, prev_hash.htb, merkle_root.htb, im_merkle_root.htb, time, x_field_type].pack('Va32a32a32Vc')
+      payload << pack_var_string(x_field.htb) unless x_field_type == X_FILED_TYPES[:none]
+      payload << pack_var_string(proof.htb) if proof && !skip_proof
+      payload
     end
 
-    def hash
-      calc_hash.to_i(16)
+    # Calculate hash using sign which does not contains proof.
+    # @return [String] hash of block without proof.
+    def hash_for_sign
+      Tapyrus.double_sha256(to_payload(true)).bth
     end
 
+    # Calculate block hash
+    # @return [String] hash of block with hex format.
     def block_hash
-      calc_hash
+      Tapyrus.double_sha256(to_payload).bth
     end
 
     # block hash(big endian)
+    # @return [String] block id which is reversed version of block hash.
     def block_id
       block_hash.rhex
     end
 
     # evaluate block header
-    def valid?
-      valid_pow? && valid_timestamp?
-    end
-
-    # evaluate valid proof of work.
-    def valid_pow?
-      block_id.hex < difficulty_target
+    # @param [String] agg_pubkey aggregated public key for signers with hex format.
+    # @return [Boolean] result.
+    def valid?(agg_pubkey)
+      valid_timestamp? && valid_proof?(agg_pubkey) && valid_x_field?
     end
 
     # evaluate valid timestamp.
@@ -66,22 +74,42 @@ module Tapyrus
       time <= Time.now.to_i + Tapyrus::MAX_FUTURE_BLOCK_TIME
     end
 
-    # compute chain work of this block.
-    # @return [Integer] a chain work.
-    def work
-      target = difficulty_target
-      return 0 if target < 1
-      115792089237316195423570985008687907853269984665640564039457584007913129639936.div(target + 1) # 115792089237316195423570985008687907853269984665640564039457584007913129639936 is 2**256
+    # Check whether proof is valid.
+    # @param [String] agg_pubkey aggregated public key for signers with hex format.
+    # @return [Boolean] Return true if proof is valid, otherwise return false.
+    def valid_proof?(agg_pubkey)
+      pubkey = Tapyrus::Key.new(pubkey: agg_pubkey)
+      msg = hash_for_sign.htb
+      pubkey.verify(proof.htb, msg, algo: :schnorr)
+    end
+
+    # Check whether x_field is valid.
+    # @return [Boolean] if valid return true, otherwise false
+    def valid_x_field?
+      case x_field_type
+      when X_FILED_TYPES[:none] then
+        x_field.nil?
+      when X_FILED_TYPES[:aggregate_pubkey] then
+        Tapyrus::Key.new(pubkey: x_field).fully_valid_pubkey?
+      else
+        false
+      end
+    end
+
+    # Check this header contains upgrade aggregated publiec key.
+    # @return [Boolean] if contains return true, otherwise false.
+    def upgrade_agg_pubkey?
+      x_field_type == X_FILED_TYPES[:aggregate_pubkey]
     end
 
     def ==(other)
       other && other.to_payload == to_payload
     end
 
-    private
-
-    def calc_hash
-      Tapyrus.double_sha256(to_payload).bth
+    # get bytesize.
+    # @return [Integer] bytesize.
+    def size
+      to_payload.bytesize
     end
 
   end

data/lib/tapyrus/chain_params.rb

@@ -33,12 +33,10 @@ module Tapyrus
     attr_reader :bip34_height
     attr_reader :proof_of_work_limit
     attr_reader :dns_seeds
-    attr_reader :genesis
     attr_reader :bip44_coin_type
 
     attr_accessor :dust_relay_fee
 
-
     # production genesis
     def self.prod
       init('prod')
@@ -57,14 +55,6 @@ module Tapyrus
       network == 'dev'
     end
 
-    def genesis_block
-      header = Tapyrus::BlockHeader.new(
-          genesis['version'], genesis['prev_hash'].rhex, genesis['merkle_root'].rhex,
-          genesis['time'], genesis['bits'], genesis['nonce'])
-      Tapyrus::Block.new(header)
-    end
-
-
     def self.init(name)
       i = YAML.load(File.open("#{__dir__}/chainparams/#{name}.yml"))
       i.dust_relay_fee ||= Tapyrus::DUST_RELAY_TX_FEE

data/lib/tapyrus/chainparams/dev.yml

@@ -25,15 +25,5 @@ retarget_time: 1209600 # 2 weeks
 target_spacing: 600 # block interval
 max_money: 21000000
 bip34_height: 227931
-genesis_hash: "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
-proof_of_work_limit: 0x1d00ffff
 dns_seeds:
-genesis:
-  hash: "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
-  merkle_root: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
-  time: 1296688602
-  nonce: 414098458
-  bits: 0x1d00ffff
-  version: 1
-  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"
 bip44_coin_type: 1

data/lib/tapyrus/chainparams/prod.yml

@@ -25,14 +25,5 @@ retarget_time: 1209600 # 2 weeks
 target_spacing: 600 # block interval
 max_money: 21000000
 bip34_height: 227931
-proof_of_work_limit: 0x1d00ffff
 dns_seeds:
-genesis:
-  hash: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
-  merkle_root: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
-  time: 1231006505
-  nonce: 2083236893
-  bits: 0x1d00ffff
-  version: 1
-  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"
 bip44_coin_type: 0

data/lib/tapyrus/errors.rb

@@ -0,0 +1,17 @@
+module Tapyrus
+  module Errors
+    module Messages
+
+      INVALID_PUBLIC_KEY = 'Invalid public key.'
+      INVALID_BIP32_PRIV_PREFIX = 'Invalid BIP32 private key prefix. prefix must be 0x00.'
+      INVALID_BIP32_FINGERPRINT = 'Invalid parent fingerprint.'
+      INVALID_BIP32_ZERO_INDEX = 'Invalid index. Depth 0 must have 0 index.'
+      INVALID_BIP32_ZERO_DEPTH = 'Invalid depth. Master key must have 0 depth.'
+      INVALID_BIP32_VERSION = 'An unsupported version byte was specified.'
+
+      INVALID_PRIV_KEY = 'Private key is not in range [1..n-1].'
+      INVALID_CHECKSUM = 'Invalid checksum.'
+
+    end
+  end
+end

data/lib/tapyrus/ext/ecdsa.rb

@@ -0,0 +1,39 @@
+class ::ECDSA::Signature
+  # convert signature to der string.
+  def to_der
+    ECDSA::Format::SignatureDerString.encode(self)
+  end
+end
+
+class ::ECDSA::Point
+  def to_hex(compression = true)
+    ECDSA::Format::PointOctetString.encode(self, compression: compression).bth
+  end
+end
+
+module ::ECDSA::Format::PointOctetString
+
+  def self.decode(string, group, allow_hybrid: false)
+    string = string.dup.force_encoding('BINARY')
+
+    raise ECDSA::Format::DecodeError, 'Point octet string is empty.' if string.empty?
+
+    case string[0].ord
+    when 0
+      check_length string, 1
+      return group.infinity
+    when 2
+      decode_compressed string, group, 0
+    when 3
+      decode_compressed string, group, 1
+    when 4
+      decode_uncompressed string, group
+    when 6..7
+      raise DecodeError, 'Unrecognized start byte for point octet string: 0x%x' % string[0].ord unless allow_hybrid
+      decode_uncompressed string, group if allow_hybrid
+    else
+      raise ECDSA::Format::DecodeError, 'Unrecognized start byte for point octet string: 0x%x' % string[0].ord
+    end
+  end
+
+end

data/lib/tapyrus/ext_key.rb

@@ -7,6 +7,9 @@ module Tapyrus
   class ExtKey
     include Tapyrus::HexConverter
 
+    MAX_DEPTH = 255
+    MASTER_FINGERPRINT = '00000000'
+
     attr_accessor :ver
     attr_accessor :depth
     attr_accessor :number
@@ -20,7 +23,7 @@ module Tapyrus
       ext_key = ExtKey.new
       ext_key.depth = ext_key.number = 0
       ext_key.parent_fingerprint = '00000000'
-      l = Tapyrus.hmac_sha512('Bitcoin seed', seed.htb)
+      l = Tapyrus.hmac_sha512('Tapyrus seed', seed.htb)
       left = l[0..31].bth.to_i(16)
       raise 'invalid key' if left >= CURVE_ORDER || left == 0
       ext_key.key = Tapyrus::Key.new(priv_key: l[0..31].bth, key_type: Tapyrus::Key::TYPES[:compressed])
@@ -48,9 +51,7 @@ module Tapyrus
 
     # Base58 encoded extended private key
     def to_base58
-      h = to_hex
-      hex = h + Tapyrus.calc_checksum(h)
-      Base58.encode(hex)
+      ExtPubkey.encode_base58(to_hex)
     end
 
     # get private key(hex)
@@ -141,19 +142,24 @@ module Tapyrus
       buf = StringIO.new(payload)
       ext_key = ExtKey.new
       ext_key.ver = buf.read(4).bth # version
-      raise 'An unsupported version byte was specified.' unless ExtKey.support_version?(ext_key.ver)
+      raise ArgumentError, Errors::Messages::INVALID_BIP32_VERSION unless ExtKey.support_version?(ext_key.ver)
       ext_key.depth = buf.read(1).unpack('C').first
       ext_key.parent_fingerprint = buf.read(4).bth
       ext_key.number = buf.read(4).unpack('N').first
+      if ext_key.depth == 0
+        raise ArgumentError, Errors::Messages::INVALID_BIP32_FINGERPRINT unless ext_key.parent_fingerprint == ExtKey::MASTER_FINGERPRINT
+        raise ArgumentError, Errors::Messages::INVALID_BIP32_ZERO_INDEX if ext_key.number > 0
+      end
+      raise ArgumentError, Errors::Messages:: INVALID_BIP32_ZERO_DEPTH if ext_key.parent_fingerprint == ExtKey::MASTER_FINGERPRINT && ext_key.depth > 0
       ext_key.chain_code = buf.read(32)
-      buf.read(1) # 0x00
+      raise ArgumentError, Errors::Messages::INVALID_BIP32_PRIV_PREFIX unless buf.read(1).bth == '00' # 0x00
       ext_key.key = Tapyrus::Key.new(priv_key: buf.read(32).bth, key_type: Tapyrus::Key::TYPES[:compressed])
       ext_key
     end
 
     # import private key from Base58 private key address
     def self.from_base58(address)
-      ExtKey.parse_from_payload(Base58.decode(address).htb)
+      ExtKey.parse_from_payload(ExtPubkey.validate_checksum(address))
     end
 
     # get version bytes from purpose' value.
@@ -237,9 +243,14 @@ module Tapyrus
 
     # Base58 encoded extended pubkey
     def to_base58
-      h = to_hex
-      hex = h + Tapyrus.calc_checksum(h)
-      Base58.encode(hex)
+      ExtPubkey.encode_base58(to_hex)
+    end
+
+    # Generate Base58 encoded key from BIP32 payload with hex format.
+    # @param [String] hex BIP32 payload with hex format.
+    # @return [String] Base58 encoded extended key.
+    def self.encode_base58(hex)
+      Base58.encode(hex + Tapyrus.calc_checksum(hex))
     end
 
     # whether hardened key.
@@ -260,7 +271,7 @@ module Tapyrus
       raise 'invalid key' if left >= CURVE_ORDER
       p1 = Tapyrus::Secp256k1::GROUP.generator.multiply_by_scalar(left)
       p2 = Tapyrus::Key.new(pubkey: pubkey, key_type: key_type).to_point
-      new_key.pubkey = ECDSA::Format::PointOctetString.encode(p1 + p2, compression: true).bth
+      new_key.pubkey = (p1 + p2).to_hex
       new_key.chain_code = l[32..-1]
       new_key.ver = version
       new_key
@@ -293,19 +304,32 @@ module Tapyrus
       buf = StringIO.new(payload)
       ext_pubkey = ExtPubkey.new
       ext_pubkey.ver = buf.read(4).bth # version
-      raise 'An unsupported version byte was specified.' unless ExtPubkey.support_version?(ext_pubkey.ver)
+      raise ArgumentError, Errors::Messages::INVALID_BIP32_VERSION unless ExtPubkey.support_version?(ext_pubkey.ver)
       ext_pubkey.depth = buf.read(1).unpack('C').first
       ext_pubkey.parent_fingerprint = buf.read(4).bth
       ext_pubkey.number = buf.read(4).unpack('N').first
+      if ext_pubkey.depth == 0
+        raise ArgumentError, Errors::Messages::INVALID_BIP32_FINGERPRINT unless ext_pubkey.parent_fingerprint == ExtKey::MASTER_FINGERPRINT
+        raise ArgumentError, Errors::Messages::INVALID_BIP32_ZERO_INDEX if ext_pubkey.number > 0
+      end
+      raise ArgumentError, Errors::Messages::INVALID_BIP32_ZERO_DEPTH if ext_pubkey.parent_fingerprint == ExtKey::MASTER_FINGERPRINT && ext_pubkey.depth > 0
       ext_pubkey.chain_code = buf.read(32)
-      ext_pubkey.pubkey = buf.read(33).bth
+      ext_pubkey.pubkey = Tapyrus::Key.new(pubkey: buf.read(33).bth).pubkey
       ext_pubkey
     end
 
-
     # import pub key from Base58 private key address
     def self.from_base58(address)
-      ExtPubkey.parse_from_payload(Base58.decode(address).htb)
+      ExtPubkey.parse_from_payload(ExtPubkey.validate_checksum(address))
+    end
+
+    # Validate address checksum and return payload.
+    # @param [String] BIP32 Base58 address
+    # @return [String] BIP32 payload with binary format
+    def self.validate_checksum(base58)
+      raw = Base58.decode(base58)
+      raise ArgumentError, Errors::Messages::INVALID_CHECKSUM unless Tapyrus.calc_checksum(raw[0...-8]) == raw[-8..-1]
+      raw[0...-8].htb
     end
 
     # get version bytes from purpose' value.

data/lib/tapyrus/key.rb

@@ -30,7 +30,7 @@ module Tapyrus
     # @param [Integer] key_type a key type which determine address type.
     # @param [Boolean] compressed [Deprecated] whether public key is compressed.
     # @return [Tapyrus::Key] a key object.
-    def initialize(priv_key: nil, pubkey: nil, key_type: nil, compressed: true)
+    def initialize(priv_key: nil, pubkey: nil, key_type: nil, compressed: true, allow_hybrid: false)
       puts "[Warning] Use key_type parameter instead of compressed. compressed parameter removed in the future." if key_type.nil? && !compressed.nil? && pubkey.nil?
       if key_type
         @key_type = key_type
@@ -41,13 +41,14 @@ module Tapyrus
       @secp256k1_module =  Tapyrus.secp_impl
       @priv_key = priv_key
       if @priv_key
-        raise ArgumentError, 'private key is not on curve' unless validate_private_key_range(@priv_key)
+        raise ArgumentError, Errors::Messages::INVALID_PRIV_KEY unless validate_private_key_range(@priv_key)
       end
       if pubkey
         @pubkey = pubkey
       else
         @pubkey = generate_pubkey(priv_key, compressed: compressed) if priv_key
       end
+      raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless fully_valid_pubkey?(allow_hybrid)
     end
 
     # generate key pair
@@ -65,7 +66,7 @@ module Tapyrus
       data = hex[2...-8].htb
       checksum = hex[-8..-1]
       raise ArgumentError, 'invalid version' unless version == Tapyrus.chain_params.privkey_version
-      raise ArgumentError, 'invalid checksum' unless Tapyrus.calc_checksum(version + data.bth) == checksum
+      raise ArgumentError, Errors::Messages::INVALID_CHECKSUM unless Tapyrus.calc_checksum(version + data.bth) == checksum
       key_len = data.bytesize
       if key_len == COMPRESSED_PUBLIC_KEY_SIZE && data[-1].unpack('C').first == 1
         key_type = TYPES[:compressed]
@@ -95,10 +96,13 @@ module Tapyrus
     # @return [String] signature data with binary format
     def sign(data, low_r = true, extra_entropy = nil, algo: :ecdsa)
       raise ArgumentError, "Unsupported algorithm has been specified." unless SIG_ALGO.include?(algo)
-      if algo == :ecdsa
+      case algo
+      when :ecdsa
         sign_ecdsa(data, low_r, extra_entropy)
+      when :schnorr
+        secp256k1_module.sign_data(data, priv_key, extra_entropy, algo: algo)
       else
-        sign_schnorr(data)
+        false
       end
     end
 
@@ -111,11 +115,8 @@ module Tapyrus
       return false unless valid_pubkey?
       begin
         raise ArgumentError, "Unsupported algorithm has been specified." unless SIG_ALGO.include?(algo)
-        if algo == :ecdsa
-          verify_ecdsa_sig(sig, origin)
-        else
-          verify_schnorr_sig(sig, origin)
-        end
+        sig = ecdsa_signature_parse_der_lax(sig) if algo == :ecdsa
+        secp256k1_module.verify_sig(origin, sig, pubkey, algo: algo)
       rescue Exception
         false
       end
@@ -223,14 +224,8 @@ module Tapyrus
     end
 
     # fully validate whether this is a valid public key (more expensive than IsValid())
-    def fully_valid_pubkey?
-      return false unless valid_pubkey?
-      begin
-        point = ECDSA::Format::PointOctetString.decode(pubkey.htb, ECDSA::Group::Secp256k1)
-        ECDSA::Group::Secp256k1.valid_public_key?(point)
-      rescue ECDSA::Format::DecodeError
-        false
-      end
+    def fully_valid_pubkey?(allow_hybrid = false)
+      valid_pubkey? && secp256k1_module.parse_ec_pubkey?(pubkey, allow_hybrid)
     end
 
     private
@@ -291,34 +286,18 @@ module Tapyrus
 
     # generate ecdsa signature
     def sign_ecdsa(data, low_r, extra_entropy)
-      sig = secp256k1_module.sign_data(data, priv_key, extra_entropy)
+      sig = secp256k1_module.sign_data(data, priv_key, extra_entropy, algo: :ecdsa)
       if low_r && !sig_has_low_r?(sig)
         counter = 1
         until sig_has_low_r?(sig)
           extra_entropy = [counter].pack('I*').bth.ljust(64, '0').htb
-          sig = secp256k1_module.sign_data(data, priv_key, extra_entropy)
+          sig = secp256k1_module.sign_data(data, priv_key, extra_entropy,  algo: :ecdsa)
           counter += 1
         end
       end
       sig
     end
 
-    # generate schnorr signature
-    def sign_schnorr(msg)
-      Schnorr.sign(msg, priv_key.to_i(16)).encode
-    end
-
-    # verify ecdsa signature
-    def verify_ecdsa_sig(sig, message)
-      sig = ecdsa_signature_parse_der_lax(sig)
-      secp256k1_module.verify_sig(message, sig, pubkey)
-    end
-
-    # verify schnorr signature
-    def verify_schnorr_sig(sig, message)
-      Schnorr.valid_sig?(message, sig, pubkey.htb)
-    end
-
   end
 
 end

data/lib/tapyrus/message/block.rb

@@ -19,7 +19,7 @@ module Tapyrus
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        header = Tapyrus::BlockHeader.parse_from_payload(buf.read(80))
+        header = Tapyrus::BlockHeader.parse_from_payload(buf)
         transactions = []
         unless buf.eof?
           tx_count = Tapyrus.unpack_var_int_from_io(buf)

data/lib/tapyrus/message/header_and_short_ids.rb

@@ -21,7 +21,7 @@ module Tapyrus
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        header = Tapyrus::BlockHeader.parse_from_payload(buf.read(80))
+        header = Tapyrus::BlockHeader.parse_from_payload(buf)
         nonce = buf.read(8).unpack('q*').first
         short_ids_len = Tapyrus.unpack_var_int_from_io(buf)
         short_ids = short_ids_len.times.map do

data/lib/tapyrus/message/headers.rb

@@ -19,7 +19,7 @@ module Tapyrus
         header_count = Tapyrus.unpack_var_int_from_io(buf)
         h = new
         header_count.times do
-          h.headers << Tapyrus::BlockHeader.parse_from_payload(buf.read(80))
+          h.headers << Tapyrus::BlockHeader.parse_from_payload(buf)
           buf.read(1) # read tx count 0x00 (headers message doesn't include any tx.)
         end
         h

data/lib/tapyrus/message/merkle_block.rb

@@ -19,7 +19,7 @@ module Tapyrus
       def self.parse_from_payload(payload)
         m = new
         buf = StringIO.new(payload)
-        m.header = Tapyrus::BlockHeader.parse_from_payload(buf.read(80))
+        m.header = Tapyrus::BlockHeader.parse_from_payload(buf)
         m.tx_count = buf.read(4).unpack('V').first
         hash_count = Tapyrus.unpack_var_int_from_io(buf)
         hash_count.times do

data/lib/tapyrus/rpc/request_handler.rb

@@ -11,7 +11,6 @@ module Tapyrus
         best_block = node.chain.latest_block
         h[:headers] = best_block.height
         h[:bestblockhash] = best_block.header.block_id
-        h[:chainwork] = best_block.header.work
         h[:mediantime] = node.chain.mtp(best_block.block_hash)
         h
       end
@@ -32,12 +31,14 @@ module Tapyrus
               hash: block_id,
               height: entry.height,
               features: entry.header.features,
-              featuresHex: entry.header.features.to_even_length_hex,
+              featuresHex: entry.header.features.to_even_length_hex.ljust(8, '0'),
               merkleroot: entry.header.merkle_root.rhex,
+              immutablemerkleroot: entry.header.im_merkle_root.rhex,
               time: entry.header.time,
               mediantime: node.chain.mtp(block_hash),
-              nonce: entry.header.nonce,
-              bits: entry.header.bits.to_even_length_hex,
+              xfield_type: entry.header.x_field_type,
+              xfield: entry.header.x_field,
+              proof: entry.header.proof,
               previousblockhash: entry.prev_hash.rhex,
               nextblockhash: node.chain.next_hash(block_hash).rhex
           }

data/lib/tapyrus/rpc/tapyrus_core_client.rb

@@ -57,14 +57,14 @@ module Tapyrus
         uri = URI.parse(server_url)
         http = Net::HTTP.new(uri.hostname, uri.port)
         http.use_ssl = uri.scheme === "https"
-        request = Net::HTTP::Post.new('/')
+        request = Net::HTTP::Post.new(uri.path.empty? ? '/' : uri.path)
         request.basic_auth(uri.user, uri.password)
         request.content_type = 'application/json'
         request.body = data.to_json
         response = http.request(request)
         body = response.body
         response = Tapyrus::Ext::JsonParser.new(body.gsub(/\\u([\da-fA-F]{4})/) { [$1].pack('H*').unpack('n*').pack('U*').encode('ISO-8859-1').force_encoding('UTF-8') }).parse
-        raise response['error'].to_s if response['error']
+        raise response['error'].to_json if response['error']
         response['result']
       end
 

data/lib/tapyrus/script/color.rb

@@ -53,11 +53,11 @@ module Tapyrus
 
     module ColoredOutput
       def colored?
-        script_pubkey.cp2pkh? || script_pubkey.cp2sh?
+        script_pubkey.colored?
       end
 
       def color_id
-        @color_id ||= ColorIdentifier.parse_from_payload(script_pubkey.chunks[0].pushed_data)
+        @color_id ||= script_pubkey.color_id
       end
 
       def reissuable?

data/lib/tapyrus/script/script.rb

@@ -75,6 +75,18 @@ module Tapyrus
       end
     end
 
+    # Remove color identifier from cp2pkh or cp2sh
+    # @param [ColorIdentifier] color identifier
+    # @return [Script] P2PKH or P2SH script
+    # @raise [RuntimeError] if script is neither cp2pkh nor cp2sh
+    def remove_color
+      raise RuntimeError, 'Only cp2pkh and cp2sh can remove color' unless cp2pkh? or cp2sh?
+
+      Tapyrus::Script.new.tap do |s|
+        s.chunks = self.chunks[2..-1]
+      end
+    end
+
     def get_multisig_pubkeys
       num = Tapyrus::Opcodes.opcode_to_small_int(chunks[-2].bth.to_i(16))
       (1..num).map{ |i| chunks[i].pushed_data }
@@ -214,6 +226,8 @@ module Tapyrus
           (chunks.size == 1 || chunks[1].opcode <= OP_16)
     end
 
+    # Return whether this script is a CP2PKH format script or not.
+    # @return [Boolean] true if this script is cp2pkh, otherwise false.
     def cp2pkh?
       return false unless chunks.size == 7
       return false unless chunks[0].bytesize == 34
@@ -223,6 +237,8 @@ module Tapyrus
           (chunks[2..3]+ chunks[5..6]).map(&:ord) && chunks[4].bytesize == 21
     end
 
+    # Return whether this script is a CP2SH format script or not.
+    # @return [Boolean] true if this script is cp2pkh, otherwise false.
     def cp2sh?
       return false unless chunks.size == 5
       return false unless chunks[0].bytesize == 34
@@ -230,6 +246,20 @@ module Tapyrus
       return false unless chunks[1].ord == OP_COLOR
       OP_HASH160 == chunks[2].ord && OP_EQUAL == chunks[4].ord && chunks[3].bytesize == 21
     end
+  
+    # Return whether this script represents colored coin.
+    # @return [Boolean] true if this script is colored, otherwise false.
+    def colored?
+      cp2pkh? || cp2sh?
+    end
+
+    # Return color identifier for this script.
+    # @return [ColorIdentifer] color identifier for this script if this script is colored. return nil if this script is not colored.
+    def color_id
+      return nil unless colored?
+
+      Tapyrus::Color::ColorIdentifier.parse_from_payload(chunks[0].pushed_data)
+    end
 
     def op_return_data
       return nil unless op_return?

data/lib/tapyrus/script/tx_checker.rb

@@ -32,12 +32,16 @@ module Tapyrus
     # @param [String] pubkey a public key with hex format.
     # @param [String] digest a message digest with binary format to be verified.
     # @return [Boolean] if check is passed return true, otherwise false.
-    def verify_sig(sig, pubkey, digest)
+    def verify_sig(sig, pubkey, digest, allow_hybrid: false)
       key_type = pubkey.start_with?('02') || pubkey.start_with?('03') ? Key::TYPES[:compressed] : Key::TYPES[:uncompressed]
       sig = sig.htb
       algo = sig.bytesize == 64 ? :schnorr : :ecdsa
-      key = Key.new(pubkey: pubkey, key_type: key_type)
-      key.verify(sig, digest, algo: algo)
+      begin
+        key = Key.new(pubkey: pubkey, key_type: key_type, allow_hybrid: allow_hybrid)
+        key.verify(sig, digest, algo: algo)
+      rescue Exception
+        false
+      end
     end
 
     def check_locktime(locktime)

data/lib/tapyrus/secp256k1/native.rb

@@ -4,8 +4,8 @@
 module Tapyrus
   module Secp256k1
 
-    # binding for secp256k1 (https://github.com/bitcoin/bitcoin/tree/v0.14.2/src/secp256k1)
-    # tag: v0.14.2
+    # binding for secp256k1 (https://github.com/chaintope/tapyrus-core/tree/v0.4.0/src/secp256k1)
+    # tag: v0.4.0
     # this is not included by default, to enable set shared object path to ENV['SECP256K1_LIB_PATH']
     # for linux, ENV['SECP256K1_LIB_PATH'] = '/usr/local/lib/libsecp256k1.so'
     # for mac,
@@ -50,6 +50,8 @@ module Tapyrus
         attach_function(:secp256k1_ecdsa_signature_parse_der, [:pointer, :pointer, :pointer, :size_t], :int)
         attach_function(:secp256k1_ecdsa_signature_normalize, [:pointer, :pointer, :pointer], :int)
         attach_function(:secp256k1_ecdsa_verify, [:pointer, :pointer, :pointer, :pointer], :int)
+        attach_function(:secp256k1_schnorr_sign, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int)
+        attach_function(:secp256k1_schnorr_verify, [:pointer, :pointer, :pointer, :pointer], :int)
       end
 
       def with_context(flags: (SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN))
@@ -100,7 +102,68 @@ module Tapyrus
       # @param [String] privkey a private key using sign
       # @param [String] extra_entropy a extra entropy for rfc6979
       # @return [String] signature data with binary format
-      def sign_data(data, privkey, extra_entropy)
+      def sign_data(data, privkey, extra_entropy, algo: :ecdsa)
+        case algo
+        when :ecdsa
+          sign_ecdsa(data, privkey, extra_entropy)
+        when :schnorr
+          sign_schnorr(data, privkey)
+        else
+          nil
+        end
+      end
+
+      # verify signature.
+      # @param[String] data a data.
+      # @param [String] sig signature data with binary format
+      # @param [String] pub_key a public key using verify.
+      def verify_sig(data, sig, pub_key, algo: :ecdsa)
+        case algo
+        when :ecdsa
+          verify_ecdsa(data, sig, pub_key)
+        when :schnorr
+          verify_schnorr(data, sig, pub_key)
+        else
+          false
+        end
+      end
+
+      # # validate whether this is a valid public key (more expensive than IsValid())
+      # @param [String] pub_key public key with hex format.
+      # @param [Boolean] allow_hybrid whether support hybrid public key.
+      # @return [Boolean] If valid public key return true, otherwise false.
+      def parse_ec_pubkey?(pub_key, allow_hybrid = false)
+        pub_key = pub_key.htb
+        return false if !allow_hybrid && ![0x02, 0x03, 0x04].include?(pub_key[0].ord)
+        with_context do |context|
+          pubkey = FFI::MemoryPointer.new(:uchar, pub_key.bytesize).put_bytes(0, pub_key)
+          internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
+          result = secp256k1_ec_pubkey_parse(context, internal_pubkey, pubkey, pub_key.bytesize)
+          result == 1
+        end
+      end
+
+      private
+
+      def generate_pubkey_in_context(context, privkey, compressed: true)
+        internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
+        result = secp256k1_ec_pubkey_create(context, internal_pubkey, privkey.htb)
+        raise 'error creating pubkey' unless result
+
+        pubkey = FFI::MemoryPointer.new(:uchar, 65)
+        pubkey_len = FFI::MemoryPointer.new(:uint64)
+        result = if compressed
+                   pubkey_len.put_uint64(0, 33)
+                   secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_COMPRESSED)
+                 else
+                   pubkey_len.put_uint64(0, 65)
+                   secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_UNCOMPRESSED)
+                 end
+        raise 'error serialize pubkey' unless result || pubkey_len.read_uint64 > 0
+        pubkey.read_string(pubkey_len.read_uint64).bth
+      end
+
+      def sign_ecdsa(data, privkey, extra_entropy)
         with_context do |context|
           secret = FFI::MemoryPointer.new(:uchar, privkey.htb.bytesize).put_bytes(0, privkey.htb)
           raise 'priv_key invalid' unless secp256k1_ec_seckey_verify(context, secret)
@@ -126,7 +189,19 @@ module Tapyrus
         end
       end
 
-      def verify_sig(data, sig, pub_key)
+      def sign_schnorr(data, privkey)
+        with_context do |context|
+          secret = FFI::MemoryPointer.new(:uchar, privkey.htb.bytesize).put_bytes(0, privkey.htb)
+          raise 'priv_key invalid' unless secp256k1_ec_seckey_verify(context, secret)
+
+          signature = FFI::MemoryPointer.new(:uchar, 64)
+          msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
+          raise 'Failed to generate schnorr signature.' unless secp256k1_schnorr_sign(context, signature, msg32, secret, nil, nil) == 1
+          signature.read_string(64)
+        end
+      end
+
+      def verify_ecdsa(data, sig, pub_key)
         with_context do |context|
           return false if data.bytesize == 0
 
@@ -150,25 +225,23 @@ module Tapyrus
         end
       end
 
-      private
+      def verify_schnorr(data, sig, pub_key)
+        with_context do |context|
+          return false if data.bytesize == 0
+          pubkey = FFI::MemoryPointer.new(:uchar, pub_key.htb.bytesize).put_bytes(0, pub_key.htb)
+          internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
+          result = secp256k1_ec_pubkey_parse(context, internal_pubkey, pubkey, pubkey.size)
+          return false unless result
 
-      def generate_pubkey_in_context(context, privkey, compressed: true)
-        internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
-        result = secp256k1_ec_pubkey_create(context, internal_pubkey, privkey.htb)
-        raise 'error creating pubkey' unless result
+          signature = FFI::MemoryPointer.new(:uchar, sig.bytesize).put_bytes(0, sig)
 
-        pubkey = FFI::MemoryPointer.new(:uchar, 65)
-        pubkey_len = FFI::MemoryPointer.new(:uint64)
-        result = if compressed
-                   pubkey_len.put_uint64(0, 33)
-                   secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_COMPRESSED)
-                 else
-                   pubkey_len.put_uint64(0, 65)
-                   secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_UNCOMPRESSED)
-                 end
-        raise 'error serialize pubkey' unless result || pubkey_len.read_uint64 > 0
-        pubkey.read_string(pubkey_len.read_uint64).bth
+          msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
+          result = secp256k1_schnorr_verify(context, signature, msg32, internal_pubkey)
+
+          result == 1
+        end
       end
+
     end
   end
 end

data/lib/tapyrus/secp256k1/ruby.rb

@@ -12,8 +12,8 @@ module Tapyrus
         private_key = 1 + SecureRandom.random_number(GROUP.order - 1)
         public_key = GROUP.generator.multiply_by_scalar(private_key)
         privkey = ECDSA::Format::IntegerOctetString.encode(private_key, 32)
-        pubkey = ECDSA::Format::PointOctetString.encode(public_key, compression: compressed)
-        [privkey.bth, pubkey.bth]
+        pubkey = public_key.to_hex(compressed)
+        [privkey.bth, pubkey]
       end
 
       # generate tapyrus key object
@@ -24,14 +24,71 @@ module Tapyrus
 
       def generate_pubkey(privkey, compressed: true)
         public_key = ECDSA::Group::Secp256k1.generator.multiply_by_scalar(privkey.to_i(16))
-        ECDSA::Format::PointOctetString.encode(public_key, compression: compressed).bth
+        public_key.to_hex(compressed)
       end
 
       # sign data.
       # @param [String] data a data to be signed with binary format
       # @param [String] privkey a private key using sign
       # @return [String] signature data with binary format
-      def sign_data(data, privkey, extra_entropy)
+      def sign_data(data, privkey, extra_entropy, algo: :ecdsa)
+        case algo
+        when :ecdsa
+          sign_ecdsa(data, privkey, extra_entropy)
+        when :schnorr
+          Schnorr.sign(data, privkey.to_i(16)).encode
+        else
+          nil
+        end
+      end
+
+      # verify signature using public key
+      # @param [String] digest a SHA-256 message digest with binary format
+      # @param [String] sig a signature for +data+ with binary format
+      # @param [String] pubkey a public key corresponding to the private key used for sign
+      # @return [Boolean] verify result
+      def verify_sig(digest, sig, pubkey, algo: :ecdsa)
+        case algo
+        when :ecdsa
+          verify_ecdsa(digest, sig, pubkey)
+        when :schnorr
+          Schnorr.valid_sig?(digest, sig, pubkey.htb)
+        else
+          false
+        end
+      end
+
+      alias :valid_sig? :verify_sig
+
+      module_function :valid_sig?
+
+      # validate whether this is a valid public key (more expensive than IsValid())
+      # @param [String] pubkey public key with hex format.
+      # @param [Boolean] allow_hybrid whether support hybrid public key.
+      # @return [Boolean] If valid public key return true, otherwise false.
+      def parse_ec_pubkey?(pubkey, allow_hybrid = false)
+        begin
+          point = ECDSA::Format::PointOctetString.decode(pubkey.htb, ECDSA::Group::Secp256k1, allow_hybrid: allow_hybrid)
+          ECDSA::Group::Secp256k1.valid_public_key?(point)
+        rescue ECDSA::Format::DecodeError
+          false
+        end
+      end
+
+      # if +pubkey+ is hybrid public key format, it convert uncompressed format.
+      # https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2012-June/001578.html
+      def repack_pubkey(pubkey)
+        p = pubkey.htb
+        case p[0]
+          when "\x06", "\x07"
+            p[0] = "\x04"
+            p
+          else
+            pubkey.htb
+        end
+      end
+
+      def sign_ecdsa(data, privkey, extra_entropy)
         privkey = privkey.htb
         private_key = ECDSA::Format::IntegerOctetString.decode(privkey)
         extra_entropy ||= ''
@@ -59,12 +116,7 @@ module Tapyrus
         signature
       end
 
-      # verify signature using public key
-      # @param [String] digest a SHA-256 message digest with binary format
-      # @param [String] sig a signature for +data+ with binary format
-      # @param [String] pubkey a public key corresponding to the private key used for sign
-      # @return [Boolean] verify result
-      def verify_sig(digest, sig, pubkey)
+      def verify_ecdsa(digest, sig, pubkey)
         begin
           k = ECDSA::Format::PointOctetString.decode(repack_pubkey(pubkey), GROUP)
           signature = ECDSA::Format::SignatureDerString.decode(sig)
@@ -74,23 +126,6 @@ module Tapyrus
         end
       end
 
-      alias :valid_sig? :verify_sig
-
-      module_function :valid_sig?
-
-      # if +pubkey+ is hybrid public key format, it convert uncompressed format.
-      # https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2012-June/001578.html
-      def repack_pubkey(pubkey)
-        p = pubkey.htb
-        case p[0]
-          when "\x06", "\x07"
-            p[0] = "\x04"
-            p
-          else
-            pubkey.htb
-        end
-      end
-
     end
 
   end

data/lib/tapyrus/store/chain_entry.rb

@@ -36,7 +36,7 @@ module Tapyrus
 
       # whether genesis block
       def genesis?
-        Tapyrus.chain_params.genesis_block.header == header
+        height == 0
       end
 
       # @param [String] payload a payload with binary format.
@@ -44,7 +44,7 @@ module Tapyrus
         buf = StringIO.new(payload)
         len = Tapyrus.unpack_var_int_from_io(buf)
         height = buf.read(len).reverse.bth.to_i(16)
-        new(Tapyrus::BlockHeader.parse_from_payload(buf.read(80)), height)
+        new(Tapyrus::BlockHeader.parse_from_payload(buf), height)
       end
 
       # build next block +StoredBlock+ instance.

data/lib/tapyrus/store/db/level_db.rb

@@ -58,14 +58,64 @@ module Tapyrus
           db.get(KEY_PREFIX[:entry] + hash)
         end
 
+        # Save entry.
+        # @param [Tapyrus::Store::ChainEntry]
         def save_entry(entry)
           db.batch do
             db.put(entry.key ,entry.to_payload)
             db.put(height_key(entry.height), entry.block_hash)
+            add_agg_pubkey(entry.height == 0 ? 0 : entry.height + 1, entry.header.x_field) if entry.header.upgrade_agg_pubkey?
             connect_entry(entry)
           end
         end
 
+        # Add aggregated public key.
+        # @param [Integer] activate_height
+        # @param [String] agg_pubkey aggregated public key with hex format.
+        def add_agg_pubkey(activate_height, agg_pubkey)
+          payload = activate_height.to_even_length_hex + agg_pubkey
+          index = latest_agg_pubkey_index
+          next_index = (index.nil? ? 0 : index + 1).to_even_length_hex
+          db.batch do
+            db.put(KEY_PREFIX[:agg_pubkey] + next_index, payload)
+            db.put(KEY_PREFIX[:latest_agg_pubkey], next_index)
+          end
+        end
+
+        # Get aggregated public key by specifying +index+.
+        # @param [Integer] index
+        # @return [Array] tupple of activate height and aggregated public key.
+        def agg_pubkey(index)
+          payload = db.get(KEY_PREFIX[:agg_pubkey] + index.to_even_length_hex)
+          [payload[0...(payload.length - 66)].to_i(16), payload[(payload.length - 66)..-1]]
+        end
+
+        # Get aggregated public key by specifying block +height+.
+        # @param [Integer] height block height.
+        # @return [String] aggregated public key with hex format.
+        def agg_pubkey_with_height(height)
+          index = latest_agg_pubkey_index
+          index ||= 0
+          (index + 1).times do |i|
+            target = index - i
+            active_height, pubkey = agg_pubkey(target)
+            return pubkey unless active_height > height
+          end
+        end
+
+        # Get latest aggregated public key.
+        # @return [Array] aggregated public key with hex format.
+        def latest_agg_pubkey
+          agg_pubkey(latest_agg_pubkey_index)[1]
+        end
+
+        # Get aggregated public key list.
+        # @return [Array[Array]] list of public key and index
+        def agg_pubkeys
+          index = latest_agg_pubkey_index
+          (index + 1).times.map { |i| agg_pubkey(i) }
+        end
+
         def close
           db.close
         end
@@ -91,6 +141,14 @@ module Tapyrus
           db.put(KEY_PREFIX[:best], entry.block_hash)
           db.put(KEY_PREFIX[:next] + entry.prev_hash, entry.block_hash)
         end
+
+        # Get latest aggregated public key index.
+        # @return [Integer] key index
+        def latest_agg_pubkey_index
+          index = db.get(KEY_PREFIX[:latest_agg_pubkey])
+          index&.to_i(16)
+        end
+
       end
 
     end

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/version.rb

@@ -1,3 +1,3 @@
 module Tapyrus
-  VERSION = "0.2.0"
+  VERSION = "0.2.5"
 end

data/tapyrusrb.gemspec

@@ -10,8 +10,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["azuchi"]
   spec.email         = ["azuchi@chaintope.com"]
 
-  spec.summary       = %q{[WIP]The implementation of Tapyrus Protocol for Ruby.}
-  spec.description   = %q{[WIP]The implementation of Tapyrus Protocol for Ruby.}
+  spec.summary       = %q{The implementation of Tapyrus Protocol for Ruby.}
+  spec.description   = %q{The implementation of Tapyrus Protocol for Ruby.}
   spec.homepage      = 'https://github.com/chaintope/tapyrusrb'
   spec.license       = "MIT"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tapyrus
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.5
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-15 00:00:00.000000000 Z
+date: 2020-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -290,7 +290,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: "[WIP]The implementation of Tapyrus Protocol for Ruby."
+description: The implementation of Tapyrus Protocol for Ruby.
 email:
 - azuchi@chaintope.com
 executables:
@@ -328,7 +328,9 @@ files:
 - lib/tapyrus/chainparams/dev.yml
 - lib/tapyrus/chainparams/prod.yml
 - lib/tapyrus/constants.rb
+- lib/tapyrus/errors.rb
 - lib/tapyrus/ext.rb
+- lib/tapyrus/ext/ecdsa.rb
 - lib/tapyrus/ext/json_parser.rb
 - lib/tapyrus/ext_key.rb
 - lib/tapyrus/key.rb
@@ -450,5 +452,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: "[WIP]The implementation of Tapyrus Protocol for Ruby."
+summary: The implementation of Tapyrus Protocol for Ruby.
 test_files: []