bitcoinrb 1.12.0 → 1.12.1

data/lib/bitcoin/network/message_handler.rb

@@ -1,243 +0,0 @@
-module Bitcoin
-  module Network
-
-    # P2P message handler used by peer connection class.
-    module MessageHandler
-
-      using Bitcoin::Ext::ObjectExt
-
-      # handle p2p message.
-      def handle(message)
-        peer.last_recv = Time.now.to_i
-        peer.bytes_recv += message.bytesize
-        begin
-          parse(message)
-        rescue Bitcoin::Message::Error => e
-          logger.error("invalid header magic. #{e.message}")
-          close
-        end
-      end
-
-      def parse(message)
-        @message += message
-        command, payload, rest = parse_header
-        return unless command
-
-        defer_handle_command(command, payload)
-        @message = ""
-        parse(rest) if rest && rest.bytesize > 0
-      end
-
-      def parse_header
-        head_magic = Bitcoin.chain_params.magic_head
-        return if @message.nil? || @message.size < MESSAGE_HEADER_SIZE
-
-        magic, command, length, checksum = @message.unpack('a4A12Va4')
-        raise Bitcoin::Message::Error, "invalid header magic. #{magic.bth}" unless magic.bth == head_magic
-
-        payload = @message[MESSAGE_HEADER_SIZE...(MESSAGE_HEADER_SIZE + length)]
-        return if payload.size < length
-        raise Bitcoin::Message::Error, "header checksum mismatch. #{checksum.bth}" unless Bitcoin.double_sha256(payload)[0...4] == checksum
-
-        rest = @message[(MESSAGE_HEADER_SIZE + length)..-1]
-        [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}.")
-        case command
-          when Bitcoin::Message::Version::COMMAND
-            on_version(Bitcoin::Message::Version.parse_from_payload(payload))
-          when Bitcoin::Message::VerAck::COMMAND
-            on_ver_ack
-          when Bitcoin::Message::GetAddr::COMMAND
-            on_get_addr
-          when Bitcoin::Message::Addr::COMMAND
-            on_addr(Bitcoin::Message::Addr.parse_from_payload(payload))
-          when Bitcoin::Message::SendHeaders::COMMAND
-            on_send_headers
-          when Bitcoin::Message::FeeFilter::COMMAND
-            on_fee_filter(Bitcoin::Message::FeeFilter.parse_from_payload(payload))
-          when Bitcoin::Message::Ping::COMMAND
-            on_ping(Bitcoin::Message::Ping.parse_from_payload(payload))
-          when Bitcoin::Message::Pong::COMMAND
-            on_pong(Bitcoin::Message::Pong.parse_from_payload(payload))
-          when Bitcoin::Message::GetHeaders::COMMAND
-            on_get_headers(Bitcoin::Message::GetHeaders.parse_from_payload(payload))
-          when Bitcoin::Message::Headers::COMMAND
-            on_headers(Bitcoin::Message::Headers.parse_from_payload(payload))
-          when Bitcoin::Message::Block::COMMAND
-            on_block(Bitcoin::Message::Block.parse_from_payload(payload))
-          when Bitcoin::Message::Tx::COMMAND
-            on_tx(Bitcoin::Message::Tx.parse_from_payload(payload))
-          when Bitcoin::Message::NotFound::COMMAND
-            on_not_found(Bitcoin::Message::NotFound.parse_from_payload(payload))
-          when Bitcoin::Message::MemPool::COMMAND
-            on_mem_pool
-          when Bitcoin::Message::Reject::COMMAND
-            on_reject(Bitcoin::Message::Reject.parse_from_payload(payload))
-          when Bitcoin::Message::SendCmpct::COMMAND
-            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))
-          when Bitcoin::Message::CmpctBlock::COMMAND
-            on_cmpct_block(Bitcoin::Message::CmpctBlock.parse_from_payload(payload))
-          when Bitcoin::Message::GetData::COMMAND
-            on_get_data(Bitcoin::Message::GetData.parse_from_payload(payload))
-          else
-            logger.warn("unsupported command received. command: #{command}, payload: #{payload.bth}")
-            close("with command #{command}")
-        end
-      end
-
-      def send_message(msg)
-        logger.info "send message #{msg.class::COMMAND}"
-        pkt = msg.to_pkt
-        peer.last_send = Time.now.to_i
-        peer.bytes_sent = pkt.bytesize
-        send_data(pkt)
-      end
-
-      def handshake_done
-        return unless @incomming_handshake && @outgoing_handshake
-        logger.info 'handshake finished.'
-        @connected = true
-        post_handshake
-      end
-
-      def on_version(version)
-        logger.info("receive version message. #{version.build_json}")
-        @version = version
-        send_message(Bitcoin::Message::VerAck.new)
-        @incomming_handshake = true
-        handshake_done
-      end
-
-      def on_ver_ack
-        logger.info('receive verack message.')
-        @outgoing_handshake = true
-        handshake_done
-      end
-
-      def on_get_addr
-        logger.info('receive getaddr message.')
-        peer.send_addrs
-      end
-
-      def on_addr(addr)
-        logger.info("receive addr message. #{addr.build_json}")
-        # TODO
-      end
-
-      def on_send_headers
-        logger.info('receive sendheaders message.')
-        @sendheaders = true
-      end
-
-      def on_fee_filter(fee_filter)
-        logger.info("receive feefilter message. #{fee_filter.build_json}")
-        @fee_rate = fee_filter.fee_rate
-      end
-
-      def on_ping(ping)
-        logger.info("receive ping message. #{ping.build_json}")
-        send_message(ping.to_response)
-      end
-
-      def on_pong(pong)
-        logger.info("receive pong message. #{pong.build_json}")
-        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.')
-        # TODO
-      end
-
-      def on_headers(headers)
-        logger.info('receive headers message.')
-        peer.handle_headers(headers)
-      end
-
-      def on_block(block)
-        logger.info('receive block message.')
-        # TODO
-      end
-
-      def on_tx(tx)
-        logger.info("receive tx message. #{tx.build_json}")
-        peer.handle_tx(tx)
-      end
-
-      def on_not_found(not_found)
-        logger.info("receive notfound message. #{not_found.build_json}")
-        # TODO
-      end
-
-      def on_mem_pool
-        logger.info('receive mempool message.')
-        # TODO return mempool tx
-      end
-
-      def on_reject(reject)
-        logger.warn("receive reject message. #{reject.build_json}")
-        # TODO
-      end
-
-      def on_send_cmpct(cmpct)
-        logger.info("receive sendcmpct message. #{cmpct.build_json}")
-        # TODO if mode is high and version is 1, relay block with cmpctblock message
-      end
-
-      def on_inv(inv)
-        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}")
-        peer.handle_merkle_block(merkle_block)
-      end
-
-      def on_cmpct_block(cmpct_block)
-        logger.info("receive cmpct_block message. #{cmpct_block.build_json}")
-      end
-
-      def on_get_data(get_data)
-        logger.info("receive get data message. #{get_data.build_json}")
-      end
-    end
-  end
-end

data/lib/bitcoin/network/peer.rb

@@ -1,228 +0,0 @@
-module Bitcoin
-  module Network
-
-    # remote peer class.
-    class Peer
-
-      # Interval for pinging peers.
-      PING_INTERVAL = 2 * 60
-
-      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, configuration)
-        @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
-        @relay = configuration.conf[:relay]
-        current_height = @chain.latest_block.height
-        remote_addr = Bitcoin::Message::NetworkAddr.new(ip: host, port: port, time: nil)
-        @local_version = Bitcoin::Message::Version.new(remote_addr: remote_addr, start_height: current_height, relay: @relay)
-      end
-
-      def connect
-        self.conn ||= EM.connect(host, port, Bitcoin::Network::Connection, self)
-      end
-
-      def connected?
-        @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
-        if remote_version.support?(Bitcoin::Message::SERVICE_FLAGS[:bloom])
-          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}
-        else
-          close("peer does not support NODE_BLOOM.")
-          pool.pending_peers.delete(self)
-        end
-      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.block_hash])
-        conn.send_message(get_headers)
-      end
-
-      # broadcast tx.
-      def broadcast_tx(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)
-          next unless entry
-          @best_hash = entry.block_hash
-          @best_height = entry.height
-        end
-        pool.changed
-        pool.notify_observers(:header, {hash: @best_hash, height: @best_height})
-        start_block_header_download if headers.headers.size > 0 # next header download
-      end
-
-      # handle error
-      def handle_error(e)
-        pool.handle_error(e)
-      end
-
-      def unbind
-        pool.handle_close_peer(self)
-      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
-        Bitcoin::Message::NetworkAddr.new(ip: host, port: port, services: v.services, time: v.timestamp)
-      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
-
-      def handle_tx(tx)
-        pool.changed
-        pool.notify_observers(:tx, tx)
-      end
-
-      def handle_merkle_block(merkle_block)
-        pool.changed
-        pool.notify_observers(:merkleblock, merkle_block)
-      end
-
-      # 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
-
-      # send filterload message.
-      def send_filter_load(bloom)
-        filter_load = Bitcoin::Message::FilterLoad.new(
-            bloom, Bitcoin::Message::FilterLoad::BLOOM_UPDATE_ALL)
-        conn.send_message(filter_load)
-      end
-
-      # send filteradd message.
-      def send_filter_add(element)
-        filter_add = Bitcoin::Message::FilterAdd.new(element)
-        conn.send_message(filter_add)
-      end
-
-      # send filterclear message.
-      def send_filter_clear
-        filter_clear = Bitcoin::Message::FilterClear.new
-        conn.send_message(filter_clear)
-      end
-    end
-  end
-end

data/lib/bitcoin/network/peer_discovery.rb

@@ -1,42 +0,0 @@
-module Bitcoin
-  module Network
-
-    class PeerDiscovery
-
-      attr_reader :logger, :configuration
-
-      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 + 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.'
-        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.compact
-      end
-    end
-  end
-end

data/lib/bitcoin/network/pool.rb

@@ -1,135 +0,0 @@
-module Bitcoin
-
-  module Network
-
-    # Time between pings automatically sent out for latency probing and keepalive (in seconds).
-    PING_INTERVAL = 2 * 60
-    # Time after which to disconnect, after waiting for a ping response (or inactivity).
-    TIMEOUT_INTERVAL = 20 * 60
-    # Maximum number of automatic outgoing nodes
-    MAX_OUTBOUND_CONNECTIONS = 4
-
-    # peer pool class.
-    class Pool
-      include Observable
-
-      attr_reader :peers # active peers
-      attr_reader :pending_peers # currently connecting peer
-      attr_reader :node
-      attr_reader :chain
-      attr_reader :max_outbound
-      attr_reader :logger
-      attr_reader :peer_discovery
-      attr_accessor :started
-      attr_reader :mutex
-
-      def initialize(node, chain, configuration)
-        @node = node
-        @peers = []
-        @pending_peers = []
-        @max_outbound = MAX_OUTBOUND_CONNECTIONS
-        @chain = chain
-        @logger = Bitcoin::Logger.create(:debug)
-        @configuration = configuration
-        @peer_discovery = PeerDiscovery.new(configuration)
-        @started = false
-        @mutex = Mutex.new
-      end
-
-      # connecting other peers and begin network activity.
-      def start
-        raise 'Cannot start a peer pool twice.' if started
-        logger.debug 'Start connecting other pears.'
-        addr_list = peer_discovery.peers
-
-        connect(addr_list)
-
-        @started = true
-      end
-
-      # detect new peer connection.
-      def handle_new_peer(peer)
-        logger.debug "connected new peer #{peer.addr}."
-        mutex.synchronize do
-          peer.id = allocate_peer_id
-          unless peers.find(&:primary?)
-            peer.primary = true
-            peer.start_block_header_download
-          end
-          peers << peer
-        end
-        pending_peers.delete(peer)
-        filter_load(peer) if node.wallet
-      end
-
-      def handle_close_peer(peer)
-        return unless started
-        peers.delete(peer)
-        pending_peers.delete(peer)
-        addr_list = peer_discovery.peers - peers.map(&:host) - pending_peers.map(&:host) - [peer.host]
-        connect(addr_list)
-      end
-
-      # terminate peers.
-      def 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(tx) }
-      end
-
-      # new bloom filter.
-      def filter_load(peer)
-        peer.send_filter_load(node.bloom)
-      end
-
-      # add element to bloom filter.
-      def filter_add(element)
-        peers.each { |peer| peer.send_filter_add(element) }
-      end
-
-      # clear bloom filter.
-      def filter_clear
-        peers.each { |peer| peer.send_filter_clear }
-      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
-
-      def connect(addr_list)
-        port = Bitcoin.chain_params.default_port
-
-        EM::Iterator.new(addr_list, Bitcoin::PARALLEL_THREAD).each do |ip, iter|
-          if pending_peers.size + peers.size < MAX_OUTBOUND_CONNECTIONS
-            peer = Peer.new(ip, port, self, @configuration)
-            pending_peers << peer
-            peer.connect
-            iter.next
-          end
-        end
-      end
-    end
-  end
-end

data/lib/bitcoin/network.rb

@@ -1,13 +0,0 @@
-require 'eventmachine'
-
-module Bitcoin
-  module Network
-
-    autoload :MessageHandler, 'bitcoin/network/message_handler'
-    autoload :Connection, 'bitcoin/network/connection'
-    autoload :Pool, 'bitcoin/network/pool'
-    autoload :Peer, 'bitcoin/network/peer'
-    autoload :PeerDiscovery, 'bitcoin/network/peer_discovery'
-
-  end
-end