bitcoinrb 0.2.9 → 0.5.0

data/lib/bitcoin/store.rb

@@ -1,4 +1,4 @@
-require 'leveldb'
+require 'leveldb-native'
 
 module Bitcoin
   module Store
@@ -6,6 +6,7 @@ module Bitcoin
     autoload :DB, 'bitcoin/store/db'
     autoload :SPVChain, 'bitcoin/store/spv_chain'
     autoload :ChainEntry, 'bitcoin/store/chain_entry'
+    autoload :UtxoDB, 'bitcoin/store/utxo_db'
 
   end
 end

data/lib/bitcoin/store/chain_entry.rb

@@ -3,6 +3,7 @@ module Bitcoin
 
     # wrap a block header object with extra data.
     class ChainEntry
+      include Bitcoin::HexConverter
 
       attr_reader :header
       attr_reader :height

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

@@ -1,4 +1,4 @@
-require 'leveldb'
+require 'leveldb-native'
 
 module Bitcoin
   module Store
@@ -12,7 +12,7 @@ module Bitcoin
         def initialize(path = "#{Bitcoin.base_dir}/db/spv")
           # @logger = Bitcoin::Logger.create(:debug)
           FileUtils.mkdir_p(path)
-          @db = ::LevelDB::DB.new(path)
+          @db = ::LevelDBNative::DB.new(path)
           # logger.debug 'Opened LevelDB successfully.'
         end
 

data/lib/bitcoin/store/utxo_db.rb

@@ -0,0 +1,226 @@
+require 'leveldb-native'
+
+module Bitcoin
+  module Store
+    class UtxoDB
+
+      KEY_PREFIX = {
+        out_point: 'o',        # key: out_point(tx_hash and index), value: Utxo
+        script: 's',           # key: script_pubkey and out_point(tx_hash and index), value: Utxo
+        height: 'h',           # key: block_height and out_point, value: Utxo
+        tx_hash: 't',          # key: tx_hash of transaction, value: [block_height, tx_index]
+        block: 'b',            # key: block_height and tx_index, value: tx_hash
+        tx_payload: 'p',       # key: tx_hash, value: Tx
+      }
+
+      attr_reader :level_db, :logger
+
+      def initialize(path = "#{Bitcoin.base_dir}/db/utxo")
+        FileUtils.mkdir_p(path)
+        @level_db = ::LevelDBNative::DB.new(path)
+        @logger = Bitcoin::Logger.create(:debug)
+      end
+
+      def close
+        level_db.close
+      end
+
+      # Save payload of a transaction into db
+      #
+      # @param  [String] tx_hash
+      # @param  [String] tx_payload
+      def save_tx(tx_hash, tx_payload)
+        logger.info("UtxoDB#save_tx:#{[tx_hash, tx_payload]}")
+        level_db.batch do
+          # tx_hash -> [block_height, tx_index]
+          key = KEY_PREFIX[:tx_payload] + tx_hash
+          level_db.put(key, tx_payload)
+        end
+      end
+
+      # Save tx position (block height and index in the block) into db
+      # When node receives `header` message, node should call save_tx_position to store block height and its index.
+      #
+      # @param  [String] tx_hash
+      # @param  [Integer] block_height
+      # @param  [Integer] tx_index
+      def save_tx_position(tx_hash, block_height, tx_index)
+        logger.info("UtxoDB#save_tx_position:#{[tx_hash, block_height, tx_index]}")
+        level_db.batch do
+          # tx_hash -> [block_height, tx_index]
+          key = KEY_PREFIX[:tx_hash] + tx_hash
+          level_db.put(key, [block_height, tx_index].pack('N2').bth)
+
+          # block_hash and tx_index -> tx_hash
+          key = KEY_PREFIX[:block] + [block_height, tx_index].pack('N2').bth
+          level_db.put(key, tx_hash)
+        end
+      end
+
+      # Save utxo into db
+      #
+      # @param [Bitcoin::OutPoint] out_point
+      # @param [Double] value
+      # @param [Bitcoin::Script] script_pubkey
+      # @param [Integer] block_height
+      def save_utxo(out_point, value, script_pubkey, block_height=nil)
+        logger.info("UtxoDB#save_utxo:#{[out_point, value, script_pubkey, block_height]}")
+        level_db.batch do
+          utxo = Bitcoin::Wallet::Utxo.new(out_point.tx_hash, out_point.index, value, script_pubkey, block_height)
+          payload = utxo.to_payload
+
+          # out_point
+          key = KEY_PREFIX[:out_point] + out_point.to_hex
+          return if level_db.contains?(key)
+          level_db.put(key, payload)
+
+          # script_pubkey
+          if script_pubkey
+            key = KEY_PREFIX[:script] + script_pubkey.to_hex + out_point.to_hex
+            level_db.put(key, payload)
+          end
+
+          # height
+          unless block_height.nil?
+            key = KEY_PREFIX[:height] + [block_height].pack('N').bth + out_point.to_hex
+            level_db.put(key, payload)
+          end
+
+          utxo
+        end
+      end
+
+      # Get transaction stored via save_tx and save_tx_position
+      #
+      # @param  [string] tx_hash
+      # @return [block_height, tx_index, tx_payload]
+      def get_tx(tx_hash)
+        key = KEY_PREFIX[:tx_hash] + tx_hash
+        return [] unless level_db.contains?(key)
+        block_height, tx_index = level_db.get(key).htb.unpack('N2')
+        key = KEY_PREFIX[:tx_payload] + tx_hash
+        tx_payload = level_db.get(key)
+        [block_height, tx_index, tx_payload]
+      end
+
+      # Delete utxo from db
+      #
+      # @param  [Bitcoin::Outpoint] out_point
+      # @return [Bitcoin::Wallet::Utxo] 
+      def delete_utxo(out_point)
+        level_db.batch do
+          # [:out_point]
+          key = KEY_PREFIX[:out_point] + out_point.to_hex
+          return unless level_db.contains?(key)
+          utxo = Bitcoin::Wallet::Utxo.parse_from_payload(level_db.get(key))
+          level_db.delete(key)
+
+          # [:script]
+          if utxo.script_pubkey
+            key = KEY_PREFIX[:script] + utxo.script_pubkey.to_hex + out_point.to_hex
+            level_db.delete(key)
+          end
+
+          if utxo.block_height
+            # [:height]
+            key = KEY_PREFIX[:height] + [utxo.block_height].pack('N').bth + out_point.to_hex
+            level_db.delete(key)
+
+            # [:block]
+            key = KEY_PREFIX[:block] + [utxo.block_height, utxo.index].pack('N2').bth
+            level_db.delete(key)
+          end
+
+          # handles both [:tx_hash] and [:tx_payload]
+          if utxo.tx_hash
+            key = KEY_PREFIX[:tx_hash] + utxo.tx_hash
+            level_db.delete(key)
+
+            key = KEY_PREFIX[:tx_payload] + utxo.tx_hash
+            level_db.delete(key)
+          end
+
+          utxo
+        end
+      end
+
+      # Get utxo of the specified out point
+      #
+      # @param  [Bitcoin::Outpoint] out_point
+      # @return [Bitcoin::Wallet::Utxo]
+      def get_utxo(out_point)
+        level_db.batch do
+          key = KEY_PREFIX[:out_point] + out_point.to_hex
+          return unless level_db.contains?(key)
+          return Bitcoin::Wallet::Utxo.parse_from_payload(level_db.get(key))
+        end
+      end
+
+      # return [Bitcoin::Wallet::Utxo ...]
+      def list_unspent(current_block_height: 9999999, min: 0, max: 9999999, addresses: nil)
+        if addresses
+          list_unspent_by_addresses(current_block_height, min: min, max: max, addresses: addresses)
+        else
+          list_unspent_by_block_height(current_block_height, min: min, max: max)
+        end
+      end
+
+      # @param [Bitcoin::Wallet::Account]
+      # return [Bitcoin::Wallet::Utxo ...]
+      def list_unspent_in_account(account, current_block_height: 9999999, min: 0, max: 9999999)
+        return [] unless account
+
+        script_pubkeys = case account.purpose
+          when Bitcoin::Wallet::Account::PURPOSE_TYPE[:legacy]
+            account.watch_targets.map { |t| Bitcoin::Script.to_p2pkh(t).to_hex }
+          when Bitcoin::Wallet::Account::PURPOSE_TYPE[:nested_witness]
+            account.watch_targets.map { |t| Bitcoin::Script.to_p2wpkh(t).to_p2sh.to_hex }
+          when Bitcoin::Wallet::Account::PURPOSE_TYPE[:native_segwit]
+            account.watch_targets.map { |t| Bitcoin::Script.to_p2wpkh(t).to_hex }
+          end
+        list_unspent_by_script_pubkeys(current_block_height, min: min, max: max, script_pubkeys: script_pubkeys)
+      end
+
+      # @param [Bitcoin::Wallet::Account]
+      # return [Bitcoin::Wallet::Utxo ...]
+      def get_balance(account, current_block_height: 9999999, min: 0, max: 9999999)
+        list_unspent_in_account(account, current_block_height: current_block_height, min: min, max: max).sum { |u| u.value }
+      end
+
+      private
+
+      def utxos_between(from, to)
+        level_db.each(from: from, to: to).map { |k, v| Bitcoin::Wallet::Utxo.parse_from_payload(v) }
+      end
+
+      class ::Array
+        def with_height(min, max)
+          select { |u| u.block_height >= min && u.block_height <= max }
+        end
+      end
+
+      def list_unspent_by_block_height(current_block_height, min: 0, max: 9999999)
+        max_height = [current_block_height - min, 0].max
+        min_height = [current_block_height - max, 0].max
+        from = KEY_PREFIX[:height] + [min_height].pack('N').bth + '000000000000000000000000000000000000000000000000000000000000000000000000'
+        to = KEY_PREFIX[:height] + [max_height].pack('N').bth + 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+        utxos_between(from, to)
+      end
+
+      def list_unspent_by_addresses(current_block_height, min: 0, max: 9999999, addresses: [])
+        script_pubkeys = addresses.map { |a| Bitcoin::Script.parse_from_addr(a).to_hex }
+        list_unspent_by_script_pubkeys(current_block_height, min: min, max: max, script_pubkeys: script_pubkeys)
+      end
+
+      def list_unspent_by_script_pubkeys(current_block_height, min: 0, max: 9999999, script_pubkeys: [])
+        max_height = current_block_height - min
+        min_height = current_block_height - max
+        script_pubkeys.map do |key|
+          from = KEY_PREFIX[:script] + key + '000000000000000000000000000000000000000000000000000000000000000000000000'
+          to = KEY_PREFIX[:script] + key + 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+          utxos_between(from, to).with_height(min_height, max_height)
+        end.flatten
+      end
+    end
+  end
+end

data/lib/bitcoin/tx.rb

@@ -6,6 +6,8 @@ module Bitcoin
   # Transaction class
   class Tx
 
+    include Bitcoin::HexConverter
+
     MAX_STANDARD_VERSION = 2
 
     # The maximum weight for transactions we're willing to relay/mine
@@ -70,7 +72,7 @@ module Bitcoin
     end
 
     def hash
-      to_payload.bth.to_i(16)
+      to_hex.to_i(16)
     end
 
     def tx_hash
@@ -104,12 +106,6 @@ module Bitcoin
       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
@@ -202,7 +198,7 @@ module Bitcoin
       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 || Bitcoin.chain_params.fork_chain?
+      if sig_version == :witness_v0
         raise ArgumentError, 'amount must be specified.' unless amount
         sighash_for_witness(input_index, output_script, hash_type, amount, skip_separator_index)
       else
@@ -225,7 +221,7 @@ module Bitcoin
         script_pubkey = redeem_script if redeem_script.p2wpkh?
       end
 
-      if has_witness || Bitcoin.chain_params.fork_chain?
+      if has_witness
         verify_input_sig_for_witness(input_index, script_pubkey, amount, flags)
       else
         verify_input_sig_for_legacy(input_index, script_pubkey, flags)
@@ -310,7 +306,7 @@ module Bitcoin
       if (hash_type & SIGHASH_TYPE[:anyonecanpay]) != 0
         hash_prevouts = hash_sequence ="\x00".ljust(32, "\x00")
       end
-      hash_type |= (Bitcoin.chain_params.fork_id << 8) if Bitcoin.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
       Bitcoin.double_sha256(buf)

data/lib/bitcoin/tx_in.rb

@@ -37,11 +37,10 @@ module Bitcoin
       hash, index = buf.read(36).unpack('a32V')
       i.out_point = OutPoint.new(hash.bth, index)
       sig_length = Bitcoin.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 = Bitcoin::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
@@ -78,7 +77,7 @@ module Bitcoin
     # return previous output hash (not txid)
     def prev_hash
       return nil unless out_point
-      out_point.hash
+      out_point.tx_hash
     end
 
   end

data/lib/bitcoin/util.rb

@@ -61,7 +61,7 @@ module Bitcoin
     end
 
     def pack_boolean(b)
-      b ? [0xFF].pack('C') : [0x00].pack('C')
+      b ? [0x01].pack('C') : [0x00].pack('C')
     end
 
     def unpack_boolean(payload)
@@ -82,6 +82,15 @@ module Bitcoin
       byte.unpack('b*').first
     end
 
+    # padding zero to the left of binary string until bytesize.
+    # @param [String] binary string
+    # @param [Integer] bytesize total bytesize.
+    # @return [String] padded binary string.
+    def padding_zero(binary, bytesize)
+      return binary unless binary.bytesize < bytesize
+      ('00' * (bytesize - binary.bytesize)).htb + binary
+    end
+
     # generate sha256-ripemd160 hash for value
     def hash160(hex)
       Digest::RMD160.hexdigest(Digest::SHA256.digest(hex.htb))
@@ -119,6 +128,25 @@ module Bitcoin
       OpenSSL::HMAC.digest(DIGEST_NAME_SHA256, key, data)
     end
 
+    # check whether +addr+ is valid address.
+    # @param [String] addr an address
+    # @return [Boolean] if valid address return true, otherwise false.
+    def valid_address?(addr)
+      begin
+        Bitcoin::Script.parse_from_addr(addr)
+        true
+      rescue Exception
+        false
+      end
+    end
+
   end
 
+  module HexConverter
+
+    def to_hex
+      to_payload.bth
+    end
+
+  end
 end

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.2.9"
+  VERSION = "0.5.0"
 end

data/lib/bitcoin/wallet.rb

@@ -4,5 +4,6 @@ module Bitcoin
     autoload :Account, 'bitcoin/wallet/account'
     autoload :DB, 'bitcoin/wallet/db'
     autoload :MasterKey, 'bitcoin/wallet/master_key'
+    autoload :Utxo, 'bitcoin/wallet/utxo'
   end
 end

data/lib/bitcoin/wallet/account.rb

@@ -3,6 +3,7 @@ module Bitcoin
 
     # the account in BIP-44
     class Account
+      include Bitcoin::HexConverter
 
       PURPOSE_TYPE = {legacy: 44, nested_witness: 49, native_segwit: 84}
 

data/lib/bitcoin/wallet/base.rb

@@ -1,4 +1,4 @@
-require 'leveldb'
+require 'leveldb-native'
 module Bitcoin
   module Wallet
 
@@ -20,14 +20,14 @@ module Bitcoin
       # @param [String] wallet_id new wallet id.
       # @param [String] path_prefix wallet file path prefix.
       # @return [Bitcoin::Wallet::Base] the wallet
-      def self.create(wallet_id = 1, path_prefix = default_path_prefix)
+      def self.create(wallet_id = 1, path_prefix = default_path_prefix, purpose = Account::PURPOSE_TYPE[:native_segwit])
         raise ArgumentError, "wallet_id : #{wallet_id} already exist." if self.exist?(wallet_id, path_prefix)
         w = self.new(wallet_id, path_prefix)
         # generate seed
         raise RuntimeError, 'the seed already exist.' if w.db.registered_master?
         master = Bitcoin::Wallet::MasterKey.generate
         w.db.register_master_key(master)
-        w.create_account('Default')
+        w.create_account(purpose, 'Default')
         w
       end
 

data/lib/bitcoin/wallet/db.rb

@@ -15,7 +15,7 @@ module Bitcoin
 
       def initialize(path = "#{Bitcoin.base_dir}/db/wallet")
         FileUtils.mkdir_p(path)
-        @level_db = ::LevelDB::DB.new(path)
+        @level_db = ::LevelDBNative::DB.new(path)
       end
 
       # close database