bitcoinrb 0.1.3 → 0.1.4

data/lib/bitcoin/rpc/request_handler.rb

@@ -0,0 +1,84 @@
+module Bitcoin
+  module RPC
+
+    # RPC server's request handler.
+    module RequestHandler
+
+      # Returns an object containing various state info regarding blockchain processing.
+      def getblockchaininfo
+        h = {}
+        h[:chain] = Bitcoin.chain_params.network
+        best_block = node.chain.latest_block
+        h[:headers] = best_block.height
+        h[:bestblockhash] = best_block.hash
+        h[:chainwork] = best_block.header.work
+        h[:mediantime] = node.chain.mtp(best_block.hash)
+        h
+      end
+
+      # shutdown node
+      def stop
+        node.shutdown
+      end
+
+      # get block header information.
+      def getblockheader(hash, verbose)
+        entry = node.chain.find_entry_by_hash(hash)
+        if verbose
+          {
+              hash: hash,
+              height: entry.height,
+              version: entry.header.version,
+              versionHex: entry.header.version.to_s(16),
+              merkleroot: entry.header.merkle_root,
+              time: entry.header.time,
+              mediantime: node.chain.mtp(hash),
+              nonce: entry.header.nonce,
+              bits: entry.header.bits.to_s(16),
+              previousblockhash: entry.prev_hash,
+              nextblockhash: node.chain.next_hash(hash)
+          }
+        else
+          entry.header.to_payload.bth
+        end
+      end
+
+      # Returns connected peer information.
+      def getpeerinfo
+        node.pool.peers.map do |peer|
+          local_addr = peer.remote_version.remote_addr[0..peer.remote_version.remote_addr.rindex(':')] + '18333'
+          {
+            id: peer.id,
+            addr: "#{peer.host}:#{peer.port}",
+            addrlocal: local_addr,
+            services: peer.remote_version.services.to_s(16).rjust(16, '0'),
+            relaytxes: peer.remote_version.relay,
+            lastsend: peer.last_send,
+            lastrecv: peer.last_recv,
+            bytessent: peer.bytes_sent,
+            bytesrecv: peer.bytes_recv,
+            conntime: peer.conn_time,
+            pingtime: peer.ping_time,
+            minping: peer.min_ping,
+            version: peer.remote_version.version,
+            subver: peer.remote_version.user_agent,
+            inbound: !peer.outbound?,
+            startingheight: peer.remote_version.start_height,
+            best_hash: peer.best_hash,
+            best_height: peer.best_height
+          }
+        end
+      end
+
+      # broadcast transaction
+      def sendrawtransaction(hex_tx)
+        tx = Bitcoin::Tx.parse_from_payload(hex_tx.htb)
+        # TODO check wether tx is valid
+        node.broadcast(tx)
+        tx.txid
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/rpc.rb

@@ -0,0 +1,6 @@
+module Bitcoin
+  module RPC
+    autoload :HttpServer, 'bitcoin/rpc/http_server'
+    autoload :RequestHandler, 'bitcoin/rpc/request_handler'
+  end
+end

data/lib/bitcoin/script/multisig.rb

@@ -0,0 +1,92 @@
+module Bitcoin
+
+  # utility for multisig
+  module Multisig
+    include Bitcoin::Opcodes
+
+    def self.prefix
+      [OP_0].pack("C*")
+    end
+
+    # generate input script sig spending a multisig output script.
+    # returns a raw binary script sig of the form:
+    #  OP_0 <sig> [<sig> ...]
+    # @param [[String]] array of signatures
+    # @return [String] script_sig for multisig
+    def self.to_multisig_script_sig(*sigs)
+      hash_type = sigs.last.is_a?(Numeric) ? sigs.pop : SIGHASH_TYPE[:all]
+      sigs.reverse.inject(prefix) { |joined, sig| add_sig_to_multisig_script_sig(sig, joined, hash_type) }
+    end
+
+    # take a multisig script sig (or p2sh multisig script sig) and add
+    # another signature to it after the OP_0. Used to sign a tx by
+    # multiple parties. Signatures must be in the same order as the
+    # pubkeys in the output script being redeemed.
+    def self.add_sig_to_multisig_script_sig(sig_to_add, script_sig, hash_type = SIGHASH_TYPE[:all])
+      signature = sig_to_add + [hash_type].pack("C*")
+      offset = script_sig.empty? ? 0 : 1
+      script_sig.insert(offset, Bitcoin::Script.pack_pushdata(signature))
+    end
+
+    # generate input script sig spending a p2sh-multisig output script.
+    # returns a raw binary script sig of the form:
+    #  OP_0 <sig> [<sig> ...] <redeem_script>
+    # @param [Script] redeem_script
+    # @param [[String]] array of signatures
+    # @return [String] script_sig for multisig
+    def self.to_p2sh_multisig_script_sig(redeem_script, *sigs)
+      to_multisig_script_sig(*sigs.flatten) + Bitcoin::Script.pack_pushdata(redeem_script)
+    end
+
+    # Sort signatures in the given +script_sig+ according to the order of pubkeys in
+    # the redeem script. Also needs the +sig_hash+ to match signatures to pubkeys.
+    # @param [String] signature for multisig.
+    # @param [String] sig_hash to be signed.
+    # @return [String] sorted sig_hash.
+    def self.sort_p2sh_multisig_signatures(script_sig, sig_hash)
+      script = Bitcoin::Script.parse_from_payload(script_sig)
+      redeem_script = Bitcoin::Script.parse_from_payload(script.chunks[-1].pushed_data)
+      pubkeys = redeem_script.get_multisig_pubkeys
+
+      # find the pubkey for each signature by trying to verify it
+      sigs = Hash[script.chunks[1...-1].map.with_index do |sig, idx|
+        sig = sig.pushed_data
+        pubkey = pubkeys.map do |key|
+          Bitcoin::Key.new(pubkey: key.bth).verify(sig, sig_hash) ? key : nil
+        end.compact.first
+        raise "Key for signature ##{idx} not found in redeem script!"  unless pubkey
+        [pubkey, sig]
+      end]
+
+      prefix + pubkeys.map { |k| sigs[k] ? Bitcoin::Script.pack_pushdata(sigs[k]) : nil }.join +
+        Bitcoin::Script.pack_pushdata(script.chunks[-1].pushed_data)
+    end
+
+    def self.add_sig_to_multisig_script_witness(sig_to_add, script_witness, hash_type = SIGHASH_TYPE[:all])
+      signature = sig_to_add + [hash_type].pack("C*")
+      script_witness.stack << signature
+    end
+
+    # Sort signatures in the given +script_witness+ according to the order of pubkeys in
+    # the redeem script. Also needs the +sig_hash+ to match signatures to pubkeys.
+    # @param [ScriptWitness] script_witness for multisig.
+    # @param [String] sig_hash to be signed.
+    def self.sort_witness_multisig_signatures(script_witness, sig_hash)
+      redeem_script = Bitcoin::Script.parse_from_payload(script_witness.stack[-1])
+      pubkeys = redeem_script.get_multisig_pubkeys
+      sigs = Hash[script_witness.stack[1...-1].map.with_index do |sig, idx|
+        pubkey = pubkeys.map do |key|
+          Bitcoin::Key.new(pubkey: key.bth).verify(sig, sig_hash) ? key : nil
+        end.compact.first
+        raise "Key for signature ##{idx} not found in redeem script!"  unless pubkey
+        [pubkey, sig]
+      end]
+      script_witness.stack.clear
+      script_witness.stack << ''
+      pubkeys.each do |pubkey|
+        script_witness.stack << sigs[pubkey] if sigs[pubkey]
+      end
+      script_witness.stack << redeem_script.to_payload
+    end
+  end
+end

data/lib/bitcoin/script/script.rb

@@ -35,6 +35,11 @@ module Bitcoin
       Script.new << OP_HASH160 << to_hash160 << OP_EQUAL
     end
 
+    def get_multisig_pubkeys
+      num = Bitcoin::Opcodes.opcode_to_small_int(chunks[-2].bth.to_i(16))
+      (1..num).map{ |i| chunks[i].pushed_data }
+    end
+
     # generate m of n multisig script
     # @param [String] m the number of signatures required for multisig
     # @param [Array] pubkeys array of public keys that compose multisig
@@ -43,6 +48,7 @@ module Bitcoin
       new << m << pubkeys << pubkeys.size << OP_CHECKMULTISIG
     end
 
+
     # generate p2wsh script for +redeem_script+
     # @param [Script] redeem_script target redeem script
     # @param [Script] p2wsh script
@@ -109,9 +115,8 @@ module Bitcoin
 
     def to_addr
       return p2pkh_addr if p2pkh?
-      return p2wpkh_addr if p2wpkh?
-      return p2wsh_addr if p2wsh?
       return p2sh_addr if p2sh?
+      return bech32_addr if witness_program?
     end
 
     # check whether standard script.
@@ -258,11 +263,16 @@ module Bitcoin
 
     def to_s
       chunks.map { |c|
-        if c.pushdata?
-          v = Opcodes.opcode_to_small_int(c.ord)
-          v ? v : c.pushed_data.bth
-        else
-          Opcodes.opcode_to_name(c.ord)
+        case c
+        when Integer
+          opcode_to_name(c)
+        when String
+          if c.pushdata?
+            v = Opcodes.opcode_to_small_int(c.ord)
+            v ? v : c.pushed_data.bth
+          else
+            Opcodes.opcode_to_name(c.ord)
+          end
         end
       }.join(' ')
     end

data/lib/bitcoin/script/script_interpreter.rb

@@ -589,7 +589,7 @@ module Bitcoin
 
     def check_signature_encoding(sig)
       return true if sig.size.zero?
-      if (flag?(SCRIPT_VERIFY_DERSIG) || flag?(SCRIPT_VERIFY_LOW_S) || flag?(SCRIPT_VERIFY_STRICTENC)) && !valid_signature_encoding?(sig)
+      if (flag?(SCRIPT_VERIFY_DERSIG) || flag?(SCRIPT_VERIFY_LOW_S) || flag?(SCRIPT_VERIFY_STRICTENC)) && !Key.valid_signature_encoding?(sig.htb)
         return set_error(SCRIPT_ERR_SIG_DER)
       elsif flag?(SCRIPT_VERIFY_LOW_S) && !low_der_signature?(sig)
         return false
@@ -599,44 +599,8 @@ module Bitcoin
       true
     end
 
-    # check +sig+ (hex) is correct der encoding.
-    # This function is consensus-critical since BIP66.
-    def valid_signature_encoding?(signature)
-      sig = signature.htb
-      return false if sig.bytesize < 9 || sig.bytesize > 73 # Minimum and maximum size check
-
-      s = sig.unpack('C*')
-
-      return false if s[0] != 0x30 || s[1] != s.size - 3 # A signature is of type 0x30 (compound). Make sure the length covers the entire signature.
-
-      len_r = s[3]
-      return false if 5 + len_r >= s.size # Make sure the length of the S element is still inside the signature.
-
-      len_s = s[5 + len_r]
-      return false unless len_r + len_s + 7 == s.size #Verify that the length of the signature matches the sum of the length of the elements.
-
-      return false unless s[2] == 0x02 # Check whether the R element is an integer.
-
-      return false if len_r == 0 # Zero-length integers are not allowed for R.
-
-      return false unless s[4] & 0x80 == 0 # Negative numbers are not allowed for R.
-
-      # Null bytes at the start of R are not allowed, unless R would otherwise be interpreted as a negative number.
-      return false if len_r > 1 && (s[4] == 0x00) && (s[5] & 0x80 == 0)
-
-      return false unless s[len_r + 4] == 0x02 # Check whether the S element is an integer.
-
-      return false if len_s == 0 # Zero-length integers are not allowed for S.
-      return false unless (s[len_r + 6] & 0x80) == 0 # Negative numbers are not allowed for S.
-
-      # Null bytes at the start of S are not allowed, unless S would otherwise be interpreted as a negative number.
-      return false if len_s > 1 && (s[len_r + 6] == 0x00) && (s[len_r + 7] & 0x80 == 0)
-
-      true
-    end
-
     def low_der_signature?(sig)
-      return set_error(SCRIPT_ERR_SIG_DER) unless valid_signature_encoding?(sig)
+      return set_error(SCRIPT_ERR_SIG_DER) unless Key.valid_signature_encoding?(sig.htb)
       return set_error(SCRIPT_ERR_SIG_HIGH_S) unless Key.low_signature?(sig.htb)
       true
     end

data/lib/bitcoin/store/chain_entry.rb

@@ -0,0 +1,64 @@
+module Bitcoin
+  module Store
+
+    # wrap a block header object with extra data.
+    class ChainEntry
+
+      attr_reader :header
+      attr_reader :height
+
+      # @param [Bitcoin::BlockHeader] header a block header.
+      # @param [Integer] height a block height.
+      def initialize(header, height)
+        @header = header
+        @height = height
+      end
+
+      # get database key
+      def key
+        Bitcoin::Store::KEY_PREFIX[:entry] + header.hash
+      end
+
+      # block hash
+      def hash
+        header.hash
+      end
+
+      # previous block hash
+      def prev_hash
+        header.prev_hash
+      end
+
+      # whether genesis block
+      def genesis?
+        Bitcoin.chain_params.genesis_block.header == header
+      end
+
+      # @param [String] payload a payload with binary format.
+      def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        len = Bitcoin.unpack_var_int_from_io(buf)
+        height = buf.read(len).reverse.bth.to_i(16)
+        new(Bitcoin::BlockHeader.parse_from_payload(buf.read(80)), height)
+      end
+
+      # build next block +StoredBlock+ instance.
+      # @param [Bitcoin::BlockHeader] next_block a next block candidate header.
+      # @return [Bitcoin::Store::ChainEntry] a next stored block (not saved).
+      def build_next_block(next_block)
+        ChainEntry.new(next_block, height + 1)
+      end
+
+      # generate payload
+      def to_payload
+        height_value = height.to_s(16)
+        height_value = '0' + height_value if height_value.length.odd?
+        height_value = height_value.htb.reverse
+        Bitcoin.pack_var_int(height_value.bytesize) + height_value + header.to_payload
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,101 @@
+require 'leveldb'
+
+module Bitcoin
+  module Store
+    module DB
+
+      class LevelDB
+
+        attr_reader :db
+        attr_reader :logger
+
+        def initialize(path = "#{Bitcoin.base_dir}/db/spv")
+          # @logger = Bitcoin::Logger.create(:debug)
+          FileUtils.mkdir_p(path)
+          @db = ::LevelDB::DB.new(path)
+          # logger.debug 'Opened LevelDB successfully.'
+        end
+
+        # put data into LevelDB.
+        # @param [Object] key a key.
+        # @param [Object] value a value.
+        def put(key, value)
+          # logger.debug "put #{key} data"
+          db.put(key, value)
+        end
+
+        # get value from specified key.
+        # @param [Object] key a key.
+        # @return[Object] the stored value.
+        def get(key)
+          db.get(key)
+        end
+
+        # get best block hash.
+        def best_hash
+          db.get(KEY_PREFIX[:best])
+        end
+
+        # delete specified key data.
+        def delete(key)
+          db.delete(key)
+        end
+
+        # get block hash specified +height+
+        def get_hash_from_height(height)
+          db.get(height_key(height))
+        end
+
+        # get next block hash specified +hash+
+        def next_hash(hash)
+          db.get(KEY_PREFIX[:next] + hash)
+        end
+
+        # get entry payload
+        # @param [String] hash the hash with hex format.
+        # @return [String] the ChainEntry payload.
+        def get_entry_payload_from_hash(hash)
+          db.get(KEY_PREFIX[:entry] + hash)
+        end
+
+        def save_entry(entry)
+          db.batch do
+            db.put(entry.key ,entry.to_payload)
+            db.put(height_key(entry.height), entry.hash)
+            connect_entry(entry)
+          end
+        end
+
+        def close
+          db.close
+        end
+
+        private
+
+        # generate height key
+        def height_key(height)
+          height = height.to_s(16)
+          height = '0' + height if height.bytesize.odd?
+          KEY_PREFIX[:height] + height.htb.reverse.bth
+        end
+
+        def connect_entry(entry)
+          unless entry.genesis?
+            tip_block = Bitcoin::Store::ChainEntry.parse_from_payload(get_entry_payload_from_hash(best_hash))
+            unless tip_block.hash == entry.prev_hash
+              raise "entry(#{entry.hash}) does not reference current best block hash(#{tip_block.hash})"
+            end
+            unless tip_block.height + 1 == entry.height
+              raise "block height is small than current best block."
+            end
+          end
+
+
+          db.put(KEY_PREFIX[:best], entry.hash)
+          db.put(KEY_PREFIX[:next] + entry.prev_hash, entry.hash)
+        end
+      end
+
+    end
+  end
+end

data/lib/bitcoin/store/db.rb

@@ -0,0 +1,9 @@
+module Bitcoin
+  module Store
+
+    module DB
+      autoload :LevelDB, 'bitcoin/store/db/level_db'
+    end
+
+  end
+end

data/lib/bitcoin/store/spv_chain.rb

@@ -0,0 +1,96 @@
+module Bitcoin
+
+  module Store
+
+    KEY_PREFIX = {
+        entry: 'e',   # key: block hash, value: Bitcoin::Store::ChainEntry payload
+        height: 'h',  # key: block height, value: block hash.
+        best: 'B',    # value: best block hash.
+        next: 'n'     # key: block hash, value: A hash of the next block of the specified hash
+    }
+
+    class SPVChain
+
+      attr_reader :db
+      attr_reader :logger
+
+      def initialize(db = Bitcoin::Store::DB::LevelDB.new)
+        @db = db # TODO multiple db switch
+        @logger = Bitcoin::Logger.create(:debug)
+        initialize_block
+      end
+
+      # get latest block in the store.
+      # @return[Bitcoin::Store::ChainEntry]
+      def latest_block
+        hash = db.best_hash
+        return nil unless hash
+        find_entry_by_hash(hash)
+      end
+
+      # find block entry with the specified height.
+      def find_entry_by_height(height)
+        find_entry_by_hash(db.get_hash_from_height(height))
+      end
+
+      # find block entry with the specified hash
+      def find_entry_by_hash(hash)
+        payload = db.get_entry_payload_from_hash(hash)
+        ChainEntry.parse_from_payload(payload)
+      end
+
+      # append block header to chain.
+      # @param [Bitcoin::BlockHeader] header a block header.
+      # @return [Bitcoin::Store::ChainEntry] appended block header entry.
+      def append_header(header)
+        logger.debug("append header #{header.hash}")
+        raise "this header is invalid. #{header.hash}" unless header.valid?
+        best_block = latest_block
+        current_height = best_block.height
+        if best_block.hash == header.prev_hash
+          entry = Bitcoin::Store::ChainEntry.new(header, current_height + 1)
+          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})."
+        end
+      end
+
+      # get next block hash for specified +hash+
+      # @param [String] hash the block hash
+      # @return [String] the next block hash. If it does not exist yet, return nil.
+      def next_hash(hash)
+        db.next_hash(hash)
+      end
+
+      # get median time past for specified block +hash+
+      # @param [String] hash the block hash.
+      # @return [Integer] the median time past value.
+      def mtp(hash)
+        time = []
+        Bitcoin::MEDIAN_TIME_SPAN.times do
+          entry = find_entry_by_hash(hash)
+          time << entry.header.time
+          hash = entry.header.prev_hash
+        end
+        time.sort!
+        time[time.size / 2]
+      end
+
+      private
+
+      # if database is empty, put genesis block.
+      def initialize_block
+        unless latest_block
+          block = Bitcoin.chain_params.genesis_block
+          genesis = ChainEntry.new(block.header, 0)
+          db.save_entry(genesis)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/bitcoin/store.rb

@@ -1,7 +1,11 @@
+require 'leveldb'
+
 module Bitcoin
   module Store
 
-    autoload :SPVBlockStore, 'bitcoin/store/spv_block_store'
+    autoload :DB, 'bitcoin/store/db'
+    autoload :SPVChain, 'bitcoin/store/spv_chain'
+    autoload :ChainEntry, 'bitcoin/store/chain_entry'
 
   end
 end

data/lib/bitcoin/tx.rb

@@ -35,8 +35,12 @@ module Bitcoin
       if in_count.zero?
         tx.marker = 0
         tx.flag = buf.read(1).unpack('c').first
-        in_count = Bitcoin.unpack_var_int_from_io(buf)
-        witness = true
+        if tx.flag.zero?
+          buf.pos -= 1
+        else
+          in_count = Bitcoin.unpack_var_int_from_io(buf)
+          witness = true
+        end
       end
 
       in_count.times do

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/bitcoin/wallet/account.rb

@@ -0,0 +1,82 @@
+module Bitcoin
+  module Wallet
+
+    # the account in BIP-44
+    class Account
+
+      PURPOSE_TYPE = {legacy: 44, nested_witness: 49}
+
+      attr_reader :purpose # either 44 or 49
+      attr_reader :index # BIP-44 index
+      attr_reader :name # account name
+      attr_accessor :receive_depth # receive address depth
+      attr_accessor :change_depth # change address depth
+      attr_accessor :lookahead
+      attr_accessor :wallet
+
+      def initialize(purpose = PURPOSE_TYPE[:legacy], index = 0, name = '')
+        @purpose = purpose
+        @index = index
+        @name = name
+        @receive_depth = 0
+        @change_depth = 0
+        @lookahead = 10
+      end
+
+      def self.parse_from_payload(payload)
+        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.receive_depth = receive_depth
+        a.change_depth = change_depth
+        a.lookahead = lookahead
+        a
+      end
+
+      def 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]
+      end
+
+      def init
+        lookahead.times do |index|
+          derive_receive(index)
+          derive_change(index)
+        end
+        @index = wallet.accounts.size
+        save
+      end
+
+      # derive receive key
+      def derive_receive(index)
+        derive(0, index)
+      end
+
+      # derive change key
+      def derive_change(index)
+        derive(1, index)
+      end
+
+      # save this account payload to database.
+      def save
+        wallet.db.save_account(self)
+      end
+
+      private
+
+      # derive key
+      def derive(branch, index)
+
+      end
+
+    end
+
+  end
+end