tapyrus 0.1.0

data/lib/tapyrus/mnemonic.rb

@@ -0,0 +1,77 @@
+module Tapyrus
+
+  # Mnemonic code for generating deterministic keys
+  # https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
+  class Mnemonic
+
+    WORD_DIR = "#{__dir__}/mnemonic/wordlist"
+
+    attr_reader :word_list
+
+    def initialize(word_list)
+      raise ArgumentError, 'specified language is not supported.' unless Mnemonic.word_lists.include?(word_list)
+      @word_list = word_list
+    end
+
+    # get support language list
+    def self.word_lists
+      Dir.glob("#{WORD_DIR}/**.txt").map{|f| f.gsub("#{WORD_DIR}/", '').gsub('.txt', '') }
+    end
+
+    # generate entropy from mnemonic word
+    # @param [Array[String]] words the array of mnemonic word.
+    # @return [String] an entropy with hex format.
+    def to_entropy(words)
+      word_master = load_words
+      mnemonic = words.map do |w|
+        index = word_master.index(w.downcase)
+        raise IndexError, 'word not found in words list.' unless index
+        index.to_s(2).rjust(11, '0')
+      end.join
+      entropy = mnemonic.slice(0, (mnemonic.length * 32) / 33)
+      checksum = mnemonic.gsub(entropy, '')
+      raise SecurityError, 'checksum mismatch.' unless checksum == checksum(entropy)
+      [entropy].pack('B*').bth
+    end
+
+    # generate mnemonic words from entropy.
+    # @param [String] entropy an entropy with hex format.
+    # @return [Array] the array of mnemonic word.
+    def to_mnemonic(entropy)
+      raise ArgumentError, 'entropy is empty.' if entropy.nil? || entropy.empty?
+      e = entropy.htb.unpack('B*').first
+      seed = e + checksum(e)
+      mnemonic_index = seed.chars.each_slice(11).map{|i|i.join.to_i(2)}
+      word_master = load_words
+      mnemonic_index.map{|i|word_master[i]}
+    end
+
+    # generate seed from mnemonic
+    # if mnemonic protected with passphrase, specify that passphrase.
+    # @param [Array] mnemonic a array of mnemonic word.
+    # @param [String] passphrase a passphrase which protects mnemonic. the default value is an empty string.
+    # @return [String] seed
+    def to_seed(mnemonic, passphrase: '')
+      to_entropy(mnemonic)
+      OpenSSL::PKCS5.pbkdf2_hmac(mnemonic.join(' ').downcase,
+                                 'mnemonic' + passphrase, 2048, 64, OpenSSL::Digest::SHA512.new).bth
+    end
+
+    # calculate entropy checksum
+    # @param [String] entropy an entropy with bit string format
+    # @return [String] an entropy checksum with bit string format
+    def checksum(entropy)
+      b = Tapyrus.sha256([entropy].pack('B*')).unpack('B*').first
+      b.slice(0, (entropy.length/32))
+    end
+
+    private
+
+    # load word list contents
+    def load_words
+      File.readlines("#{WORD_DIR}/#{word_list}.txt").map(&:strip)
+    end
+
+  end
+
+end

data/lib/tapyrus/network/connection.rb

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,241 @@
+module Tapyrus
+  module Network
+
+    # P2P message handler used by peer connection class.
+    module MessageHandler
+
+      # 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
+        raise Tapyrus::Message::Error, "header checksum mismatch. #{checksum.bth}" unless Tapyrus.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 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

@@ -0,0 +1,223 @@
+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, support_witness?))
+      end
+
+      # check the remote peer support witness.
+      def support_witness?
+        return false unless remote_version
+        remote_version.services & Tapyrus::Message::SERVICE_FLAGS[:witness] > 0
+      end
+
+      # check the remote peer supports compact block.
+      def support_cmpct?
+        return false if remote_version.version < Tapyrus::Message::VERSION[:compact]
+        return true unless local_version.services & Tapyrus::Message::SERVICE_FLAGS[:witness] > 0
+        return false unless support_witness?
+        remote_version.version >= Tapyrus::Message::VERSION[:compact_witness]
+      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

@@ -0,0 +1,42 @@
+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 { |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
+        }.flatten.compact
+      end
+    end
+  end
+end