rtcbx 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 82a2a059f832e80857a14fa93ca724c7231f9fe9
-  data.tar.gz: 5f8346117ed15e6b2d7b2391796104c928c4fe64
+  metadata.gz: 618bb22197148e139a847b21a5c41f049b4b974e
+  data.tar.gz: 8ae41e97883da4fffd728625215b210dcc1115ef
 SHA512:
-  metadata.gz: 5029d67e9ac25a3e8dba7f9f718d53589555f62bf99ca1296ff1296ae2a303fd558b2f0f9a6d87165a78883bc08105656da12225046a2611f289e4f4de96f197
-  data.tar.gz: a288a6bb4d241a13ae5ca4d195b421572f506ff4486e487a4c48e3e870f642e9e900155026bd2df36db579f3a3b8a1e69f9dd531d0df3813c2bd4bd38b29acd3
+  metadata.gz: fdfe5368c8e704e0a99d64892662345a7c2d19bd2c1c7fca35bc5b7f9197d219f28962416f56c0413bb5ed1d3e89aa8b01c35b4b1197cb1a54ddc84e7db5420a
+  data.tar.gz: efcae4d468599dcabd22a0fd166e025f75b6860150c22ea78b1ed5babf4a515a87cbe39ccb4fbd14faa8118024484859f3c7f185f1ef9d53972b4acc8a5cd28e

data/README.md

@@ -129,6 +129,22 @@ ob.last_sequence
 ob.last_pong
 ```
 
+* Aggregates the top N bids in the Orderbook (optional parameter defaults to aggregate all available bids):
+```ruby
+ob.aggregate_bids(10)
+```
+
+* Aggregates the first N asks in the Orderbook (optional parameter defaults to aggregate all available asks):
+```ruby
+ob.aggregate_asks(10)
+```
+
+* Aggregates the top N bids and the first N asks in the Orderbook (optional parameter defaults to aggregate the entire Orderbook):
+```ruby
+# Will perform the aggregation on each call. Avoid abusing this function since it may degrade performance.
+ob.aggregate(10)
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/mikerodrigues/orderbook/fork )

data/lib/rtcbx.rb

@@ -8,20 +8,52 @@ require 'eventmachine'
 class RTCBX
   # seconds in between pinging the connection.
   #
-  PING_INTERVAL = 15
-
-  Thread.abort_on_exception = true
+  PING_INTERVAL = 2
 
+  # The GDAX product being tracked (eg. "BTC-USD")
   attr_reader :product_id
+
+  # Boolean, whether the orderbook goes live on creation or not
+  # If +false+, +#start!+ must be called to initiate tracking.
   attr_reader :start
+
+  # API key used to authenticate to the API
+  # Not required for Orderbook or Candles
   attr_reader :api_key
+
+  # An array of blocks to be run each time a message comes in on the Websocket
   attr_reader :message_callbacks
+
+  # The Websocket object
   attr_reader :websocket
+
+  # The GDAX Client object
+  # You can use this if you need to make API calls
   attr_reader :client
+
+  # The message queue from the Websocket.
+  # The +websocket_thread+ processes this queue
   attr_reader :queue
+
+  # Epoch time indicating the last time we received a pong from GDAX in response
+  # to one of our pings
   attr_reader :last_pong
+
+  # The thread that consumes the websocket data
   attr_reader :websocket_thread
 
+  # Create a new RTCBX object with options and an optional block to be run when
+  # each message is called.
+  #
+  # Generally you won't call this directly. You'll use +RTCBX::Orderbook.new+,
+  # +RTCBX::Trader.new+, or +RTCBX::Candles.new+.
+  #
+  # You can also subclass RTCBX and call this method through +super+, as the
+  # classes mentioned above do.
+  #
+  # RTCBX handles connecting to the Websocket, setting up the client, and
+  # managing the thread that consumes the Websocket feed.
+  #
   def initialize(options = {}, &block)
     @product_id     = options.fetch(:product_id, 'BTC-USD')
     @start          = options.fetch(:start, true)
@@ -44,15 +76,18 @@ class RTCBX
     start! if start
   end
 
+  # Starts the thread to consume the Websocket feed
   def start!
     start_websocket_thread
   end
 
+  # Stops the thread and disconnects from the Websocket
   def stop!
     websocket_thread.kill
     websocket.stop!
   end
 
+  # Stops, then starts the thread that consumes the Websocket feed
   def reset!
     stop!
     start!
@@ -63,6 +98,8 @@ class RTCBX
   attr_reader :api_secret
   attr_reader :api_passphrase
 
+  # Configures the websocket to pass each message to each of the defined message
+  # callbacks
   def setup_websocket_callback
     websocket.message do |message|
       queue.push(message)
@@ -70,6 +107,7 @@ class RTCBX
     end
   end
 
+  # Starts the thread that consumes the websocket
   def start_websocket_thread
     @websocket_thread = Thread.new do
       setup_websocket_callback
@@ -81,14 +119,16 @@ class RTCBX
     end
   end
 
+  # Configures the websocket to periodically ping GDAX and confirm connection
   def setup_ping_timer
     EM.add_periodic_timer(PING_INTERVAL) do
       websocket.ping do
-        last_pong = Time.now
+        @last_pong = Time.now
       end
     end
   end
 
+  # Configures the Websocket object to print any errors to the console
   def setup_error_handler
     EM.error_handler do |e|
       print "Websocket Error: #{e.message} - #{e.backtrace.join("\n")}"

data/lib/rtcbx/candles.rb

@@ -3,25 +3,51 @@ require 'rtcbx/candles/candle'
 class RTCBX
   class Candles < RTCBX
 
+    # A hash of buckets
+    # Each key is an epoch which stores every +match+ message for that minute
+    # (The epoch plus 60 seconds)
+    # Each minute interval is a bucket, which is used to calculate that minute's
+    # +Candle+
     attr_reader :buckets
-    attr_reader :history_queue
-    attr_reader :update_thread
+
+
+    # This thread monitors the websocket object and puts each +match+ object
+    # into the proper bucket. This thread maintains the +buckets+ object.
     attr_reader :bucket_thread
+
+    # The +candle_thread+ consumes the buckets created by the +bucket_thread+ in
+    # +buckets+ and turns them into +Candle+ objects. These are then appended to
+    # the +candles+ array. This functionality could be improved. Ideally you're
+    # consuming this array into a database to keep history in realtime.
     attr_reader :candle_thread
+
+    # The epoch representing the current bucket
     attr_reader :current_bucket
-    attr_reader :start_minute
+
+    # An array of generated candles. You should process these by putting them
+    # into a database and removing them from the array. If you want to help me
+    # abstract this to a pluggable database system, open an issue.
     attr_reader :candles
 
+    # The first full minute that we can collect for. (+Time+ object)
     attr_reader :initial_time
+
+    # The epoch of the first bucket
     attr_reader :first_bucket
-    attr_reader :bucket_lock
 
+    # Mutex to allow our two threads to produce and consume +buckets+
+    attr_reader :buckets_lock
 
+
+    # Create a new +Candles+ object to start and track candles
+    # Pass a block to run a block whenever a candle is created.
+    #
     def initialize(options = {}, &block)
       super(options, &block)
       @buckets_lock = Mutex.new
     end
 
+    # Start tracking candles
     def start!
       super
       #
@@ -30,7 +56,6 @@ class RTCBX
       #
       @initial_time = Time.now
       @first_bucket = initial_time.to_i + (60 - initial_time.sec)
-      @history_queue = Queue.new
 
       start_bucket_thread
       start_candle_thread
@@ -38,6 +63,7 @@ class RTCBX
 
     private
 
+    # Start the thread to create buckets
     def start_bucket_thread
       @bucket_thread = Thread.new do
         @buckets = {}
@@ -56,11 +82,7 @@ class RTCBX
                   @buckets[current_bucket.to_i] = []
                   @buckets[current_bucket.to_i] << message
                 else
-                  begin
-                    @buckets[current_bucket.to_i] << message
-                  rescue
-                    binding.pry
-                  end
+                  @buckets[current_bucket.to_i] << message
                 end
               end
             end
@@ -69,6 +91,7 @@ class RTCBX
       end
     end
 
+    # Start the thread to consume buckets to +Candle+ objects
     def start_candle_thread
       @candle_thread = Thread.new do
         @candles = []

data/lib/rtcbx/candles/candle.rb

@@ -2,8 +2,11 @@ class RTCBX
   class Candles < RTCBX
     class Candle
 
+      # Candle values, this is standard
       attr_reader :time, :low, :high, :open, :close, :volume
 
+      # Create a new +Candle+ from an epoch, and all the messages sent during
+      # the interval of the candle
       def initialize(epoch, matches)
         @time = Time.at(epoch)
         @low = matches.map {|message| BigDecimal.new(message.fetch('price'))}.min
@@ -13,6 +16,7 @@ class RTCBX
         @volume = matches.reduce(BigDecimal(0)) {|sum, message| sum + BigDecimal.new(message.fetch('size'))}
       end
 
+      # Return a +Hash+ representation of the +Candle+
       def to_h
         {
           start:  Time.at(@time),

data/lib/rtcbx/orderbook.rb

@@ -47,11 +47,13 @@ class RTCBX
     #
     def start!
       super
-      sleep 0.3
+      sleep 1
       apply_orderbook_snapshot
       start_update_thread
     end
 
+    # Stop the thread that listens to updates on the websocket
+    #
     def stop!
       super
       update_thread.kill
@@ -79,6 +81,8 @@ class RTCBX
       end
     end
 
+    # Private method to actually start the thread that reads from the que and
+    # updates the Orderbook state
     def start_update_thread
       @update_thread = Thread.new do
         begin
@@ -92,7 +96,5 @@ class RTCBX
         end
       end
     end
-
-    #    apply(message)
   end
 end

data/lib/rtcbx/orderbook/book_analysis.rb

@@ -4,64 +4,126 @@ class RTCBX
     # methods for calculating whatever it is you feel like calculating.
     #
     module BookAnalysis
+      # Number of all current bids
       def bid_count
         @bids.count
       end
 
+      # Number of all current asks
       def ask_count
         @asks.count
       end
 
+      # Number of all current orders
       def count
         { bid: bid_count, ask: ask_count }
       end
 
+      # The total volume of product across all current bids
       def bid_volume
         @bids.map { |x| x.fetch(:size) }.inject(:+)
       end
 
+      # The total volume of product across all current asks
       def ask_volume
         @asks.map { |x| x.fetch(:size) }.inject(:+)
       end
 
+      # The total volume of all product across current asks and bids
       def volume
         { bid: bid_volume, ask: ask_volume }
       end
 
+      # The average bid price across all bids
       def average_bid
         bids = @bids.map { |x| x.fetch(:price) }
         bids.inject(:+) / bids.count
       end
 
+      # The average ask price across all asks
       def average_ask
         asks = @asks.map { |x| x.fetch(:price) }
         asks.inject(:+) / asks.count
       end
 
+      # The average price across all orders
       def average
         { bid: average_bid, ask: average_ask }
       end
 
+      # The price of the best current bid
       def best_bid
         @bids.sort_by { |x| x.fetch(:price) }.last
       end
 
+      # The price of the best current ask
       def best_ask
         @asks.sort_by { |x| x.fetch(:price) }.first
       end
 
+      # The prices of the best current bid and ask
       def best
         { bid: best_bid, ask: best_ask }
       end
 
+      # The price difference between the best current bid and ask
       def spread
         best_ask.fetch(:price) - best_bid.fetch(:price)
       end
 
+      # Aggregates the +top_n+ current bids. Pass `50` and you'll get the same
+      # thing tht GDAX calls a "Level 2 Orderbook"
+      def aggregate_bids(top_n = nil)
+        aggregate = {}
+        @bids.each do |bid|
+          aggregate[bid[:price]] ||= aggregate_base
+          aggregate[bid[:price]][:size] += bid[:size]
+          aggregate[bid[:price]][:num_orders] += 1
+        end
+        top_n ||= aggregate.keys.count
+        aggregate.keys.sort.reverse.first(top_n).map do |price|
+          { price: price,
+            size: aggregate[price][:size],
+            num_orders: aggregate[price][:num_orders]
+          }
+        end
+      end
+
+      # Aggregates the +top_n+ current asks. Pass `50` and you'll get the same
+      # thing tht GDAX calls a "Level 2 Orderbook"
+      def aggregate_asks(top_n = nil)
+        aggregate = {}
+        @asks.each do |ask|
+          aggregate[ask[:price]] ||= aggregate_base
+          aggregate[ask[:price]][:size] += ask[:size]
+          aggregate[ask[:price]][:num_orders] += 1
+        end
+        top_n ||= aggregate.keys.count
+        aggregate.keys.sort.first(top_n).map do |price|
+          { price: price,
+            size: aggregate[price][:size],
+            num_orders: aggregate[price][:num_orders]
+          }
+        end
+      end
+
+      # Aggregates the +top_n+ current asks and bids. Pass `50` and you'll get the same
+      # thing tht GDAX calls a "Level 2 Orderbook"
+      def aggregate(top_n = nil)
+        { bids: aggregate_bids(top_n), asks: aggregate_asks(top_n) }
+      end
+
+      # print a quick summary of the +Orderbook+
       def summarize
         print "# of asks: #{ask_count}\n# of bids: #{bid_count}\nAsk volume: #{ask_volume.to_s('F')}\nBid volume: #{bid_volume.to_s('F')}\n"
         $stdout.flush
       end
+
+      private
+
+      def aggregate_base
+        { size: BigDecimal.new(0), num_orders: 0 }
+      end
     end
   end
 end

data/lib/rtcbx/orderbook/book_methods.rb

@@ -6,6 +6,8 @@ class RTCBX
     # as they are received by the websocket.
     #
     module BookMethods
+
+      # Names of attributes that should be converted to +BigDecimal+
       BIGDECIMAL_KEYS = %w(size old_size new_size remaining_size price)
 
       # Applies a message to an Orderbook object by making relevant changes to
@@ -71,6 +73,14 @@ class RTCBX
       def received(_)
         # The book doesn't change for this message type.
       end
+
+      def margin_profile_update(_)
+        # The book doesn't change for this message type.
+      end
+
+      def activate(_)
+        # The book doesn't change for this message type.
+      end
     end
   end
 end

data/lib/rtcbx/version.rb

@@ -1,5 +1,5 @@
 # Orderbook version number. I try to keep it semantic.
 #
 class RTCBX
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtcbx
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Michael Rodrigues
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-19 00:00:00.000000000 Z
+date: 2017-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler