bitcoinrb 0.3.1 → 0.7.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
@@ -34,13 +36,13 @@ module Bitcoin
     def self.parse_from_payload(payload, non_witness: false)
       buf = payload.is_a?(String) ? StringIO.new(payload) : payload
       tx = new
-      tx.version = buf.read(4).unpack('V').first
+      tx.version = buf.read(4).unpack1('V')
 
       in_count = Bitcoin.unpack_var_int_from_io(buf)
       witness = false
       if in_count.zero? && !non_witness
         tx.marker = 0
-        tx.flag = buf.read(1).unpack('c').first
+        tx.flag = buf.read(1).unpack1('c')
         if tx.flag.zero?
           buf.pos -= 1
         else
@@ -64,13 +66,13 @@ module Bitcoin
         end
       end
 
-      tx.lock_time = buf.read(4).unpack('V').first
+      tx.lock_time = buf.read(4).unpack1('V')
 
       tx
     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
@@ -192,22 +188,22 @@ module Bitcoin
     # @param [Integer] input_index input index.
     # @param [Integer] hash_type signature hash type
     # @param [Bitcoin::Script] output_script script pubkey or script code. if script pubkey is P2WSH, set witness script to this.
+    # @param [Hash] opts Data required for each sig version (amount and skip_separator_index params can also be set to this parameter)
     # @param [Integer] amount bitcoin amount locked in input. required for witness input only.
     # @param [Integer] skip_separator_index If output_script is P2WSH and output_script contains any OP_CODESEPARATOR,
     # the script code needs  is the witnessScript but removing everything up to and including the last executed OP_CODESEPARATOR before the signature checking opcode being executed.
-    def sighash_for_input(input_index, output_script, hash_type: SIGHASH_TYPE[:all],
+    def sighash_for_input(input_index, output_script = nil, opts: {}, hash_type: SIGHASH_TYPE[:all],
                           sig_version: :base, amount: nil, skip_separator_index: 0)
       raise ArgumentError, 'input_index must be specified.' unless input_index
       raise ArgumentError, 'does not exist input corresponding to input_index.' if input_index >= inputs.size
-      raise ArgumentError, 'script_pubkey must be specified.' unless output_script
-      raise ArgumentError, 'unsupported sig version specified.' unless SIG_VERSION.include?(sig_version)
-
-      if sig_version == :witness_v0 || Bitcoin.chain_params.fork_chain?
-        raise ArgumentError, 'amount must be specified.' unless amount
-        sighash_for_witness(input_index, output_script, hash_type, amount, skip_separator_index)
-      else
-        sighash_for_legacy(input_index, output_script, hash_type)
-      end
+      raise ArgumentError, 'script_pubkey must be specified.' if [:base, :witness_v0].include?(sig_version) && output_script.nil?
+
+      opts[:amount] = amount if amount
+      opts[:skip_separator_index] = skip_separator_index
+      opts[:sig_version] = sig_version
+      opts[:script_code] = output_script
+      sig_hash_gen = SigHashGenerator.load(sig_version)
+      sig_hash_gen.generate(self, input_index, hash_type, opts)
     end
 
     # verify input signature.
@@ -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)
@@ -249,73 +245,6 @@ module Bitcoin
 
     private
 
-    # generate sighash with legacy format
-    def sighash_for_legacy(index, script_code, hash_type)
-      ins = inputs.map.with_index do |i, idx|
-        if idx == index
-          i.to_payload(script_code.delete_opcode(Bitcoin::Opcodes::OP_CODESEPARATOR))
-        else
-          case hash_type & 0x1f
-            when SIGHASH_TYPE[:none], SIGHASH_TYPE[:single]
-              i.to_payload(Bitcoin::Script.new, 0)
-            else
-              i.to_payload(Bitcoin::Script.new)
-          end
-        end
-      end
-
-      outs = outputs.map(&:to_payload)
-      out_size = Bitcoin.pack_var_int(outputs.size)
-
-      case hash_type & 0x1f
-        when SIGHASH_TYPE[:none]
-          outs = ''
-          out_size = Bitcoin.pack_var_int(0)
-        when SIGHASH_TYPE[:single]
-          return "\x01".ljust(32, "\x00") if index >= outputs.size
-          outs = outputs[0...(index + 1)].map.with_index { |o, idx| (idx == index) ? o.to_payload : o.to_empty_payload }.join
-          out_size = Bitcoin.pack_var_int(index + 1)
-      end
-
-      if hash_type & SIGHASH_TYPE[:anyonecanpay] != 0
-        ins = [ins[index]]
-      end
-
-      buf = [[version].pack('V'), Bitcoin.pack_var_int(ins.size),
-          ins, out_size, outs, [lock_time, hash_type].pack('VV')].join
-
-      Bitcoin.double_sha256(buf)
-    end
-
-    # generate sighash with BIP-143 format
-    # https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki
-    def sighash_for_witness(index, script_pubkey_or_script_code, hash_type, amount, skip_separator_index)
-      hash_prevouts = Bitcoin.double_sha256(inputs.map{|i|i.out_point.to_payload}.join)
-      hash_sequence = Bitcoin.double_sha256(inputs.map{|i|[i.sequence].pack('V')}.join)
-      outpoint = inputs[index].out_point.to_payload
-      amount = [amount].pack('Q')
-      nsequence = [inputs[index].sequence].pack('V')
-      hash_outputs = Bitcoin.double_sha256(outputs.map{|o|o.to_payload}.join)
-
-      script_code = script_pubkey_or_script_code.to_script_code(skip_separator_index)
-
-      case (hash_type & 0x1f)
-      when SIGHASH_TYPE[:single]
-        hash_outputs = index >= outputs.size ? "\x00".ljust(32, "\x00") : Bitcoin.double_sha256(outputs[index].to_payload)
-        hash_sequence = "\x00".ljust(32, "\x00")
-      when SIGHASH_TYPE[:none]
-        hash_sequence = hash_outputs = "\x00".ljust(32, "\x00")
-      end
-
-      if (hash_type & SIGHASH_TYPE[:anyonecanpay]) != 0
-        hash_prevouts = hash_sequence ="\x00".ljust(32, "\x00")
-      end
-      hash_type |= (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)
-    end
-
     # verify input signature for legacy tx.
     def verify_input_sig_for_legacy(input_index, script_pubkey, flags)
       script_sig = inputs[input_index].script_sig

data/lib/bitcoin/tx_in.rb

@@ -37,13 +37,12 @@ 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.sequence = buf.read(4).unpack1('V')
       i
     end