tapyrus 0.3.9 → 0.4.0

data/exe/tapyrusrbd

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-require "thor"
-require "tapyrus"
-require "daemon_spawn"
-
-class TapyrusDaemon < DaemonSpawn::Base
-  def start(args)
-    puts "Tapyrusrb daemon start : #{Time.now}"
-    conf = Tapyrus::Node::Configuration.new(network: args.first[:network])
-    node = Tapyrus::Node::SPV.new(conf)
-    node.run
-  end
-end
-
-class Tapyrusrbd < Thor
-  class_option :network, aliases: "-n", default: :prod
-
-  desc "start", "start tapyrusrb daemon."
-  def start
-    network = options["network"] ? options["network"].to_sym : :prod
-    Tapyrus.chain_params = network
-    FileUtils.mkdir_p(Tapyrus.base_dir)
-    execute_daemon(["start", network: network])
-  end
-
-  private
-
-  def execute_daemon(cmd_args)
-    TapyrusDaemon.spawn!(
-      {
-        working_dir: Tapyrus.base_dir,
-        log_file: "#{Tapyrus.base_dir}/log/tapyrusrbd.log",
-        pid_file: "#{Tapyrus.base_dir}/tapyrusrbd.pid",
-        sync_log: true,
-        singleton: true
-      },
-      cmd_args
-    )
-  end
-end
-
-Tapyrusrbd.start(ARGV)

data/lib/tapyrus/network/connection.rb

@@ -1,70 +0,0 @@
-module Tapyrus
-  module Network
-    # Basic Bitcoin P2P connection class
-    class Connection < EM::Connection
-      include MessageHandler
-
-      attr_reader :peer, :logger
-
-      # remote peer version.
-      attr_accessor :version
-
-      # if true, this peer send new block announcements using a headers message rather than an inv message.
-      attr_accessor :sendheaders
-
-      # minimum fee(in satoshis per kilobyte) for relay tx
-      attr_accessor :fee_rate
-
-      def initialize(peer)
-        @peer = peer
-        @logger = peer.logger
-        @sendheaders = false
-        @attr_accessor = 0
-        @message = ""
-        self.pending_connect_timeout = 5.0
-      end
-
-      def post_init
-        logger.info "connected. #{addr}"
-        peer.conn_time = Time.now.to_i
-        begin_handshake
-      end
-
-      # handle receiving data from remote node.
-      def receive_data(data)
-        handle(data)
-      end
-
-      def post_handshake
-        peer.post_handshake
-      end
-
-      def addr
-        peer.addr
-      end
-
-      # close network connection.
-      def close(msg = "")
-        logger.info "close connection with #{addr}. #{msg}"
-        close_connection_after_writing
-      end
-
-      def handle_error(e)
-        peer.handle_error(e)
-      end
-
-      def unbind
-        logger.info "unbind. #{addr}"
-        peer.unbind
-      end
-
-      private
-
-      # start handshake
-      def begin_handshake
-        logger.info "begin handshake with #{addr}"
-        send_message(peer.local_version)
-      end
-    end
-  end
-end

data/lib/tapyrus/network/message_handler.rb

@@ -1,244 +0,0 @@
-module Tapyrus
-  module Network
-    # P2P message handler used by peer connection class.
-    module MessageHandler
-      using Tapyrus::Ext
-
-      # handle p2p message.
-      def handle(message)
-        peer.last_recv = Time.now.to_i
-        peer.bytes_recv += message.bytesize
-        begin
-          parse(message)
-        rescue Tapyrus::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 = Tapyrus.chain_params.magic_head
-        return if @message.nil? || @message.size < MESSAGE_HEADER_SIZE
-
-        magic, command, length, checksum = @message.unpack("a4A12Va4")
-        raise Tapyrus::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
-        unless Tapyrus.double_sha256(payload)[0...4] == checksum
-          raise Tapyrus::Message::Error, "header checksum mismatch. #{checksum.bth}"
-        end
-
-        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 do |e|
-            logger.error("error occurred. #{e.message}")
-            logger.error(e.backtrace)
-            peer.handle_error(e)
-          end
-        EM.defer(operation, callback, errback)
-      end
-
-      def handle_command(command, payload)
-        logger.info("[#{addr}] process command #{command}.")
-        case command
-        when Tapyrus::Message::Version::COMMAND
-          on_version(Tapyrus::Message::Version.parse_from_payload(payload))
-        when Tapyrus::Message::VerAck::COMMAND
-          on_ver_ack
-        when Tapyrus::Message::GetAddr::COMMAND
-          on_get_addr
-        when Tapyrus::Message::Addr::COMMAND
-          on_addr(Tapyrus::Message::Addr.parse_from_payload(payload))
-        when Tapyrus::Message::SendHeaders::COMMAND
-          on_send_headers
-        when Tapyrus::Message::FeeFilter::COMMAND
-          on_fee_filter(Tapyrus::Message::FeeFilter.parse_from_payload(payload))
-        when Tapyrus::Message::Ping::COMMAND
-          on_ping(Tapyrus::Message::Ping.parse_from_payload(payload))
-        when Tapyrus::Message::Pong::COMMAND
-          on_pong(Tapyrus::Message::Pong.parse_from_payload(payload))
-        when Tapyrus::Message::GetHeaders::COMMAND
-          on_get_headers(Tapyrus::Message::GetHeaders.parse_from_payload(payload))
-        when Tapyrus::Message::Headers::COMMAND
-          on_headers(Tapyrus::Message::Headers.parse_from_payload(payload))
-        when Tapyrus::Message::Block::COMMAND
-          on_block(Tapyrus::Message::Block.parse_from_payload(payload))
-        when Tapyrus::Message::Tx::COMMAND
-          on_tx(Tapyrus::Message::Tx.parse_from_payload(payload))
-        when Tapyrus::Message::NotFound::COMMAND
-          on_not_found(Tapyrus::Message::NotFound.parse_from_payload(payload))
-        when Tapyrus::Message::MemPool::COMMAND
-          on_mem_pool
-        when Tapyrus::Message::Reject::COMMAND
-          on_reject(Tapyrus::Message::Reject.parse_from_payload(payload))
-        when Tapyrus::Message::SendCmpct::COMMAND
-          on_send_cmpct(Tapyrus::Message::SendCmpct.parse_from_payload(payload))
-        when Tapyrus::Message::Inv::COMMAND
-          on_inv(Tapyrus::Message::Inv.parse_from_payload(payload))
-        when Tapyrus::Message::MerkleBlock::COMMAND
-          on_merkle_block(Tapyrus::Message::MerkleBlock.parse_from_payload(payload))
-        when Tapyrus::Message::CmpctBlock::COMMAND
-          on_cmpct_block(Tapyrus::Message::CmpctBlock.parse_from_payload(payload))
-        when Tapyrus::Message::GetData::COMMAND
-          on_get_data(Tapyrus::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(Tapyrus::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 Tapyrus::Message::Inventory::MSG_TX
-            txs << i.hash
-          when Tapyrus::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/tapyrus/network/peer.rb

@@ -1,210 +0,0 @@
-module Tapyrus
-  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 = Tapyrus::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 = Tapyrus::Message::NetworkAddr.new(ip: host, port: port, time: nil)
-        @local_version =
-          Tapyrus::Message::Version.new(remote_addr: remote_addr, start_height: current_height, relay: @relay)
-      end
-
-      def connect
-        self.conn ||= EM.connect(host, port, Tapyrus::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
-        pool.handle_new_peer(self)
-
-        # require remote peer to use headers message instead fo inv message.
-        conn.send_message(Tapyrus::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 =
-          Tapyrus::Message::GetHeaders.new(Tapyrus.chain_params.protocol_version, [chain.latest_block.block_hash])
-        conn.send_message(get_headers)
-      end
-
-      # broadcast tx.
-      def broadcast_tx(tx)
-        conn.send_message(Tapyrus::Message::Tx.new(tx))
-      end
-
-      # get peer's block type.
-      def block_type
-        Tapyrus::Message::Inventory::MSG_FILTERED_BLOCK # TODO need other implementation
-      end
-
-      # get remote peer's version message.
-      # @return [Tapyrus::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 [Tapyrus::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 Tapyrus::Message::NetworkAddr object from this peer info.
-      # @return [Tapyrus::Message::NetworkAddr]
-      def to_network_addr
-        v = remote_version
-        Tapyrus::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(Tapyrus::Message::Addr.new(addrs))
-      end
-
-      # handle block inv message.
-      def handle_block_inv(hashes)
-        getdata = Tapyrus::Message::GetData.new(hashes.map { |h| Tapyrus::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 = Tapyrus::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 = Tapyrus::Message::FilterLoad.new(bloom, Tapyrus::Message::FilterLoad::BLOOM_UPDATE_ALL)
-        conn.send_message(filter_load)
-      end
-
-      # send filteradd message.
-      def send_filter_add(element)
-        filter_add = Tapyrus::Message::FilterAdd.new(element)
-        conn.send_message(filter_add)
-      end
-
-      # send filterclear message.
-      def send_filter_clear
-        filter_clear = Tapyrus::Message::FilterClear.new
-        conn.send_message(filter_clear)
-      end
-    end
-  end
-end

data/lib/tapyrus/network/peer_discovery.rb

@@ -1,43 +0,0 @@
-module Tapyrus
-  module Network
-    class PeerDiscovery
-      attr_reader :logger, :configuration
-
-      def initialize(configuration)
-        @logger = Tapyrus::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
-        Tapyrus.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 do |seed|
-            begin
-              Socket.getaddrinfo(seed, Tapyrus.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
-          end
-          .flatten
-          .compact
-      end
-    end
-  end
-end