bitcoinrb 0.1.3 → 0.1.4

data/lib/bitcoin/network/message_handler.rb

@@ -6,7 +6,8 @@ module Bitcoin
 
       # handle p2p message.
       def handle(message)
-        logger.info "handle message #{message.bth}"
+        peer.last_recv = Time.now.to_i
+        peer.bytes_recv += message.bytesize
         begin
           parse(message)
         rescue Bitcoin::Message::Error => e
@@ -20,7 +21,7 @@ module Bitcoin
         command, payload, rest = parse_header
         return unless command
 
-        handle_command(command, payload)
+        defer_handle_command(command, payload)
         @message = ""
         parse(rest) if rest && rest.bytesize > 0
       end
@@ -40,8 +41,20 @@ module Bitcoin
         [command, payload, rest]
       end
 
+      # handle command with EM#defer
+      def defer_handle_command(command, payload)
+        operation = proc {handle_command(command, payload)}
+        callback = proc{|result|}
+        errback = proc{|e|
+          logger.error("error occurred. #{e.message}")
+          logger.error(e.backtrace)
+          peer.handle_error(e)
+        }
+        EM.defer(operation, callback, errback)
+      end
+
       def handle_command(command, payload)
-        logger.info("[#{addr}] process command #{command}. payload = #{payload.bth}")
+        logger.info("[#{addr}] process command #{command}.")
         case command
           when Bitcoin::Message::Version::COMMAND
             on_version(Bitcoin::Message::Version.parse_from_payload(payload))
@@ -77,6 +90,8 @@ module Bitcoin
             on_send_cmpct(Bitcoin::Message::SendCmpct.parse_from_payload(payload))
           when Bitcoin::Message::Inv::COMMAND
             on_inv(Bitcoin::Message::Inv.parse_from_payload(payload))
+          when Bitcoin::Message::MerkleBlock::COMMAND
+            on_merkle_block(Bitcoin::Message::MerkleBlock.parse_from_payload(payload))
           else
             logger.warn("unsupported command received. #{command}")
             close("with command #{command}")
@@ -85,14 +100,10 @@ module Bitcoin
 
       def send_message(msg)
         logger.info "send message #{msg.class::COMMAND}"
-        send_data(msg.to_pkt)
-      end
-
-      # start handshake
-      def begin_handshake
-        logger.info "begin handshake with #{addr}"
-        ver = Bitcoin::Message::Version.new(remote_addr: addr, start_height: 0) # TODO use start_height in wallet
-        send_message(ver)
+        pkt = msg.to_pkt
+        peer.last_send = Time.now.to_i
+        peer.bytes_sent = pkt.bytesize
+        send_data(pkt)
       end
 
       def handshake_done
@@ -114,6 +125,7 @@ module Bitcoin
 
       def on_get_addr
         logger.info('receive getaddr message.')
+        peer.send_addrs
       end
 
       def on_addr(addr)
@@ -138,26 +150,31 @@ module Bitcoin
 
       def on_pong(pong)
         logger.info("receive pong message. #{pong.build_json}")
-        # TODO calculate response
+        if pong.nonce == peer.last_ping_nonce
+          peer.last_ping_nonce = nil
+          peer.last_pong = Time.now.to_i
+        else
+          logger.debug "The remote peer sent the wrong nonce (#{pong.nonce})."
+        end
       end
 
       def on_get_headers(headers)
-        logger.info("receive getheaders message. #{headers.build_json}")
+        logger.info('receive getheaders message.')
         # TODO
       end
 
       def on_headers(headers)
-        logger.info("receive headers message. #{headers.build_json}")
-        # TODO
+        logger.info('receive headers message.')
+        peer.handle_headers(headers)
       end
 
       def on_block(block)
-        logger.info("receive block message. #{block.build_json}")
+        logger.info('receive block message.')
         # TODO
       end
 
       def on_tx(tx)
-        logger.info("receive tx message. #{tx.build_json}")
+        logger.info('receive tx message.')
         # TODO
       end
 
@@ -182,10 +199,26 @@ module Bitcoin
       end
 
       def on_inv(inv)
-        logger.info("receive inv message. #{inv.build_json}")
-        # TODO
+        logger.info('receive inv message.')
+        blocks = []
+        txs = []
+        inv.inventories.each do |i|
+          case i.identifier
+            when Bitcoin::Message::Inventory::MSG_TX
+              txs << i.hash
+            when Bitcoin::Message::Inventory::MSG_BLOCK
+              blocks << i.hash
+            else
+              logger.warn("[#{addr}] peer sent unknown inv type: #{i.identifier}")
+          end
+        end
+        logger.info("receive block= #{blocks.size}, txs: #{txs.size}")
+        peer.handle_block_inv(blocks) unless blocks.empty?
       end
 
+      def on_merkle_block(merkle_block)
+        logger.info("receive merkle block message. #{merkle_block.build_json}")
+      end
 
     end
   end

data/lib/bitcoin/network/peer.rb

@@ -4,21 +4,52 @@ module Bitcoin
     # remote peer class.
     class Peer
 
+      # Interval for pinging peers.
+      PING_INTERVAL = 30
+
+      attr_reader :logger
+      attr_accessor :id
+      attr_accessor :local_version
+      attr_accessor :last_send
+      attr_accessor :last_recv
+      attr_accessor :bytes_sent
+      attr_accessor :bytes_recv
+      attr_accessor :conn_time
+      attr_accessor :last_ping
+      attr_accessor :last_ping_nonce
+      attr_accessor :last_pong
+      attr_accessor :min_ping
+      attr_accessor :outbound # TODO need implements to accept inbound connection
+      attr_accessor :best_hash
+      attr_accessor :best_height
       # remote peer info
       attr_reader :host
       attr_reader :port
       # remote peer connection
       attr_accessor :conn
       attr_accessor :connected
+      attr_accessor :primary
       # parent pool
       attr_reader :pool
+      attr_reader :chain
       attr_accessor :fee_rate
 
       def initialize(host, port, pool)
         @host = host
         @port = port
         @pool = pool
+        @chain = pool.chain
         @connected = false
+        @primary = false
+        @logger = Bitcoin::Logger.create(:debug)
+        @outbound = true
+        @best_hash = -1
+        @best_height = -1
+        @min_ping = -1
+        @bytes_sent = 0
+        @bytes_recv = 0
+        current_height = @chain.latest_block.height
+        @local_version = Bitcoin::Message::Version.new(remote_addr: addr, start_height: current_height)
       end
 
       def connect
@@ -29,24 +60,130 @@ module Bitcoin
         @connected
       end
 
+      def outbound?
+        @outbound
+      end
+
       def addr
         "#{host}:#{port}"
       end
 
+      # calculate ping-pong time.
+      def ping_time
+        last_pong ? (last_pong - last_ping) / 1e6 : -1
+      end
+
+      # set last pong
+      def last_pong=(time)
+        @last_pong = time
+        @min_ping = ping_time if min_ping == -1 || ping_time < min_ping
+      end
+
       def post_handshake
         @connected = true
         pool.handle_new_peer(self)
+        # require remote peer to use headers message instead fo inv message.
+        conn.send_message(Bitcoin::Message::SendHeaders.new)
+        EM.add_periodic_timer(PING_INTERVAL) {send_ping}
+      end
+
+      # start block header download
+      def start_block_header_download
+        logger.info("[#{addr}] start block header download.")
+        get_headers = Bitcoin::Message::GetHeaders.new(
+            Bitcoin.chain_params.protocol_version, [chain.latest_block.hash])
+        conn.send_message(get_headers)
       end
 
       # broadcast tx.
       def broadcast_tx(tx)
-        send_message(Bitcoin::Message::Tx.new(tx, ))
+        conn.send_message(Bitcoin::Message::Tx.new(tx, support_witness?))
+      end
+
+      # check the remote peer support witness.
+      def support_witness?
+        return false unless remote_version
+        remote_version.services & Bitcoin::Message::SERVICE_FLAGS[:witness] > 0
+      end
+
+      # check the remote peer supports compact block.
+      def support_cmpct?
+        return false if remote_version.version < Bitcoin::Message::VERSION[:compact]
+        return true unless local_version.services & Bitcoin::Message::SERVICE_FLAGS[:witness] > 0
+        return false unless support_witness?
+        remote_version.version >= Bitcoin::Message::VERSION[:compact_witness]
+      end
+
+      # get peer's block type.
+      def block_type
+        Bitcoin::Message::Inventory::MSG_FILTERED_BLOCK # TODO need other implementation
+      end
+
+      # get remote peer's version message.
+      # @return [Bitcoin::Message::Version]
+      def remote_version
+        conn.version
+      end
+
+      # Whether to try and download blocks and transactions from this peer.
+      def primary?
+        primary
+      end
+
+      # handle headers message
+      # @params [Bitcoin::Message::Headers]
+      def handle_headers(headers)
+        headers.headers.each do |header|
+          break unless header.valid?
+          entry = chain.append_header(header)
+          @best_hash = entry.hash
+          @best_height = entry.height
+        end
+        start_block_header_download if headers.headers.size > 0 # next header download
+      end
+
+      # handle error
+      def handle_error(e)
+        pool.handle_error(e)
+      end
+
+      # close peer connection.
+      def close(msg = '')
+        conn.close(msg)
+      end
+
+      # generate Bitcoin::Message::NetworkAddr object from this peer info.
+      # @return [Bitcoin::Message::NetworkAddr]
+      def to_network_addr
+        v = remote_version
+        addr = Bitcoin::Message::NetworkAddr.new
+        addr.time = v.timestamp
+        addr.services = v.services
+        addr.ip = host
+        addr.port = port
+        addr
+      end
+
+      # send +addr+ message to remote peer
+      def send_addrs
+        addrs = pool.peers.select{|p|p != self}.map(&:to_network_addr)
+        conn.send_message(Bitcoin::Message::Addr.new(addrs))
+      end
+
+      # handle block inv message.
+      def handle_block_inv(hashes)
+        getdata = Bitcoin::Message::GetData.new(
+            hashes.map{|h|Bitcoin::Message::Inventory.new(block_type, h)})
+        conn.send_message(getdata)
       end
 
-      # check the remote peer support segwit.
-      def support_segwit?
-        return false unless conn.version
-        conn.version.services & Bitcoin::Message::SERVICE_FLAGS[:witness] > 0
+      # send ping message.
+      def send_ping
+        ping = Bitcoin::Message::Ping.new
+        @last_ping = Time.now.to_i
+        @last_pong = -1
+        @last_ping_nonce = ping.nonce
+        conn.send_message(ping)
       end
 
     end

data/lib/bitcoin/network/peer_discovery.rb

@@ -3,32 +3,40 @@ module Bitcoin
 
     class PeerDiscovery
 
-      attr_reader :logger
+      attr_reader :logger, :configuration
 
-      def initialize
+      def initialize(configuration)
         @logger = Bitcoin::Logger.create(:debug)
+        @configuration = configuration
       end
 
       # get peer addresses, from DNS seeds.
       def peers
         # TODO add find from previous connected peer at first.
-        find_from_dns_seeds
+        (find_from_dns_seeds + seeds).uniq
       end
 
       private
 
+      def dns_seeds
+        Bitcoin.chain_params.dns_seeds || []
+      end
+
+      def seeds
+        [*configuration.conf[:connect]]
+      end
+
       def find_from_dns_seeds
         logger.debug 'discover peer address from DNS seeds.'
-        Bitcoin.chain_params.dns_seeds.map {|seed|
+        dns_seeds.map { |seed|
           begin
             Socket.getaddrinfo(seed, Bitcoin.chain_params.default_port).map{|a|a[2]}.uniq
           rescue SocketError => e
             logger.error "SocketError occurred when load DNS seed: #{seed}, error: #{e.message}"
+            nil
           end
-        }.flatten
+        }.flatten.compact
       end
-
     end
-
   end
-end
+end

data/lib/bitcoin/network/pool.rb

@@ -20,13 +20,13 @@ module Bitcoin
       attr_reader :peer_discovery
       attr_accessor :started
 
-      def initialize
+      def initialize(chain, configuration)
         @peers = []
         @pending_peers = []
         @max_outbound = MAX_OUTBOUND_CONNECTIONS
-        @chain = Bitcoin::Node::SPVBlockChain.new
+        @chain = chain
         @logger = Bitcoin::Logger.create(:debug)
-        @peer_discovery = PeerDiscovery.new
+        @peer_discovery = PeerDiscovery.new(configuration)
         @started = false
       end
 
@@ -35,14 +35,14 @@ module Bitcoin
         raise 'Cannot start a peer pool twice.' if started
         logger.debug 'Start connecting other pears.'
         addr_list = peer_discovery.peers
+
         port = Bitcoin.chain_params.default_port
-        Parallel.map(addr_list, in_processes: 3) do |ip|
-          if peers.size < MAX_OUTBOUND_CONNECTIONS
-            EM.run do
-              peer = Peer.new(ip, port, self)
-              pending_peers << peer
-              peer.connect
-            end
+        EM::Iterator.new(addr_list, Bitcoin::PARALLEL_THREAD).each do |ip, iter|
+          if pending_peers.size < MAX_OUTBOUND_CONNECTIONS
+            peer = Peer.new(ip, port, self)
+            pending_peers << peer
+            peer.connect
+            iter.next
           end
         end
         @started = true
@@ -50,25 +50,50 @@ module Bitcoin
 
       # detect new peer connection.
       def handle_new_peer(peer)
-        logger.debug "connected new peer #{peer.addr}"
+        logger.debug "connected new peer #{peer.addr}."
+        peer.id = allocate_peer_id
+        unless peers.find(&:primary?)
+          peer.primary = true
+          peer.start_block_header_download
+        end
         peers << peer
         pending_peers.delete(peer)
       end
 
       # terminate peers.
       def terminate
-        peers.each {|peer| peer.close('terminate')}
+        peers.each { |peer| peer.close('terminate') }
+        pending_peers.each { |peer| peer.close('terminate') }
         @peers = []
         @started = false
       end
 
+      # broadcast tx to connecting peer.
       def broadcast(tx)
-        peers.each {|peer| peer.broadcast(tx) }
+        peers.each { |peer| peer.broadcast_tx(tx) }
+      end
+
+      def handle_error(e)
+        terminate
       end
 
       private
 
+      # get primary peer
+      def primary_peer
+        peers.find(&:primary?)
+      end
+
+      # allocate new peer id
+      def allocate_peer_id
+        id = 0
+        until peers.empty? || peers.find{|p|p.id == id}.nil?
+          id += 1
+        end
+        id
+      end
+
     end
 
   end
-end
+end

data/lib/bitcoin/network.rb

@@ -1,4 +1,3 @@
-require 'parallel'
 require 'eventmachine'
 
 module Bitcoin

data/lib/bitcoin/node/cli.rb

@@ -0,0 +1,66 @@
+require 'rest-client'
+require 'thor'
+require 'json'
+
+module Bitcoin
+  module Node
+
+    class CLI < Thor
+
+      class_option :network, aliases: '-n', default: :mainnet
+
+      desc 'getblockchaininfo', 'Returns an object containing various state info regarding blockchain processing.'
+      def getblockchaininfo
+        request('getblockchaininfo')
+      end
+
+      desc 'stop', 'Stop Bitcoin server.'
+      def stop
+        request('stop')
+      end
+
+      desc 'getblockheader "hash" ( verbose )', 'If verbose is false, returns a string that is serialized, hex-encoded data for blockheader "hash". If verbose is true, returns an Object with information about blockheader <hash>.'
+      def getblockheader(hash, verbose = true)
+        verbose = verbose.is_a?(String) ? (verbose == 'true') : verbose
+        request('getblockheader', hash, verbose)
+      end
+
+      desc 'getpeerinfo', 'Returns data about each connected network node as a json array of objects.'
+      def getpeerinfo
+        request('getpeerinfo')
+      end
+
+      desc 'sendrawtransaction', 'Submits raw transaction (serialized, hex-encoded) to local node and network.'
+      def sendrawtransaction(hex_tx)
+        request('sendrawtransaction', hex_tx)
+      end
+
+      private
+
+      def config
+        opts = {}
+        opts[:network] = options['network'] if options['network']
+        @conf ||= Bitcoin::Node::Configuration.new(opts)
+      end
+
+      def request(command, *params)
+        data = {
+            :method => command,
+            :params => params,
+            :id => 'jsonrpc'
+        }
+        begin
+          RestClient::Request.execute(method: :post, url: config.server_url, payload: data.to_json,
+                                      headers: {content_type: :json}) do |response, request, result|
+            return false if !result.kind_of?(Net::HTTPSuccess) && response.empty?
+            json = JSON.parse(response.to_str)
+            puts JSON.pretty_generate(json)
+          end
+        rescue Exception => e
+          puts e.message
+        end
+      end
+
+    end
+  end
+end

data/lib/bitcoin/node/configuration.rb

@@ -0,0 +1,37 @@
+require 'iniparse'
+
+module Bitcoin
+  module Node
+    class Configuration
+
+      attr_reader :conf
+
+      def initialize(opts = {})
+        # TODO apply configuration file.
+        opts[:network] = :mainnet unless opts[:network]
+        Bitcoin.chain_params = opts[:network]
+
+        begin
+          ini_file = IniParse.parse(File.read("#{Bitcoin.base_dir}/bitcoinrb.conf"))
+          @conf = Hash[ ini_file.to_h['__anonymous__'].map{|k,v| [k.to_sym, v] } ]
+        rescue => e
+          @conf = {}
+        end
+        @conf.merge!(opts)
+      end
+
+      def host
+        'localhost'
+      end
+
+      def port
+        Bitcoin.chain_params.default_port - 1
+      end
+
+      def server_url
+        "http://#{host}:#{port}"
+      end
+
+    end
+  end
+end

data/lib/bitcoin/node/spv.rb

@@ -4,21 +4,31 @@ module Bitcoin
     # SPV class
     class SPV
 
+      attr_reader :chain
       attr_reader :pool
       attr_reader :logger
       attr_accessor :running
+      attr_reader :configuration
+      attr_accessor :server
 
-      def initialize
-        @pool = Bitcoin::Network::Pool.new
+      def initialize(configuration)
+        @chain = Bitcoin::Store::SPVChain.new
+        @configuration = configuration
+        @pool = Bitcoin::Network::Pool.new(@chain, @configuration)
         @logger = Bitcoin::Logger.create(:debug)
         @running = false
       end
 
       # open the node.
       def run
+        # TODO need process running check.
         return if running
         logger.debug 'SPV node start running.'
-        pool.start
+        EM.run do
+          # EM.start_server('0.0.0.0', Bitcoin.chain_params.default_port, Bitcoin::Network::InboundConnector, self)
+          pool.start
+          @server = Bitcoin::RPC::HttpServer.run(self, configuration.port)
+        end
       end
 
       # close the node.

data/lib/bitcoin/node.rb

@@ -1,6 +1,7 @@
 module Bitcoin
   module Node
     autoload :SPV, 'bitcoin/node/spv'
-    autoload :SPVBlockChain, 'bitcoin/node/spv_block_chain'
+    autoload :CLI, 'bitcoin/node/cli'
+    autoload :Configuration, 'bitcoin/node/configuration'
   end
 end

data/lib/bitcoin/rpc/http_server.rb

@@ -0,0 +1,56 @@
+require 'evma_httpserver'
+require 'json'
+
+module Bitcoin
+  module RPC
+
+    # Bitcoinrb RPC server.
+    class HttpServer < EM::Connection
+      include EM::HttpServer
+      include RequestHandler
+
+      attr_reader :node
+      attr_accessor :logger
+
+      def initialize(node)
+        @node = node
+        @logger = Bitcoin::Logger.create(:debug)
+      end
+
+      def post_init
+        super
+        logger.debug 'start http server.'
+      end
+
+      def self.run(node, port = 8332)
+        EM.start_server('0.0.0.0', port, HttpServer, node)
+      end
+
+      # process http request.
+      def process_http_request
+        operation = proc {
+          command, args = parse_json_params
+          logger.debug("process http request. command = #{command}")
+          send(command, *args).to_json
+        }
+        callback = proc{ |result|
+          response = EM::DelegatedHttpResponse.new(self)
+          response.status = 200
+          response.content_type 'application/json'
+          response.content = result
+          response.send_response
+        }
+        EM.defer(operation, callback)
+      end
+
+      # parse request parameter.
+      # @return [Array] the array of command and args
+      def parse_json_params
+        params = JSON.parse(@http_post_content)
+        [params['method'], params['params']]
+      end
+
+    end
+
+  end
+end