bitcoinrb 0.3.2 → 0.8.0

data/lib/bitcoin/sighash_generator.rb

@@ -0,0 +1,156 @@
+module Bitcoin
+
+  module SigHashGenerator
+
+    def self.load(sig_ver)
+      case sig_ver
+      when :base
+        LegacySigHashGenerator.new
+      when :witness_v0
+        SegwitSigHashGenerator.new
+      when :taproot, :tapscript
+        SchnorrSigHashGenerator.new
+      else
+        raise ArgumentError, "Unsupported sig version specified. #{sig_ver}"
+      end
+    end
+
+    # Legacy SigHash Generator
+    class LegacySigHashGenerator
+
+      def generate(tx, input_index, hash_type, opts)
+        output_script = opts[:script_code]
+        ins = tx.inputs.map.with_index do |i, idx|
+          if idx == input_index
+            i.to_payload(output_script.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 = tx.outputs.map(&:to_payload)
+        out_size = Bitcoin.pack_var_int(tx.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 input_index >= tx.outputs.size
+          outs = tx.outputs[0...(input_index + 1)].map.with_index { |o, idx| (idx == input_index) ? o.to_payload : o.to_empty_payload }.join
+          out_size = Bitcoin.pack_var_int(input_index + 1)
+        end
+
+        ins = [ins[input_index]] unless hash_type & SIGHASH_TYPE[:anyonecanpay] == 0
+
+        buf = [[tx.version].pack('V'), Bitcoin.pack_var_int(ins.size),
+               ins, out_size, outs, [tx.lock_time, hash_type].pack('VV')].join
+
+        Bitcoin.double_sha256(buf)
+      end
+
+    end
+
+    # V0 witness sighash generator.
+    # see: https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki
+    class SegwitSigHashGenerator
+
+      def generate(tx, input_index, hash_type, opts)
+        amount = opts[:amount]
+        output_script = opts[:script_code]
+        skip_separator_index = opts[:skip_separator_index]
+        hash_prevouts = Bitcoin.double_sha256(tx.inputs.map{|i|i.out_point.to_payload}.join)
+        hash_sequence = Bitcoin.double_sha256(tx.inputs.map{|i|[i.sequence].pack('V')}.join)
+        outpoint = tx.inputs[input_index].out_point.to_payload
+        amount = [amount].pack('Q')
+        nsequence = [tx.inputs[input_index].sequence].pack('V')
+        hash_outputs = Bitcoin.double_sha256(tx.outputs.map{|o|o.to_payload}.join)
+
+        script_code = output_script.to_script_code(skip_separator_index)
+
+        case (hash_type & 0x1f)
+        when SIGHASH_TYPE[:single]
+          hash_outputs = input_index >= tx.outputs.size ? "\x00".ljust(32, "\x00") : Bitcoin.double_sha256(tx.outputs[input_index].to_payload)
+          hash_sequence = "\x00".ljust(32, "\x00")
+        when SIGHASH_TYPE[:none]
+          hash_sequence = hash_outputs = "\x00".ljust(32, "\x00")
+        end
+
+        unless (hash_type & SIGHASH_TYPE[:anyonecanpay]) == 0
+          hash_prevouts = hash_sequence ="\x00".ljust(32, "\x00")
+        end
+
+        buf = [ [tx.version].pack('V'), hash_prevouts, hash_sequence, outpoint,
+                script_code ,amount, nsequence, hash_outputs, [tx.lock_time, hash_type].pack('VV')].join
+        Bitcoin.double_sha256(buf)
+      end
+
+    end
+
+    # v1 witness sighash generator
+    # see: https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki
+    class SchnorrSigHashGenerator
+
+      # generate signature hash for taproot and tapscript
+      # @param [Hash] opts some data using signature. This class requires following key params:
+      # - sig_version: sig version. :taproot or :tapscript
+      # - prevouts: array of all prevout[Txout]
+      # - annex: annex value with binary format if annex exist.
+      # - leaf_hash: leaf hash with binary format if sig_version is :tapscript, it required
+      # - last_code_separator_pos: the position of last code separator
+      # @return [String] signature hash with binary format.
+      def generate(tx, input_index, hash_type, opts)
+        raise ArgumentError, 'Invalid sig_version was specified.' unless [:taproot, :tapscript].include?(opts[:sig_version])
+
+        ext_flag = opts[:sig_version] == :taproot ? 0 : 1
+        key_version = 0
+        output_ype = hash_type == SIGHASH_TYPE[:default] ? SIGHASH_TYPE[:all] : (hash_type & 0x03)
+        input_type = hash_type & 0x80
+        epoc = '00'.htb
+
+        buf = epoc # EPOC
+        buf << [hash_type, tx.version, tx.lock_time].pack('CVV')
+        unless input_type == SIGHASH_TYPE[:anyonecanpay]
+          buf << Bitcoin.sha256(tx.in.map{|i|i.out_point.to_payload}.join) # sha_prevouts
+          buf << Bitcoin.sha256(opts[:prevouts].map(&:value).pack('Q*'))# sha_amounts
+          buf << Bitcoin.sha256(opts[:prevouts].map{|o|o.script_pubkey.to_payload(true)}.join) # sha_scriptpubkeys
+          buf << Bitcoin.sha256(tx.in.map(&:sequence).pack('V*')) # sha_sequences
+        end
+
+        buf << Bitcoin.sha256(tx.out.map(&:to_payload).join) if output_ype == SIGHASH_TYPE[:all]
+
+        spend_type = (ext_flag << 1) + (opts[:annex] ? 1 : 0)
+        buf << [spend_type].pack('C')
+        if input_type == SIGHASH_TYPE[:anyonecanpay]
+          buf << tx.in[input_index].out_point.to_payload
+          buf << opts[:prevouts][input_index].to_payload
+          buf << [tx.in[input_index].sequence].pack('V')
+        else
+          buf << [input_index].pack('V')
+        end
+
+        buf << Bitcoin.sha256(Bitcoin.pack_var_string(opts[:annex])) if opts[:annex]
+
+        if output_ype == SIGHASH_TYPE[:single]
+          raise ArgumentError, "Tx does not have #{input_index} th output." if input_index >= tx.out.size
+          buf << Bitcoin.sha256(tx.out[input_index].to_payload)
+        end
+
+        if opts[:sig_version] == :tapscript
+          buf << opts[:leaf_hash]
+          buf << [key_version, opts[:last_code_separator_pos]].pack("CV")
+        end
+
+        Bitcoin.tagged_hash('TapSighash', buf)
+      end
+
+    end
+
+  end
+
+end

data/lib/bitcoin/store.rb

@@ -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/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/taproot.rb

@@ -0,0 +1,9 @@
+module Bitcoin
+  module Taproot
+
+    class Error < StandardError; end
+
+    autoload :LeafNode, 'bitcoin/taproot/leaf_node'
+    autoload :SimpleBuilder, 'bitcoin/taproot/simple_builder'
+  end
+end

data/lib/bitcoin/taproot/leaf_node.rb

@@ -0,0 +1,23 @@
+module Bitcoin
+  module Taproot
+    class LeafNode
+
+      attr_reader :script, :leaf_ver
+
+      # Initialize
+      # @param [Bitcoin::Script] script Locking script
+      # @param [Integer] leaf_ver The leaf version of this script.
+      def initialize(script, leaf_ver)
+        raise Taproot::Error, 'script must be Bitcoin::Script object' unless script.is_a?(Bitcoin::Script)
+        @script = script
+        @leaf_ver = leaf_ver
+      end
+
+      # Calculate leaf hash.
+      # @return [String] leaf hash.
+      def leaf_hash
+        @hash_value ||= Bitcoin.tagged_hash('TapLeaf', [leaf_ver].pack('C') + Bitcoin.pack_var_string(script.to_payload))
+      end
+    end
+  end
+end

data/lib/bitcoin/taproot/simple_builder.rb

@@ -0,0 +1,139 @@
+module Bitcoin
+  module Taproot
+
+    # Utility class to construct Taproot outputs from internal key and script tree.
+    # SimpleBuilder builds a script tree that places all lock scripts, in the order they are added, as leaf nodes.
+    # It is not possible to specify the depth of the locking script or to insert any intermediate nodes.
+    class SimpleBuilder
+      include Bitcoin::Opcodes
+
+      attr_reader :internal_key # String with hex format
+      attr_reader :leaves # Array[LeafNode]
+
+      # Initialize builder.
+      # @param [String] internal_key Internal public key with hex format.
+      # @param [Array[Bitcoin::Script]] scripts Scripts for each lock condition.
+      # @param [Integer] leaf_ver (Optional) The leaf version of tapscript.
+      # @raise [Bitcoin::Taproot::Builder] +internal_pubkey+ dose not xonly public key or script in +scripts+ does not instance of Bitcoin::Script.
+      # @return [Bitcoin::Taproot::SimpleBuilder]
+      def initialize(internal_key, *scripts, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        raise Error, 'Internal public key must be 32 bytes' unless internal_key.htb.bytesize == 32
+        @leaves = scripts.map { |script| LeafNode.new(script, leaf_ver) }
+        @internal_key = internal_key
+      end
+
+      # Add lock script to leaf node.
+      # @param [Bitcoin::Script] script lock script.
+      # @param [Integer] leaf_ver (Optional) The leaf version of tapscript.
+      # @raise [Bitcoin::Taproot::Builder] If +script+ does not instance of Bitcoin::Script.
+      # @return [Bitcoin::Taproot::SimpleBuilder] self
+      def <<(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        leaves << LeafNode.new(script, leaf_ver)
+        self
+      end
+
+      # Build P2TR script.
+      # @return [Bitcoin::Script] P2TR script.
+      def build
+        q = tweak_public_key
+        Bitcoin::Script.new << OP_1 << q.xonly_pubkey
+      end
+
+      # Compute the tweaked public key.
+      # @return [Bitcoin::Key] the tweaked public key
+      def tweak_public_key
+        key = Bitcoin::Key.new(priv_key: tweak.bth, key_type: Key::TYPES[:compressed])
+        Bitcoin::Key.from_point(key.to_point + Bitcoin::Key.from_xonly_pubkey(internal_key).to_point)
+      end
+
+      # Compute the secret key for a tweaked public key.
+      # @param [Bitcoin::Key] key key object contains private key.
+      # @return [Bitcoin::Key] secret key for a tweaked public key
+      def tweak_private_key(key)
+        raise Error, 'Requires private key' unless key.priv_key
+        p = key.to_point
+        private_key = p.has_even_y? ? key.priv_key.to_i(16) : ECDSA::Group::Secp256k1.order - key.priv_key.to_i(16)
+        Bitcoin::Key.new(priv_key: ((tweak.bti + private_key) % ECDSA::Group::Secp256k1.order).to_even_length_hex)
+      end
+
+      # Generate control block needed to unlock with script-path.
+      # @param [Bitcoin::Script] script Script to use for unlocking.
+      # @param [Integer] leaf_ver leaf version of script.
+      # @return [String] control block with binary format.
+      def control_block(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        path = inclusion_proof(script, leaf_ver: leaf_ver)
+        parity = tweak_public_key.to_point.has_even_y? ? 0 : 1
+        [parity + leaf_ver].pack("C") + internal_key.htb + path.join
+      end
+
+      # Generate inclusion proof for +script+.
+      # @param [Bitcoin::Script] script The script in script tree.
+      # @param [Integer] leaf_ver (Optional) The leaf version of tapscript.
+      # @return [Array[String]] Inclusion proof.
+      def inclusion_proof(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        parents = leaves
+        parent_hash = leaf_hash(script, leaf_ver: leaf_ver)
+        proofs = []
+        until parents.size == 1
+          parents = parents.each_slice(2).map do |pair|
+            combined = combine_hash(pair)
+            unless pair.size == 1
+              if hash_value(pair[0]) == parent_hash
+                proofs << hash_value(pair[1])
+                parent_hash = combined
+              elsif hash_value(pair[1]) == parent_hash
+                proofs << hash_value(pair[0])
+                parent_hash = combined
+              end
+            end
+            combined
+          end
+        end
+        proofs
+      end
+
+      # Computes leaf hash
+      # @param [Bitcoin::Script] script
+      # @param [Integer] leaf_ver leaf version
+      # @@return [String] leaf hash with binary format.
+      def leaf_hash(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        raise Error, 'script does not exist' unless leaves.find{ |leaf| leaf.script == script}
+        LeafNode.new(script, leaf_ver).leaf_hash
+      end
+
+      private
+
+      # Compute tweak from script tree.
+      # @return [String] tweak with binary format.
+      def tweak
+        parents = leaves
+        if parents.empty?
+          parents = ['']
+        else
+          parents = parents.each_slice(2).map { |pair| combine_hash(pair) } until parents.size == 1
+        end
+        t = Bitcoin.tagged_hash('TapTweak', internal_key.htb + parents.first)
+        raise Error, 'tweak value exceeds the curve order' if t.bti >= ECDSA::Group::Secp256k1.order
+        t
+      end
+
+      def combine_hash(pair)
+        if pair.size == 1
+          hash_value(pair[0])
+        else
+          hash1 = hash_value(pair[0])
+          hash2 = hash_value(pair[1])
+
+          # Lexicographically sort a and b's hash, and compute parent hash.
+          payload = hash1.bth < hash2.bth ? hash1 + hash2 : hash2 + hash1
+          Bitcoin.tagged_hash('TapBranch', payload)
+        end
+      end
+
+      def hash_value(leaf_or_branch)
+        leaf_or_branch.is_a?(LeafNode) ? leaf_or_branch.leaf_hash : leaf_or_branch
+      end
+    end
+  end
+
+end