bitcoinrb 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99f5168564a4d436b4a3a43ce30fc4cf0657f4feb0f96cfa57362de3a322846b
-  data.tar.gz: 0bf7749a29bfcebb5006a5a01f47dabeb766d98269476dfa75f2d524af6d6da2
+  metadata.gz: 3d66a90af2b70a6494a6b38d0602a4442a0173e27294cec5b389149b77bc7360
+  data.tar.gz: 1b830903242397fece09064f51a150b9716ef1d06409f597ca60c6ee76e80ebc
 SHA512:
-  metadata.gz: c23353ea258a891d79fff2f91a0e8661f389dc6045ca0199955dfe3fb91cdb01be5dc857553c7073633c7f34f0603991f6761403f787aea9bf306586124ccea4
-  data.tar.gz: '0597bdd738e1ffc9b8189ec1aaf05245b2cc988bd4ce3a92ad35bf8182cfb3864b59209c7a4894cf0c6d10d5fabaf3a9f2e0da10c7afa25f595969274ca3f5e1'
+  metadata.gz: 397ecea38a38e72c3a66d6ca18461a41af2ecfa747eb71c9193c9c7a1629c96e49a8338348a2bd88f3be0e01184bb5148dd6e53e968c83dae8c3da4d2105e253
+  data.tar.gz: bf3fca048c69f4939f1c4cae0da6c9be03e0650dd18f271d5cac045d4a30528ef3e3268e3290c6f03cadb6d2dbd06cd6ac0405e11e4400359085bfbd36d55f46

data/LICENSE.txt

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

data/lib/bitcoin/block.rb

@@ -33,7 +33,7 @@ module Bitcoin
 
     # calculate merkle root from tx list.
     def calculate_merkle_root
-      Bitcoin::MerkleTree.build_from_leaf(transactions.map(&:txid)).merkle_root
+      Bitcoin::MerkleTree.build_from_leaf(transactions.map(&:hash)).merkle_root
     end
 
     # check the witness commitment in coinbase tx matches witness commitment calculated from tx list.
@@ -43,12 +43,11 @@ module Bitcoin
 
     # calculate witness commitment from tx list.
     def calculate_witness_commitment
-      wtxid_list = [COINBASE_WTXID]
-      wtxid_list.concat(transactions[1..-1].map{|tx| tx.wtxid})
+      witness_hashes = [COINBASE_WTXID]
+      witness_hashes += (transactions[1..-1].map(&:witness_hash))
       reserved_value = transactions[0].inputs[0].script_witness.stack.map(&:bth).join
-      root_hash = Bitcoin::MerkleTree.build_from_leaf(wtxid_list).merkle_root
-      Digest::SHA256.digest(Digest::SHA256.digest(
-          [reserved_value + root_hash].pack('H*').reverse )).bth
+      root_hash = Bitcoin::MerkleTree.build_from_leaf(witness_hashes).merkle_root
+      Bitcoin.double_sha256([root_hash + reserved_value].pack('H*')).bth
     end
 
     # return this block height. block height is included in coinbase.

data/lib/bitcoin/block_header.rb

@@ -21,11 +21,11 @@ module Bitcoin
 
     def self.parse_from_payload(payload)
       version, prev_hash, merkle_root, time, bits, nonce = payload.unpack('Va32a32VVV')
-      new(version, prev_hash.reverse.bth, merkle_root.reverse.bth, time, bits, nonce)
+      new(version, prev_hash.bth, merkle_root.bth, time, bits, nonce)
     end
 
     def to_payload
-      [version, prev_hash.htb.reverse, merkle_root.htb.reverse, time, bits, nonce].pack('Va32a32VVV')
+      [version, prev_hash.htb, merkle_root.htb, time, bits, nonce].pack('Va32a32VVV')
     end
 
     # compute difficulty target from bits.
@@ -36,11 +36,16 @@ module Bitcoin
       (mantissa * 2 ** (8 * (exponent - 3)))
     end
 
-    # block hash
+    # block hash(little endian)
     def hash
       calc_hash
     end
 
+    # block hash(big endian)
+    def block_id
+      hash.rhex
+    end
+
     # evaluate block header
     def valid?
       valid_pow? && valid_timestamp?
@@ -48,7 +53,7 @@ module Bitcoin
 
     # evaluate valid proof of work.
     def valid_pow?
-      hash.hex < difficulty_target
+      block_id.hex < difficulty_target
     end
 
     # evaluate valid timestamp.
@@ -72,7 +77,7 @@ module Bitcoin
     private
 
     def calc_hash
-      Bitcoin.double_sha256(to_payload).reverse.bth
+      Bitcoin.double_sha256(to_payload).bth
     end
 
   end

data/lib/bitcoin/bloom_filter.rb

@@ -7,24 +7,31 @@ module Bitcoin
     MAX_BLOOM_FILTER_SIZE = 36_000 # bytes
     MAX_HASH_FUNCS = 50
 
-    attr_reader :hash_funcs, :tweak
+    attr_reader :filter, :hash_funcs, :tweak
 
+    def initialize(filter, hash_funcs, tweak)
+      @filter = filter
+      @hash_funcs = hash_funcs
+      @tweak = tweak
+    end
+
+    # Create a new bloom filter.
     # @param [Integer] elements_length the number of elements
     # @param [Float] fp_rate the false positive rate chosen by the client
     # @param [Integer] tweak A random value to add to the seed value in the hash function used by the bloom filter
-    def initialize(elements_length, fp_rate, tweak=0)
+    def self.create_filter(elements_length, fp_rate, tweak = 0)
       # The size S of the filter in bytes is given by (-1 / pow(log(2), 2) * N * log(P)) / 8
       len = [[(-elements_length * Math.log(fp_rate) / (LN2_SQUARED * 8)).to_i, MAX_BLOOM_FILTER_SIZE].min, 1].max
-      @filter = Array.new(len, 0)
+      filter = Array.new(len, 0)
       # The number of hash functions required is given by S * 8 / N * log(2)
-      @hash_funcs = [[(@filter.size * 8 * LN2 / elements_length).to_i, MAX_HASH_FUNCS].min, 1].max
-      @tweak = tweak
+      hash_funcs = [[(filter.size * 8 * LN2 / elements_length).to_i, MAX_HASH_FUNCS].min, 1].max
+      BloomFilter.new(filter, hash_funcs, tweak)
     end
 
     # @param [String] data The data element to add to the current filter.
     def add(data)
       return if full?
-      @hash_funcs.times do |i|
+      hash_funcs.times do |i|
         hash = to_hash(data, i)
         set_bit(hash)
       end
@@ -35,7 +42,7 @@ module Bitcoin
     # @return [Boolean] true if the given data matches the filter
     def contains?(data)
       return true if full?
-      @hash_funcs.times do |i|
+      hash_funcs.times do |i|
         hash = to_hash(data, i)
         return false unless check_bit(hash)
       end
@@ -43,29 +50,29 @@ module Bitcoin
     end
 
     def clear
-      @filter.fill(0)
+      filter.fill(0)
       @full = false
     end
 
     def to_a
-      @filter
+      filter
     end
 
     private
     def to_hash(data, i)
-      MurmurHash3::V32.str_hash(data, (i * 0xfba4c795 + @tweak) & 0xffffffff)  % (@filter.length * 8)
+      MurmurHash3::V32.str_hash(data, (i * 0xfba4c795 + tweak) & 0xffffffff)  % (filter.length * 8)
     end
 
     def set_bit(data)
-      @filter[data >> 3] |= (1 << (7 & data))
+      filter[data >> 3] |= (1 << (7 & data))
     end
 
     def check_bit(data)
-      @filter[data >> 3] & (1 << (7 & data)) != 0
+      filter[data >> 3] & (1 << (7 & data)) != 0
     end
 
     def full?
-      @full |= @filter.all? {|byte| byte == 0xff}
+      @full |= filter.all? {|byte| byte == 0xff}
     end
   end
 end

data/lib/bitcoin/chain_params.rb

@@ -14,6 +14,14 @@ module Bitcoin
     attr_reader :privkey_version
     attr_reader :extended_privkey_version
     attr_reader :extended_pubkey_version
+    attr_reader :bip49_pubkey_p2wpkh_p2sh_version
+    attr_reader :bip49_privkey_p2wpkh_p2sh_version
+    attr_reader :bip49_pubkey_p2wsh_p2sh_version
+    attr_reader :bip49_privkey_p2wsh_p2sh_version
+    attr_reader :bip84_pubkey_p2wpkh_version
+    attr_reader :bip84_privkey_p2wpkh_version
+    attr_reader :bip84_pubkey_p2wsh_version
+    attr_reader :bip84_privkey_p2wsh_version
     attr_reader :default_port
     attr_reader :protocol_version
     attr_reader :retarget_interval
@@ -58,7 +66,7 @@ module Bitcoin
 
     def genesis_block
       header = Bitcoin::BlockHeader.new(
-          genesis['version'], genesis['prev_hash'], genesis['merkle_root'],
+          genesis['version'], genesis['prev_hash'].rhex, genesis['merkle_root'].rhex,
           genesis['time'], genesis['bits'], genesis['nonce'])
       Bitcoin::Block.new(header)
     end

data/lib/bitcoin/chainparams/mainnet.yml

@@ -8,6 +8,14 @@ bech32_hrp: 'bc'
 privkey_version: "80"
 extended_privkey_version: "0488ade4"
 extended_pubkey_version: "0488b21e"
+bip49_pubkey_p2wpkh_p2sh_version: "049d7cb2"
+bip49_pubkey_p2wsh_p2sh_version: "0295b43f"
+bip49_privkey_p2wpkh_p2sh_version: "049d7878"
+bip49_privkey_p2wsh_p2sh_version: "0295b005"
+bip84_pubkey_p2wpkh_version: "04b24746"
+bip84_pubkey_p2wsh_version: "02aa7ed3"
+bip84_privkey_p2wpkh_version: "04b2430c"
+bip84_privkey_p2wsh_version: "02aa7a99"
 default_port: 8333
 protocol_version: 70013
 retarget_interval: 2016

data/lib/bitcoin/chainparams/regtest.yml

@@ -8,6 +8,14 @@ bech32_hrp: 'bcrt'
 privkey_version: "ef"
 extended_privkey_version: "04358394"
 extended_pubkey_version: "043587cf"
+bip49_pubkey_p2wpkh_p2sh_version: "044a5262"
+bip49_pubkey_p2wsh_p2sh_version: "024285ef"
+bip49_privkey_p2wpkh_p2sh_version: "044a4e28"
+bip49_privkey_p2wsh_p2sh_version: "024285b5"
+bip84_pubkey_p2wpkh_version: "045f1cf6"
+bip84_pubkey_p2wsh_version: "02575483"
+bip84_privkey_p2wpkh_version: "045f18bc"
+bip84_privkey_p2wsh_version: "02575048"
 default_port: 18444
 protocol_version: 70013
 retarget_interval: 2016

data/lib/bitcoin/chainparams/testnet.yml

@@ -8,6 +8,14 @@ bech32_hrp: 'tb'
 privkey_version: "ef"
 extended_privkey_version: "04358394"
 extended_pubkey_version: "043587cf"
+bip49_pubkey_p2wpkh_p2sh_version: "044a5262"
+bip49_pubkey_p2wsh_p2sh_version: "024285ef"
+bip49_privkey_p2wpkh_p2sh_version: "044a4e28"
+bip49_privkey_p2wsh_p2sh_version: "024285b5"
+bip84_pubkey_p2wpkh_version: "045f1cf6"
+bip84_pubkey_p2wsh_version: "02575483"
+bip84_privkey_p2wpkh_version: "045f18bc"
+bip84_privkey_p2wsh_version: "02575048"
 default_port: 18333
 protocol_version: 70013
 retarget_interval: 2016

data/lib/bitcoin/ext_key.rb

@@ -6,10 +6,11 @@ module Bitcoin
   # BIP32 Extended private key
   class ExtKey
 
+    attr_accessor :ver
     attr_accessor :depth
     attr_accessor :number
     attr_accessor :chain_code
-    attr_accessor :key
+    attr_accessor :key # Bitcoin::Key
     attr_accessor :parent_fingerprint
 
     # generate master key from seed.
@@ -34,13 +35,14 @@ module Bitcoin
       k.parent_fingerprint = parent_fingerprint
       k.chain_code = chain_code
       k.pubkey = key.pubkey
+      k.ver = priv_ver_to_pub_ver
       k
     end
 
     # serialize extended private key
     def to_payload
-      Bitcoin.chain_params.extended_privkey_version.htb << [depth].pack('C') <<
-          parent_fingerprint.htb << [number].pack('N') << chain_code << [0x00].pack('C') << key.priv_key.htb
+      version.htb << [depth].pack('C') << parent_fingerprint.htb <<
+          [number].pack('N') << chain_code << [0x00].pack('C') << key.priv_key.htb
     end
 
     # Base58 encoded extended private key
@@ -66,12 +68,7 @@ module Bitcoin
 
     # get address
     def addr
-      key.to_p2pkh
-    end
-
-    # get segwit p2wpkh address
-    def segwit_addr
-      ext_pubkey.segwit_addr
+      ext_pubkey.addr
     end
 
     # get key identifier
@@ -107,27 +104,72 @@ module Bitcoin
       raise 'invalid key ' if child_priv >= CURVE_ORDER
       new_key.key = Bitcoin::Key.new(priv_key: child_priv.to_s(16).rjust(64, '0'))
       new_key.chain_code = l[32..-1]
+      new_key.ver = version
       new_key
     end
 
-    # import private key from Base58 private key address
-    def self.from_base58(address)
-      data = StringIO.new(Base58.decode(address).htb)
+    # get version bytes using serialization format
+    def version
+      return ExtKey.version_from_purpose(number) if depth == 1
+      ver ? ver : Bitcoin.chain_params.extended_privkey_version
+    end
+
+    def self.parse_from_payload(payload)
+      buf = StringIO.new(payload)
       ext_key = ExtKey.new
-      data.read(4).bth # version
-      ext_key.depth = data.read(1).unpack('C').first
-      ext_key.parent_fingerprint = data.read(4).bth
-      ext_key.number = data.read(4).unpack('N').first
-      ext_key.chain_code = data.read(32)
-      data.read(1) # 0x00
-      ext_key.key = Bitcoin::Key.new(priv_key: data.read(32).bth)
+      ext_key.ver = buf.read(4).bth # version
+      raise 'An unsupported version byte was specified.' 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
+      ext_key.chain_code = buf.read(32)
+      buf.read(1) # 0x00
+      ext_key.key = Bitcoin::Key.new(priv_key: buf.read(32).bth)
       ext_key
     end
 
+    # import private key from Base58 private key address
+    def self.from_base58(address)
+      ExtKey.parse_from_payload(Base58.decode(address).htb)
+    end
+
+    # get version bytes from purpose' value.
+    def self.version_from_purpose(purpose)
+      v = purpose - 2**31
+      case v
+        when 49
+          Bitcoin.chain_params.bip49_privkey_p2wpkh_p2sh_version
+        when 84
+          Bitcoin.chain_params.bip84_privkey_p2wpkh_version
+        else
+          Bitcoin.chain_params.extended_privkey_version
+      end
+    end
+
+    # check whether +version+ is supported version bytes.
+    def self.support_version?(version)
+      p = Bitcoin.chain_params
+      [p.bip49_privkey_p2wpkh_p2sh_version, p.bip84_privkey_p2wpkh_version, p.extended_privkey_version].include?(version)
+    end
+
+    # convert privkey version to pubkey version
+    def priv_ver_to_pub_ver
+      case version
+        when Bitcoin.chain_params.bip49_privkey_p2wpkh_p2sh_version
+          Bitcoin.chain_params.bip49_pubkey_p2wpkh_p2sh_version
+        when Bitcoin.chain_params.bip84_privkey_p2wpkh_version
+          Bitcoin.chain_params.bip84_pubkey_p2wpkh_version
+        else
+          Bitcoin.chain_params.extended_pubkey_version
+      end
+    end
+
   end
 
   # BIP-32 Extended public key
   class ExtPubkey
+
+    attr_accessor :ver
     attr_accessor :depth
     attr_accessor :number
     attr_accessor :chain_code
@@ -136,7 +178,7 @@ module Bitcoin
 
     # serialize extended pubkey
     def to_payload
-      Bitcoin.chain_params.extended_pubkey_version.htb << [depth].pack('C') <<
+      version.htb << [depth].pack('C') <<
           parent_fingerprint.htb << [number].pack('N') << chain_code << pub.htb
     end
 
@@ -150,17 +192,20 @@ module Bitcoin
 
     # get address
     def addr
-      Bitcoin::Key.new(pubkey: pubkey).to_p2pkh
+      case version
+        when Bitcoin.chain_params.bip49_pubkey_p2wpkh_p2sh_version
+          key.to_nested_p2wpkh
+        when Bitcoin.chain_params.bip84_pubkey_p2wpkh_version
+          key.to_p2wpkh
+        else
+          key.to_p2pkh
+      end
     end
 
-    # get segwit p2wpkh address
-    def segwit_addr
-      hash160 = Bitcoin.hash160(pub)
-      p2wpkh = [ ["00", "14", hash160].join ].pack("H*").bth
-      segwit_addr = Bech32::SegwitAddr.new
-      segwit_addr.hrp = Bitcoin.chain_params.address_version == '00' ? 'bc' : 'tb'
-      segwit_addr.script_pubkey = p2wpkh
-      segwit_addr.addr
+    # get key object
+    # @return [Bitcoin::Key]
+    def key
+      Bitcoin::Key.new(pubkey: pubkey)
     end
 
     # get key identifier
@@ -200,21 +245,53 @@ module Bitcoin
       p2 = Bitcoin::Key.new(pubkey: pubkey).to_point
       new_key.pubkey = ECDSA::Format::PointOctetString.encode(p1 + p2, compression: true).bth
       new_key.chain_code = l[32..-1]
+      new_key.ver = version
       new_key
     end
 
-    # import pub key from Base58 private key address
-    def self.from_base58(address)
-      data = StringIO.new(Base58.decode(address).htb)
+    # get version bytes using serialization format
+    def version
+      return ExtPubkey.version_from_purpose(number) if depth == 1
+      ver ? ver : Bitcoin.chain_params.extended_pubkey_version
+    end
+
+    def self.parse_from_payload(payload)
+      buf = StringIO.new(payload)
       ext_pubkey = ExtPubkey.new
-      data.read(4).bth # version
-      ext_pubkey.depth = data.read(1).unpack('C').first
-      ext_pubkey.parent_fingerprint = data.read(4).bth
-      ext_pubkey.number = data.read(4).unpack('N').first
-      ext_pubkey.chain_code = data.read(32)
-      ext_pubkey.pubkey = data.read(33).bth
+      ext_pubkey.ver = buf.read(4).bth # version
+      raise 'An unsupported version byte was specified.' 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
+      ext_pubkey.chain_code = buf.read(32)
+      ext_pubkey.pubkey = buf.read(33).bth
       ext_pubkey
     end
+
+    # import pub key from Base58 private key address
+    def self.from_base58(address)
+      ExtPubkey.parse_from_payload(Base58.decode(address).htb)
+    end
+
+    # get version bytes from purpose' value.
+    def self.version_from_purpose(purpose)
+      v = purpose - 2**31
+      case v
+        when 49
+          Bitcoin.chain_params.bip49_pubkey_p2wpkh_p2sh_version
+        when 84
+          Bitcoin.chain_params.bip84_pubkey_p2wpkh_version
+        else
+          Bitcoin.chain_params.extended_pubkey_version
+      end
+    end
+
+    # check whether +version+ is supported version bytes.
+    def self.support_version?(version)
+      p = Bitcoin.chain_params
+      [p.bip49_pubkey_p2wpkh_p2sh_version, p.bip84_pubkey_p2wpkh_version, p.extended_pubkey_version].include?(version)
+    end
+
   end
 
 end

data/lib/bitcoin/key.rb

@@ -87,14 +87,24 @@ module Bitcoin
       end
     end
 
+    # get hash160 public key.
+    def hash160
+      Bitcoin.hash160(pubkey)
+    end
+
     # get pay to pubkey hash address
     def to_p2pkh
-      Bitcoin::Script.to_p2pkh(Bitcoin.hash160(pubkey)).to_addr
+      Bitcoin::Script.to_p2pkh(hash160).to_addr
     end
 
     # get pay to witness pubkey hash address
     def to_p2wpkh
-      Bitcoin::Script.to_p2wpkh(Bitcoin.hash160(pubkey)).to_addr
+      Bitcoin::Script.to_p2wpkh(hash160).to_addr
+    end
+
+    # get p2wpkh address nested in p2sh.
+    def to_nested_p2wpkh
+      Bitcoin::Script.to_p2wpkh(hash160).to_p2sh.to_addr
     end
 
     def compressed?

data/lib/bitcoin/merkle_tree.rb

@@ -78,8 +78,7 @@ module Bitcoin
       def hash
         return @hash if @hash
         self.right = left.dup unless right
-        Digest::SHA256.digest(Digest::SHA256.digest(
-            [right.hash + left.hash].pack('H*').reverse )).reverse.bth
+        Bitcoin.double_sha256([left.hash + right.hash].pack('H*')).bth
       end
 
       def root?

data/lib/bitcoin/message/filter_load.rb

@@ -11,15 +11,11 @@ module Bitcoin
       BLOOM_UPDATE_ALL = 1
       BLOOM_UPDATE_P2PUBKEY_ONLY = 2
 
-      attr_accessor :filter # bin format
-      attr_accessor :func_count
-      attr_accessor :tweak
+      attr_accessor :filter
       attr_accessor :flag
 
-      def initialize(filter, func_count, tweak = 0, flag = BLOOM_UPDATE_ALL)
+      def initialize(filter, flag = BLOOM_UPDATE_ALL)
         @filter = filter
-        @func_count = func_count
-        @tweak = tweak
         @flag = flag
       end
 
@@ -30,11 +26,11 @@ module Bitcoin
         func_count = buf.read(4).unpack('V').first
         tweak = buf.read(4).unpack('V').first
         flag = buf.read(1).unpack('C').first
-        new(filter, func_count, tweak, flag)
+        FilterLoad.new(Bitcoin::BloomFilter.new(filter, func_count, tweak), flag)
       end
 
       def to_payload
-        Bitcoin.pack_var_int(filter.size) << filter.pack('C*') << [func_count, tweak, flag].pack('VVC')
+        Bitcoin.pack_var_int(filter.filter.size) << filter.filter.pack('C*') << [filter.hash_funcs, filter.tweak, flag].pack('VVC')
       end
 
     end

data/lib/bitcoin/network/peer.rb

@@ -190,11 +190,7 @@ module Bitcoin
       # send filterload message.
       def send_filter_load(bloom)
         filter_load = Bitcoin::Message::FilterLoad.new(
-          bloom.to_a,
-          bloom.hash_funcs,
-          bloom.tweak,
-          Bitcoin::Message::FilterLoad::BLOOM_UPDATE_ALL
-        )
+            bloom, Bitcoin::Message::FilterLoad::BLOOM_UPDATE_ALL)
         conn.send_message(filter_load)
       end
 

data/lib/bitcoin/network/pool.rb

@@ -14,13 +14,15 @@ module Bitcoin
 
       attr_reader :peers # active peers
       attr_reader :pending_peers # currently connecting peer
+      attr_reader :node
       attr_reader :chain
       attr_reader :max_outbound
       attr_reader :logger
       attr_reader :peer_discovery
       attr_accessor :started
 
-      def initialize(chain, configuration)
+      def initialize(node, chain, configuration)
+        @node = node
         @peers = []
         @pending_peers = []
         @max_outbound = MAX_OUTBOUND_CONNECTIONS
@@ -59,6 +61,7 @@ module Bitcoin
         end
         peers << peer
         pending_peers.delete(peer)
+        filter_load(peer) if node.wallet
       end
 
       # terminate peers.
@@ -75,8 +78,8 @@ module Bitcoin
       end
 
       # new bloom filter.
-      def filter_load(bloom)
-        peers.each { |peer| peer.send_filter_load(bloom) }
+      def filter_load(peer)
+        peer.send_filter_load(node.bloom)
       end
 
       # add element to bloom filter.

data/lib/bitcoin/node/cli.rb

@@ -50,6 +50,21 @@ module Bitcoin
         request('getwalletinfo')
       end
 
+      desc 'listaccounts', '[WIP]Returns Object that has account names as keys, account balances as values.'
+      def listaccounts
+        request('listaccounts')
+      end
+
+      desc 'encryptwallet "passphrase"', 'Encrypts the wallet with "passphrase". This is for first time encryption.After this, any calls that interact with private keys such as sending or signing will require the passphrase to be set prior the making these calls.'
+      def encryptwallet(passhphrase)
+        request('encryptwallet', passhphrase)
+      end
+
+      desc 'getnewaddress "account"', 'Returns a new Bitcoin address for receiving payments.'
+      def getnewaddress(account)
+        request('getnewaddress', account)
+      end
+
       private
 
       def config

data/lib/bitcoin/node/spv.rb

@@ -11,17 +11,17 @@ module Bitcoin
       attr_reader :configuration
       attr_accessor :server
       attr_accessor :wallet
+      attr_accessor :bloom
 
       def initialize(configuration)
         @chain = Bitcoin::Store::SPVChain.new
         @configuration = configuration
-        @pool = Bitcoin::Network::Pool.new(@chain, @configuration)
+        @pool = Bitcoin::Network::Pool.new(self, @chain, @configuration)
         @logger = Bitcoin::Logger.create(:debug)
         @running = false
         @wallet = Bitcoin::Wallet::Base.current_wallet
         # TODO : optimize bloom filter parameters
-        # TODO : load public keys in wallet.
-        @bloom = Bitcoin::BloomFilter.new(512, 0.01)
+        setup_filter
       end
 
       # open the node.
@@ -48,15 +48,10 @@ module Bitcoin
         logger.debug "broadcast tx: #{tx.to_payload.bth}"
       end
 
-      # new bloom filter.
-      def filter_load
-        pool.filter_load(@bloom)
-      end
-
       # add filter element to bloom filter.
       # [String] element. the hex string of txid, public key, public key hash or outpoint.
       def filter_add(element)
-        @bloom.add(element)
+        bloom.add(element)
         pool.filter_add(element)
       end
 
@@ -64,6 +59,14 @@ module Bitcoin
       def filter_clear
         pool.filter_clear
       end
+
+      private
+
+      def setup_filter
+        @bloom = Bitcoin::BloomFilter.create_filter(512, 0.01)
+        wallet.watch_targets.each{|t|bloom.add(t.htb.reverse)} if wallet
+      end
+
     end
   end
 end

data/lib/bitcoin/rpc/request_handler.rb

@@ -10,7 +10,7 @@ module Bitcoin
         h[:chain] = Bitcoin.chain_params.network
         best_block = node.chain.latest_block
         h[:headers] = best_block.height
-        h[:bestblockhash] = best_block.hash
+        h[:bestblockhash] = best_block.header.block_id
         h[:chainwork] = best_block.header.work
         h[:mediantime] = node.chain.mtp(best_block.hash)
         h
@@ -22,21 +22,23 @@ module Bitcoin
       end
 
       # get block header information.
-      def getblockheader(hash, verbose)
-        entry = node.chain.find_entry_by_hash(hash)
+      # @param [String] block_id block hash(big endian)
+      def getblockheader(block_id, verbose)
+        block_hash = block_id.rhex
+        entry = node.chain.find_entry_by_hash(block_hash)
         if verbose
           {
-              hash: hash,
+              hash: block_id,
               height: entry.height,
               version: entry.header.version,
               versionHex: entry.header.version.to_s(16),
-              merkleroot: entry.header.merkle_root,
+              merkleroot: entry.header.merkle_root.rhex,
               time: entry.header.time,
-              mediantime: node.chain.mtp(hash),
+              mediantime: node.chain.mtp(block_hash),
               nonce: entry.header.nonce,
               bits: entry.header.bits.to_s(16),
-              previousblockhash: entry.prev_hash,
-              nextblockhash: node.chain.next_hash(hash)
+              previousblockhash: entry.prev_hash.rhex,
+              nextblockhash: node.chain.next_hash(block_hash).rhex
           }
         else
           entry.header.to_payload.bth
@@ -94,8 +96,29 @@ module Bitcoin
 
       # get current wallet information.
       def getwalletinfo
+        node.wallet ? node.wallet.to_h : {}
+      end
+
+      # get the list of current Wallet accounts.
+      def listaccounts
         return {} unless node.wallet
-        {wallet_id: node.wallet.wallet_id, version: node.wallet.version}
+        accounts = {}
+        node.wallet.accounts.each do |a|
+          accounts[a.name] = node.wallet.get_balance(a)
+        end
+        accounts
+      end
+
+      # encrypt wallet.
+      def encryptwallet(passphrase)
+        return nil unless node.wallet
+        node.wallet.encrypt(passphrase)
+        "The wallet 'wallet_id: #{node.wallet.wallet_id}' has been encrypted."
+      end
+
+      # create new bitcoin address for receiving payments.
+      def getnewaddress(account_name)
+        node.wallet.generate_new_address(account_name)
       end
 
     end

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

@@ -75,7 +75,7 @@ module Bitcoin
         # generate height key
         def height_key(height)
           height = height.to_even_length_hex
-          KEY_PREFIX[:height] + height.htb.reverse.bth
+          KEY_PREFIX[:height] + height.rhex
         end
 
         def connect_entry(entry)

data/lib/bitcoin/store/spv_chain.rb

@@ -52,13 +52,15 @@ module Bitcoin
           db.save_entry(entry)
           entry
         else
-          # TODO implements recovery process
-          raise "header's previous hash(#{header.prev_hash}) does not match current best block's(#{best_block.hash})."
+          unless find_entry_by_hash(header.hash)
+            # TODO implements recovery process
+            raise "header's previous hash(#{header.prev_hash}) does not match current best block's(#{best_block.hash})."
+          end
         end
       end
 
       # get next block hash for specified +hash+
-      # @param [String] hash the block hash
+      # @param [String] hash the block hash(little endian)
       # @return [String] the next block hash. If it does not exist yet, return nil.
       def next_hash(hash)
         db.next_hash(hash)

data/lib/bitcoin/tx.rb

@@ -70,12 +70,20 @@ module Bitcoin
       tx
     end
 
+    def hash
+      Bitcoin.double_sha256(serialize_old_format).bth
+    end
+
     def txid
-      Bitcoin.double_sha256(serialize_old_format).reverse.bth
+      hash.rhex
+    end
+
+    def witness_hash
+      Bitcoin.double_sha256(to_payload).bth
     end
 
     def wtxid
-      Bitcoin.double_sha256(to_payload).reverse.bth
+      witness_hash.rhex
     end
 
     # get the witness commitment of coinbase tx.

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/bitcoin/wallet/account.rb

@@ -4,30 +4,36 @@ module Bitcoin
     # the account in BIP-44
     class Account
 
-      PURPOSE_TYPE = {legacy: 44, nested_witness: 49}
+      PURPOSE_TYPE = {legacy: 44, nested_witness: 49, native_segwit: 84}
 
-      attr_reader :purpose # either 44 or 49
+      attr_reader :purpose # either 44 or 49 or 84
       attr_reader :index # BIP-44 index
       attr_reader :name # account name
+      attr_reader :account_key # account xpub key Bitcoin::ExtPubkey
       attr_accessor :receive_depth # receive address depth(address index)
       attr_accessor :change_depth # change address depth(address index)
       attr_accessor :lookahead
       attr_accessor :wallet
 
-      def initialize(purpose = PURPOSE_TYPE[:nested_witness], index = 0, name = '')
+      def initialize(account_key, purpose = PURPOSE_TYPE[:native_segwit], index = 0, name = '')
+        validate_params!(account_key, purpose, index)
         @purpose = purpose
         @index = index
         @name = name
         @receive_depth = 0
         @change_depth = 0
         @lookahead = 10
+        @account_key = account_key
       end
 
       def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        account_key = Bitcoin::ExtPubkey.parse_from_payload(buf.read(78))
+        payload = buf.read
         name, payload = Bitcoin.unpack_var_string(payload)
         name = name.force_encoding('utf-8')
         purpose, index, receive_depth, change_depth, lookahead = payload.unpack('I*')
-        a = Account.new(purpose, index, name)
+        a = Account.new(account_key, purpose, index, name)
         a.receive_depth = receive_depth
         a.change_depth = change_depth
         a.lookahead = lookahead
@@ -35,31 +41,31 @@ module Bitcoin
       end
 
       def to_payload
-        payload = Bitcoin.pack_var_string(name.unpack('H*').first.htb)
+        payload = account_key.to_payload
+        payload << Bitcoin.pack_var_string(name.unpack('H*').first.htb)
         payload << [purpose, index, receive_depth, change_depth, lookahead].pack('I*')
         payload
       end
 
       # whether support witness
       def witness?
-        purpose == PURPOSE_TYPE[:nested_witness]
+        [PURPOSE_TYPE[:nested_witness], PURPOSE_TYPE[:native_segwit]].include?(purpose)
       end
 
-      def init
-        @receive_depth = lookahead
-        @change_depth = lookahead
-        @index = wallet.accounts.size
+      # create new receive key
+      # @return [Bitcoin::ExtKey]
+      def create_receive
+        @receive_depth += 1
         save
+        derive_key(0, @receive_depth)
       end
 
-      # derive receive key
-      def derive_receive(address_index)
-        derive_key(0, address_index)
-      end
-
-      # derive change key
-      def derive_change(address_index)
-        derive_key(1, address_index)
+      # create new change key
+      # # @return [Bitcoin::ExtKey]
+      def create_change
+        @change_depth += 1
+        save
+        derive_key(1, @change_depth)
       end
 
       # save this account payload to database.
@@ -68,13 +74,53 @@ module Bitcoin
       end
 
       # get the list of derived keys for receive key.
+      # @return [Array[Bitcoin::ExtPubkey]]
       def derived_receive_keys
-        receive_depth.times.map{|i|derive_key(0,i)}
+        (receive_depth + 1).times.map{|i|derive_key(0,i)}
       end
 
       # get the list of derived keys for change key.
+      # @return [Array[Bitcoin::ExtPubkey]]
       def derived_change_keys
-        change_depth.times.map{|i|derive_key(1,i)}
+        (change_depth + 1).times.map{|i|derive_key(1,i)}
+      end
+
+      # get account type label.
+      def type
+        case purpose
+          when PURPOSE_TYPE[:legacy]
+            'pubkeyhash'
+          when PURPOSE_TYPE[:nested_witness]
+            'p2wpkh-p2sh'
+          when PURPOSE_TYPE[:native_segwit]
+            'p2wpkh'
+          else
+            'unknown'
+        end
+      end
+
+      # account derivation path
+      def path
+        "m/#{purpose}'/#{Bitcoin.chain_params.bip44_coin_type}'/#{index}'"
+      end
+
+      def watch_only
+        false # TODO implements import watch only address.
+      end
+
+      # get data elements tobe monitored with Bloom Filter.
+      # @return [Array[String]]
+      def watch_targets
+        derived_receive_keys.map(&:hash160) + derived_change_keys.map(&:hash160)
+      end
+
+      def to_h
+        {
+            name: name, type: type, index: index, receive_depth: receive_depth, change_depth: change_depth,
+            look_ahead: lookahead, receive_address: derive_key(0, receive_depth).addr,
+            change_address: derive_key(1, change_depth).addr,
+            account_key: account_key.to_base58, path: path, watch_only: watch_only
+        }
       end
 
       private
@@ -83,11 +129,11 @@ module Bitcoin
         account_key.derive(branch).derive(address_index)
       end
 
-      def account_key
-        return @cached_account_key if @cached_account_key
-        coin_type = Bitcoin.chain_params.bip44_coin_type
-        # m / purpose' / coin_type' / account_index'
-        @cached_account_key = wallet.master_key.key.derive(2**31 + purpose).derive(2**31 + coin_type).derive(2**31 + index)
+      def validate_params!(account_key, purpose, index)
+        raise 'account_key must be an instance of Bitcoin::ExtPubkey.' unless account_key.is_a?(Bitcoin::ExtPubkey)
+        raise 'Account key and index does not match.' unless account_key.number == (index + 2**31)
+        version_bytes = Bitcoin::ExtPubkey.version_from_purpose(purpose + 2**31)
+        raise 'The purpose and the account key do not match.' unless account_key.version == version_bytes
       end
 
     end

data/lib/bitcoin/wallet/base.rb

@@ -49,21 +49,48 @@ module Bitcoin
       end
 
       # get account list based on BIP-44
-      def accounts
-        db.accounts.map do |raw|
+      def accounts(purpose = nil)
+        list = []
+        db.accounts.each do |raw|
           a = Account.parse_from_payload(raw)
+          next if purpose && purpose != a.purpose
           a.wallet = self
-          a
+          list << a
         end
+        list
       end
 
-      def create_account(purpose = Account::PURPOSE_TYPE[:nested_witness], index = 0, name)
-        account = Account.new(purpose, index, name)
+      # create new account
+      # @param [Integer] purpose BIP44's purpose.
+      # @param [String] name a account name.
+      # @return [Bitcoin::Wallet::Account]
+      def create_account(purpose = Account::PURPOSE_TYPE[:native_segwit], name)
+        raise ArgumentError.new('Account already exists.') if find_account(name, purpose)
+        index = accounts.size
+        path = "m/#{purpose}'/#{Bitcoin.chain_params.bip44_coin_type}'/#{index}'"
+        account_key = master_key.derive(path).ext_pubkey
+        account = Account.new(account_key, purpose, index, name)
         account.wallet = self
-        account.init
+        account.save
         account
       end
 
+      # get wallet balance.
+      # @param [Bitcoin::Wallet::Account] account a account in the wallet.
+      def get_balance(account)
+        # TODO get from utxo db.
+        0.00000000
+      end
+
+      # create new bitcoin address for receiving payments.
+      # @param [String] account_name an account name.
+      # @return [String] generated address.
+      def generate_new_address(account_name)
+        account = find_account(account_name)
+        raise ArgumentError.new('Account does not exist.') unless account
+        account.create_receive.addr
+      end
+
       # get wallet version.
       def version
         db.version
@@ -83,7 +110,8 @@ module Bitcoin
       # encrypt wallet
       # @param [String] passphrase the wallet passphrase
       def encrypt(passphrase)
-
+        master_key.encrypt(passphrase)
+        db.register_master_key(master_key)
       end
 
       # decrypt wallet
@@ -92,6 +120,18 @@ module Bitcoin
 
       end
 
+      # wallet information
+      def to_h
+        a = accounts.map(&:to_h)
+        { wallet_id: wallet_id, version: version, account_depth: a.size, accounts: a, master: {encrypted: master_key.encrypted} }
+      end
+
+      # get data elements tobe monitored with Bloom Filter.
+      # @return [Array[String]]
+      def watch_targets
+        accounts.map(&:watch_targets).flatten
+      end
+
       private
 
       def initialize(wallet_id, path_prefix)
@@ -105,6 +145,11 @@ module Bitcoin
         Dir.exist?(path)
       end
 
+      # find account using +account_name+
+      def find_account(account_name, purpose = nil)
+        accounts(purpose).find{|a| a.name == account_name}
+      end
+
     end
 
   end

data/lib/bitcoin/wallet/db.rb

@@ -31,7 +31,8 @@ module Bitcoin
 
       def save_account(account)
         level_db.batch do
-          key = KEY_PREFIX[:account] + account.index.to_s(16).rjust(8, '0')
+          id = [account.purpose, account.index].pack('I*').bth
+          key = KEY_PREFIX[:account] + id
           level_db.put(key, account.to_payload)
         end
       end

data/lib/bitcoin/wallet/master_key.rb

@@ -61,9 +61,25 @@ module Bitcoin
         Bitcoin::ExtKey.generate_master(seed)
       end
 
+      # derive child key using derivation path.
+      # @return [Bitcoin::ExtKey]
+      def derive(path)
+        derived_key = key
+        path.split('/').each_with_index do|p, index|
+          if index == 0
+            raise ArgumentError.new("#{path} is invalid format.") unless p == 'm'
+            next
+          end
+          raise ArgumentError.new("#{path} is invalid format.") unless p.delete("'") =~ /^[0-9]+$/
+          num = (p[-1] == "'" ? p.delete("'").to_i + 2**31 : p.to_i)
+          derived_key = derived_key.derive(num)
+        end
+        derived_key
+      end
+
       # encrypt seed
       def encrypt(passphrase)
-        raise 'seed already encrypted.' if encrypted
+        raise 'The wallet is already encrypted.' if encrypted
         @salt = SecureRandom.hex(16)
         enc = OpenSSL::Cipher.new('AES-256-CBC')
         enc.encrypt
@@ -77,7 +93,7 @@ module Bitcoin
 
       # decrypt seed
       def decrypt(passphrase)
-        raise 'seed is not encrypted.' unless encrypted
+        raise 'The wallet is not encrypted.' unless encrypted
         dec = OpenSSL::Cipher.new('AES-256-CBC')
         dec.decrypt
         dec.key, dec.iv = key_iv(dec, passphrase)

data/lib/bitcoin.rb

@@ -32,6 +32,7 @@ module Bitcoin
   autoload :MerkleTree, 'bitcoin/merkle_tree'
   autoload :Key, 'bitcoin/key'
   autoload :ExtKey, 'bitcoin/ext_key'
+  autoload :ExtPubkey, 'bitcoin/ext_key'
   autoload :Opcodes, 'bitcoin/opcodes'
   autoload :Node, 'bitcoin/node'
   autoload :Base58, 'bitcoin/base58'
@@ -101,6 +102,11 @@ module Bitcoin
       [self].pack('H*')
     end
 
+    # reverse hex string endian
+    def rhex
+      htb.reverse.bth
+    end
+
     # get opcode
     def opcode
       case encoding

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-18 00:00:00.000000000 Z
+date: 2018-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa