bitcoin_node 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48d06efa48cc2005ed61b0f93c74b60c908a0e16
-  data.tar.gz: c0a85ea6484d812575e186f853989e39161890a0
+  metadata.gz: 50c1b46b013075e9d27e561239c9ca3f03d50237
+  data.tar.gz: a165a27047b94ea084f55e761dfcfb939b3dca4e
 SHA512:
-  metadata.gz: 71e234828fdcb3f467e4124aade08d5d4ba9c4b15bd45c63a3147b107cdc764413a2a2a774ccce8223d79d58b5e19d1d1a49755bb8fb9b4ff8de5b3e66071b4e
-  data.tar.gz: 9d2503e3af79a1a705fc2283a4a45040c1a7a1f8f5da5718db422705440c942965e080fc3f388c9dead2e2eeea8ea92b27a3e98a3349586eab54c39d90f95890
+  metadata.gz: afea8a1965550c6c9d4b24eb6eead1895e8814d8818012759906430fc625e712b0d3d2139ce5a0f1d108b1b2a314d7d05649c4f9aff3eeccb87f2e10ea27da96
+  data.tar.gz: fd14859b97c3410cd825b6dce8a270eb8e00107d9946caf7093f58e12c6e4ad6a8435fc3502c458759c0836d347e8b26ddcd27a71d500df258affa5162bb4354

data/README.md

@@ -1,32 +1,45 @@
 # BitcoinNode
 
-Study of Bitcoin protocol by implementing a simple node 
-in the p2p bitcoin network
+Study of Bitcoin protocol by implementing a simple node in the p2p bitcoin network.
 
-Using as much as Ruby stdlib as possible. Main foreign dependency is Celluloid::IO
+Using as much as Ruby stdlib as possible. Main foreign dependency is `Celluloid::IO`
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add to your Gemfile `gem 'bitcoin_node'` or locally run
 
-    gem 'bitcoin_node'
+    $ gem install bitcoin_node
 
-And then execute:
+Test
 
-    $ bundle
+    $ bundle exec rspec
 
-Or install it yourself as:
+## Usage
 
-    $ gem install bitcoin_node
+### Create messages
 
-## Usage
+```ruby
+require 'bitcoin_node'
+
+ping = BitcoinNode::Protocol::Messages.ping
+# => #<BitcoinNode::Protocol::Message:0x007feb24e1fa20 @payload=#<Ping {:nonce=>#<struct Integer64Field 12031756400052209357>}>, @command="ping">
+
+ping.raw
+# => "\xF9\xBE\xB4\xD9ping\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\xAB\x0F\x0FZ\x95\xDC{\xA1\xB1i\x11]"
+
+version = BN::Protocol::Messages.version
+```
+
+### Single client
+
+```ruby
+require 'bitcoin_node'
 
-TODO: Write usage instructions here
+host = '144.76.217.165'
 
-## Contributing
+client = BN::P2P::Client.connect(host)
 
-1. Fork it ( https://github.com/[my-github-username]/bitcoin_node/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+client.send(BN::Protocol::Messages.version)
+client.send(BN::Protocol::Messages.ping)
+client.send(BN::Protocol::Messages.getaddr)
+```

data/bin/bitcoin_node

@@ -1,3 +1,20 @@
 #!/usr/bin/env ruby
 
 require 'bitcoin_node'
+require 'resolv'
+
+SEED = 'seed.bitcoin.sipa.be'
+hosts = Resolv::DNS.new.getaddresses(SEED).map(&:to_s).sample(4)
+
+threads = hosts.map do |host|
+  Thread.new(host) do |h|
+    client = BN::P2p::Client.connect(h)
+
+    client.send(BN::P::Messages.version)
+    client.send(BN::P::Messages.ping)
+  end
+end
+
+threads.map(&:join)
+
+sleep(20)

data/bitcoin_node.gemspec

@@ -18,6 +18,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "celluloid-io"
+
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
 end

data/examples/spike.rb

@@ -0,0 +1,16 @@
+# encoding: ascii-8bit
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'bitcoin_node'
+
+host = ARGV[0] || (abort 'Missing host') 
+
+payload = BN::Protocol::Version.new(addr_recv: [host, 8333])
+
+message = BN::Protocol::Message.new(payload)
+
+client = BN::P2P::Client.connect(host)
+client.send(message)
+client.send(BN::Protocol::Messages.ping)
+client.send(BN::Protocol::Messages.getaddr)
+

data/lib/bitcoin_node.rb

@@ -1,5 +1,20 @@
-require "bitcoin_node/version"
+# coding: ascii-8bit
+require 'logger'
+
+require 'bitcoin_node/version'
+require 'bitcoin_node/protocol'
+require 'bitcoin_node/p2p'
 
 module BitcoinNode
-  # Your code goes here...
+  NETWORKS = { main: "\xF9\xBE\xB4\xD9".freeze, testnet: "\xFA\xBF\xB5\xDA".freeze }
+
+  def self.network
+    NETWORKS[:main]
+  end
+
+  Logger = ::Logger.new(STDOUT)
+  Logger.progname = 'NODE'
 end
+
+BN = BitcoinNode
+BN::P = BN::Protocol

data/lib/bitcoin_node/p2p.rb

@@ -0,0 +1,10 @@
+module BitcoinNode
+  module P2p
+  end
+  
+  P2P = P2p
+end
+
+require_relative 'p2p/probe'
+require_relative 'p2p/client'
+require_relative 'p2p/server'

data/lib/bitcoin_node/p2p/client.rb

@@ -0,0 +1,108 @@
+require 'socket'
+
+module BitcoinNode
+  module P2p
+    class Client
+      def self.connect(host, port = 8333, probe = LoggingProbe.new("client-#{host}"))
+        new(host, port, probe)
+      end
+
+      attr_accessor :handshaked, :version
+
+      def initialize(host, port = 8333, probe = LoggingProbe.new("client-#{host}"))
+        @host, @buffer, @probe = host, String.new, probe
+        @socket = TCPSocket.new(host, port)
+        @handshaked = false
+        @version = BN::Protocol::VERSION
+        @probe << { connected: host }
+      end
+
+      alias_method :handshaked?, :handshaked
+
+      def send(message)
+        raise ArgumentError unless BN::Protocol::Message === message
+
+        @probe << { sending: message.command }
+        @socket.write(message.raw)
+
+        loop {
+          @buffer << @socket.readpartial(1024)
+          handler = CommandHandler.new(self, @buffer, @probe)
+          if handler.valid_message?
+            handler.parse
+            break
+          end
+        }
+      rescue IOError => e
+        BN::ClientLogger.error(e.message)
+      end
+
+      def close!
+        @socket.close
+        @probe << { closed: @host }
+      end
+
+      class CommandHandler
+        def initialize(client, buffer, probe)
+          @client, @buffer, @probe = client, buffer, probe
+        end
+
+        def parse
+          @probe << { receiving: @command }
+
+          callback = Parser.new(@command, @payload).parse
+
+          @buffer.clear
+          callback.call(@client)
+        end
+
+        def valid_message?
+          @payload, @command = BN::Protocol::Message.validate(@buffer)
+        rescue BN::P::IncompleteMessageError
+          false
+        rescue BN::P::InvalidChecksumError => e  
+          BN::Logger.info(e.message)
+          false
+        end
+      end
+
+      class Parser
+        def initialize(command, payload)
+          @command, @payload = command, payload
+        end
+
+        def parse
+          callback = Proc.new {}
+
+          if @command == 'version'
+            received = BN::Protocol::Version.parse(@payload)
+            remote_protocol_version = received.protocol_version.value
+            callback = lambda do |client|
+              client.version = [remote_protocol_version, client.version].min
+              client.send(BN::Protocol::Messages.verack)
+            end
+          end
+
+          if @command == 'verack'
+            BN::Logger.info('Version handshake finished')
+            callback = lambda { |client| client.handshaked = true }
+          end
+
+          if @command == 'addr'
+            BN::Logger.info('Parsing addresses')
+            BN::Protocol::Addr.parse(@payload)
+          end
+
+          if @command == 'inv'
+            BN::Logger.info('Parsing inv')
+            p BN::Protocol::Inv.parse(@payload)
+          end
+
+          callback
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bitcoin_node/p2p/probe.rb

@@ -0,0 +1,43 @@
+module BitcoinNode
+  module P2p
+    class NullProbe
+      def <<(*args); end
+    end
+
+    class StoreProbe
+      attr_reader :store
+
+      def initialize
+        @store = Hash.new { |h, key| h[key] = [] }
+      end
+
+      def <<(hash)
+        hash.each do |key, value|
+          store[key] << value
+        end
+      end
+    end
+
+    class LoggingProbe
+      attr_reader :logger
+
+      def initialize(progname)
+        @logger = ::Logger.new(STDOUT)
+        @logger.progname = progname.upcase
+      end
+
+      def <<(hash)
+        hash.each do |key, value|
+          case key
+          when :sending then logger.info("Sending #{value}")
+          when :receiving then logger.info("Receiving #{value}")
+          when :connected then logger.info("Connected to #{value}")
+          when :connection then logger.info("Connection received from #{value}")
+          when :closed then logger.info("Closed connection to #{value}")
+          else logger.unknown('Cannot log that!!')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin_node/p2p/server.rb

@@ -0,0 +1,63 @@
+require 'socket'
+require 'celluloid/io'
+
+module BitcoinNode
+  module P2p
+    class Server
+      include Celluloid::IO
+      finalizer :shutdown
+
+      def initialize(port = 3333,  probe = LoggingProbe.new('server'))
+        @server = TCPServer.new('localhost', port)
+        @probe  = probe
+        async.run
+      end
+
+      def run
+        loop { async.accept_connection @server.accept }
+      end
+
+      def shutdown
+        @server.close if @server
+      end
+
+      private
+
+      def accept_connection(socket)
+        _, port, host = socket.peeraddr
+        @probe << { connection: "#{host}:#{port}" }
+
+        loop { handle_messages(socket) }
+      end
+
+      def handle_messages(socket)
+        _, port, host = socket.peeraddr
+        response = socket.readpartial(1024)
+        network, command, length, checksum = response.unpack('a4A12Va4')
+        payload = response[24...(24 + length)]
+        @probe << { receiving: command }
+
+        if command == 'version'
+          payload = BN::Protocol::Version.new(addr_recv: ['127.0.0.1', port]) 
+          message = BN::Protocol::Message.new(payload)
+          @probe << { sending: 'version' }
+          socket.write(message.raw)
+        end
+
+        if command == 'verack'
+          verack = BN::Protocol::Messages.verack
+          @probe << { sending: 'verack' }
+          socket.write(verack.raw)
+        end
+
+        if command == 'ping'
+          ping_nonce = BN::Protocol::Ping.parse(payload).nonce.value
+          pong = BN::Protocol::Messages.pong(ping_nonce)
+          @probe << { sending: 'pong' }
+          socket.write(pong.raw)
+        end
+      end
+
+    end
+  end
+end

data/lib/bitcoin_node/protocol.rb

@@ -0,0 +1,196 @@
+# coding: ascii-8bit
+require 'digest'
+
+module BitcoinNode
+  module Protocol
+
+    VERSION = 70001
+
+    MessageParsingError = Class.new(StandardError)
+    IncompleteMessageError = Class.new(MessageParsingError)
+    InvalidChecksumError = Class.new(MessageParsingError)
+
+    def self.digest(content)
+      Digest::SHA256.digest(Digest::SHA256.digest(content))
+    end
+
+    def self.nonce
+      rand(0xffffffffffffffff) 
+    end
+
+    class Header
+      SIZE = 24
+
+      def self.build_from(payload)
+        new(payload)
+      end
+
+      def self.unpack(raw)
+        raw.unpack('a4A12Va4')
+      end
+
+      def initialize(payload)
+        @payload = payload
+      end
+      private_class_method :new 
+
+      def raw
+        @raw ||= begin
+          [BitcoinNode.network,
+           @payload.name.ljust(12, "\x00")[0...12],
+           [@payload.bytesize].pack("V"),
+           BN::Protocol.digest(@payload.raw)[0...4]].join
+        end
+      end
+    end
+
+    class Message
+      attr_reader :command
+
+      def initialize(payload)
+        raise ArgumentError, 'Expected Payload type' unless Payload === payload
+        @payload = payload
+        @command = payload.name
+      end
+
+      def raw
+        @raw ||= begin
+          [Header.build_from(@payload).raw, @payload.raw]
+            .join
+            .force_encoding('binary')
+        end
+      end
+
+      def bytesize
+        raw.bytesize
+      end
+
+      def self.validate(raw_message)
+        network, command, expected_length, checksum = Header.unpack(raw_message)
+        raw_payload = raw_message[Header::SIZE...(Header::SIZE + expected_length)]
+        if (actual = raw_payload.bytesize) < expected_length
+          raise BN::P::IncompleteMessageError.new("Incomplete message (missing #{expected_length - actual} bytes)")
+        elsif checksum != BN::Protocol.digest(raw_payload)[0...4]
+          raise BN::P::InvalidChecksumError.new("Invalid checksum on command #{command}")
+        else
+          [raw_payload, command]
+        end
+      end
+    end
+
+    module Messages
+      module_function
+
+      def ping
+        BN::P::Message.new(BN::Protocol::Ping.new)
+      end
+
+      def pong(nonce)
+        BN::P::Message.new(BN::Protocol::Pong.new(nonce: nonce))
+      end
+
+      def verack
+        BN::P::Message.new(BN::Protocol::Verack.new)
+      end
+
+      def version
+        BN::P::Message.new(BN::Protocol::Version.new)
+      end
+
+      def getaddr
+        BN::P::Message.new(BN::Protocol::Getaddr.new)
+      end
+    end
+
+    class Payload
+      class << self
+        def field(name, type, options = {})
+          define_method(name) do
+            instance_fields[name]
+          end
+
+          define_method("#{name}=") do |value|
+            if type === value
+              instance_fields[name] = value
+            else
+              instance_fields[name] = type.new(*Array(value))
+            end
+          end
+
+          fields[name] = type
+          defaults[name] = options[:default] if options[:default]
+        end
+
+        def defaults
+          @defaults ||= {}
+        end
+
+        def fields
+          @fields ||= {}
+        end
+
+        def field_names
+          fields.keys
+        end
+
+        def parse(payload)
+          result = fields.inject({}) do |memo, (field_name, type)|
+            custom_parse_method = "parse_#{field_name.to_s}"
+            parsed, payload = if respond_to?(custom_parse_method)
+              public_send(custom_parse_method, payload, memo)
+            else
+              type.parse(payload)
+            end
+            memo[field_name] = parsed
+            memo
+          end
+          new(result)
+        end
+      end
+
+      def initialize(attributes = {})
+        attributes.each do |k,v|
+          self.send("#{k}=", v) 
+        end
+        missings = self.class.field_names - attributes.keys
+        missings.each do |k|
+          d = self.class.defaults[k]
+          self.send("#{k}=", Proc === d ? d.call : d)
+        end
+      end
+
+      def raw
+        @raw ||= begin
+          ordered = instance_fields.values_at(*self.class.field_names)
+          ordered.map(&:pack).join
+        end
+      end
+
+      def bytesize
+        raw.bytesize
+      end
+
+      def type
+        self.class.name.split('::').last
+      end
+
+      def name
+        type.downcase 
+      end
+
+      def to_s
+        "#<#{type} #{@instance_fields.inspect}>"
+      end
+      alias_method :inspect, :to_s
+
+      private 
+
+      def instance_fields
+        @instance_fields ||= {}
+      end
+    end
+  end
+end
+
+require 'bitcoin_node/protocol/fields'
+require 'bitcoin_node/protocol/payloads'

data/lib/bitcoin_node/protocol/fields.rb

@@ -0,0 +1,134 @@
+# coding: ascii-8bit
+require 'digest'
+
+module BitcoinNode
+  module Protocol
+
+    class FieldStruct < Struct
+      def to_s
+        type = self.class.name ? self.class.name.split('::').last : '' 
+        "#<struct #{type} #{values.join(', ')}>" 
+      end
+      alias_method :inspect, :to_s
+    end
+
+    AddressField = FieldStruct.new(:host, :port) do
+      def pack
+        sockaddr = Socket.pack_sockaddr_in(port, host)
+        p, h = sockaddr[2...4], sockaddr[4...8]
+        [[1].pack('Q'), "\x00" * 10, "\xFF\xFF", h, p].join
+      end
+
+      def self.parse(address)
+        ip, port, remain = address.unpack("x8x12a4na*")
+        [new(ip.unpack("C*").join('.'), port), remain]
+      end
+    end
+
+    TimedAddressField = FieldStruct.new(:time, :service, :host, :port) do
+      def pack
+      end
+
+      def alive?
+        (Time.now.tv_sec - 10800) <= time
+      end
+
+      def self.parse(address)
+        time, service, ip, port, remain = address.unpack('VQx12a4na*')
+        [new(time, service, ip.unpack("C*").join('.'), port), remain]
+      end
+    end
+
+    AddressesListField = FieldStruct.new(:count) do
+      def self.parse(count, payload)
+        Array.new(count) do
+          addr, payload = TimedAddressField.parse(payload)
+          addr
+        end
+      end
+    end
+
+    VariableIntegerField = FieldStruct.new(:value) do
+      def pack
+        if value < 0xfd; [value].pack("C")
+        elsif value <= 0xffff; [0xfd, value].pack("Cv")
+        elsif value <= 0xffffffff; [0xfe, value].pack("CV")
+        elsif value <= 0xffffffffffffffff; [0xff, value].pack("CQ")
+        else raise "Cannot pack integer #{value}"
+        end
+      end
+
+      def self.parse(raw)
+        case raw.unpack("C")[0]
+        when 0xfd; raw.unpack("xva*")
+        when 0xfe; raw.unpack("xVa*")
+        when 0xff; raw.unpack("xQa*")
+        else; raw.unpack("Ca*")
+        end
+      end
+    end
+
+    InventoryVectorField = FieldStruct.new(:type, :object_hash) do
+
+      TYPES = { ERROR: 0, MSG_TX: 1, MSG_BLOCK: 2, MSG_FILTERED_BLOCK: 3 }
+
+      def pack
+        [TYPES.fetch(type), object_hash].pack('Va32') 
+      end
+
+      def self.parse(raw)
+        type_int, object_hash, remain = raw.unpack('Va32a*')
+        [new(TYPES.invert.fetch(type_int), object_hash), remain]
+      end
+    end
+
+    Integer32Field  = FieldStruct.new(:value) do
+      def pack
+        [value].pack('V')  
+      end
+
+      def self.parse(raw)
+        i, remain = raw.unpack('Va*')
+        [new(i), remain]
+      end
+    end
+
+    StringField = FieldStruct.new(:value) do
+      def pack
+        "#{VariableIntegerField.new(value.bytesize).pack}#{value}"
+      end
+
+      def self.parse(raw)
+        size, payload = VariableIntegerField.parse(raw)
+        if size > 0
+          v, payload = payload.unpack("a#{size}a*")
+          [StringField.new(v), payload]
+        else 
+          [nil, payload]
+        end
+      end
+    end
+
+    Integer64Field = FieldStruct.new(:value) do
+      def pack
+        [value].pack('Q')  
+      end
+
+      def self.parse(raw)
+        i, remain = raw.unpack('Qa*')
+        [new(i), remain]
+      end
+    end
+
+    BooleanField = FieldStruct.new(:value) do
+      def pack
+        (value == true) ? [0xFF].pack("C") : [0x00].pack("C")
+      end
+
+      def self.parse(raw)
+        b, remain = raw.unpack('C')
+        [BooleanField.new(b == 0 ? false : true), remain]
+      end
+    end
+  end
+end

data/lib/bitcoin_node/protocol/payloads.rb

@@ -0,0 +1,60 @@
+module BitcoinNode
+  module Protocol
+    class Version < Payload
+      field :protocol_version, Integer32Field, default: BitcoinNode::Protocol::VERSION
+      field :services, Integer64Field, default: 1
+      field :timestamp, Integer64Field, default: lambda { Time.now.tv_sec }
+      field :addr_recv, AddressField, default: ['127.0.0.1', 3333]
+      field :addr_from, AddressField, default: ['127.0.0.1', 8333]
+      field :nonce, Integer64Field, default: lambda { BN::Protocol.nonce }
+      field :user_agent, StringField, default: "/bitcoin_node:#{BitcoinNode::VERSION}/"
+      field :start_height, Integer32Field, default: 0
+      field :relay, BooleanField, default: true
+
+      def self.parse_relay(payload, fields_parsed)
+        parsed_version = fields_parsed.fetch(:protocol_version).value
+        parsed_version >= BitcoinNode::Protocol::VERSION ? BooleanField.parse(payload) : true
+      end
+
+    end
+
+    class Addr < Payload
+      field :count, VariableIntegerField
+      field :addr_list, AddressesListField
+
+      def self.parse(raw)
+        count, payload = VariableIntegerField.parse(raw) 
+        AddressesListField.parse(count, payload)
+      end
+    end
+
+    class Inv < Payload
+      field :count, VariableIntegerField
+      field :inventory_list, InventoryVectorField
+
+      def self.parse(raw)
+        count, payload = VariableIntegerField.parse(raw)  
+        invs = Array.new(count) do
+          inv, payload = InventoryVectorField.parse(payload)
+          inv
+        end
+        new(count: count, inventory_list: invs)
+      end
+    end
+
+    class Verack < Payload; end
+
+    class Getaddr < Payload; end
+
+    class Ping < Payload
+      field :nonce, Integer64Field, default: lambda { BN::Protocol.nonce }
+    end
+
+    class Pong < Payload
+      field :nonce, Integer64Field
+    end
+
+  end
+end
+
+

data/lib/bitcoin_node/version.rb

@@ -1,3 +1,3 @@
 module BitcoinNode
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/integration/protocol_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'Protocol messages' do
+
+  it 'sends and parses version correctly' do
+    now = Time.now.tv_sec
+
+    version = BN::Protocol::Version.new(
+      timestamp: now, addr_recv: ['127.0.0.0', 8333],
+      addr_from: ['192.168.0.1', 45555],
+      start_height: 127953,
+      relay: false,
+    )
+
+    parsed_version = BN::Protocol::Version.parse(version.raw)
+
+    expect(parsed_version.protocol_version.value).to eql 70001
+    expect(parsed_version.services.value).to eql 1
+    expect(parsed_version.timestamp).to eql(version.timestamp)
+    expect(parsed_version.addr_recv).to eql(version.addr_recv)
+    expect(parsed_version.addr_from).to eql(version.addr_from)
+    expect(parsed_version.nonce).to eql(version.nonce)
+    expect(parsed_version.user_agent.value).to eql("/bitcoin_node:#{BitcoinNode::VERSION}/")
+    expect(parsed_version.start_height).to eql(version.start_height)
+    expect(parsed_version.relay).to eql(version.relay)
+  end
+
+end

data/spec/integration/version_handshake_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe 'Version handshake' do
+
+  let(:port) { 3333 } 
+
+  it 'peers exchanges version properly' do
+    server = BN::P2p::Server.new
+
+    client_probe = BN::P2p::StoreProbe.new
+    client = BN::P2p::Client.connect('localhost', port, client_probe)
+    client.version = 60001
+
+    payload = BN::Protocol::Version.new(addr_recv: ['127.0.0.1', port])
+    message = BN::Protocol::Message.new(payload)
+
+    expect(client.handshaked?).to eql false
+    
+    client.send(message)
+
+    expect(client.handshaked?).to eql true
+    expect(client.version).to eql 60001
+
+    client.send(BN::Protocol::Messages.ping)
+
+    expect(client_probe.store[:sending]).to eql %w(version verack ping)
+    expect(client_probe.store[:receiving]).to eql %w(version verack pong)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require File.expand_path('../lib/bitcoin_node.rb', __dir__)
+
+require 'pry'
+

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: bitcoin_node
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - simcap
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-27 00:00:00.000000000 Z
+date: 2014-11-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid-io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Simple node on the p2p bitcoin network
 email:
 - simcap@fastmail.com
@@ -53,8 +95,19 @@ files:
 - Rakefile
 - bin/bitcoin_node
 - bitcoin_node.gemspec
+- examples/spike.rb
 - lib/bitcoin_node.rb
+- lib/bitcoin_node/p2p.rb
+- lib/bitcoin_node/p2p/client.rb
+- lib/bitcoin_node/p2p/probe.rb
+- lib/bitcoin_node/p2p/server.rb
+- lib/bitcoin_node/protocol.rb
+- lib/bitcoin_node/protocol/fields.rb
+- lib/bitcoin_node/protocol/payloads.rb
 - lib/bitcoin_node/version.rb
+- spec/integration/protocol_spec.rb
+- spec/integration/version_handshake_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -79,4 +132,7 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Simple node on the p2p bitcoin network
-test_files: []
+test_files:
+- spec/integration/protocol_spec.rb
+- spec/integration/version_handshake_spec.rb
+- spec/spec_helper.rb