gekko 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c22a43388f516eb29f65b1c7439018b7d0b62b2d
-  data.tar.gz: f5b5b3011d40a9dfa97b3573b166af0c772023cd
+  metadata.gz: 95df87c9c162b780e408b2761062ff2230542f22
+  data.tar.gz: 4468b3d3bc4f53aa31316321ce9908f63c899704
 SHA512:
-  metadata.gz: 2c486804dc2109f896f2d98cb160b099e73dbe157c465f21bf61f7cfa56f36794ceac3886677ebd802102bc90d0c5e0059aeaa354c590047b152a39746dd6bac
-  data.tar.gz: 5c303f98396a43ba09640630f8bb8f649b064819f05a5b76c4fc1e75f7bdc0d2e58411bb8fc186d18b96006e5b1aa916750ce60d9915fb5e9fb64eae5baceed3
+  metadata.gz: 5d66764b99cc061c8fc8f6c9750fbb64f478c4d817b04cefbff70a718589225eb5fc3df0fbd935b9f06b36fa5618817eda6c685d0a764e959377b71d7795fc95
+  data.tar.gz: dffa0324039b7c5aa10772087af12e763a5de8f25e1f9ff7ff906ecd31002d005b723e0b736a690c71a62c60f734226bc252b052c5b89444c4f84cce5cbaeacf

data/README.md

@@ -7,3 +7,10 @@ Gekko is intended to become a high-performance in-memory trade order matching en
 ## What Gekko is not
 Gekko is not intended to maintain an accounting database, it just matches trade orders associated to accounts, and returns the necessary data for an accounting system to record the trades (usually against some sort of RDBMS).
 
+## Left to do
+The following items are left to do and will need to be implemented before gekko is considered production-ready.
+
+ - Persistence and failure recovery
+ - Add and enforce minimum and maximum order sizes
+ - Correctly handle order expiration
+

data/lib/gekko/book.rb

@@ -9,25 +9,15 @@ module Gekko
   #
   class Book
 
-    # TODO: Add order size limits
-    # TODO: Add order expiration
-    # TODO: Test for rounding issues
-
-    # The default minimum price increment accepted for placed orders
-    DEFAULT_TICK_SIZE = 1000
-
-    attr_accessor :pair, :bids, :asks, :tape, :tick_size, :received, :base_precision
+    attr_accessor :pair, :bids, :asks, :tape, :received, :base_precision
 
     def initialize(pair, opts = {})
       self.pair           = pair
       self.bids           = BookSide.new(:bid)
       self.asks           = BookSide.new(:ask)
       self.tape           = Tape.new(opts[:logger])
-      self.base_precision = 8
+      self.base_precision = opts[:base_precision] || 8
       self.received       = {}
-
-      self.tick_size  = opts[:tick_size] || DEFAULT_TICK_SIZE
-      raise "Tick size must be a positive integer if provided" if tick_size && (!tick_size.is_a?(Fixnum) || tick_size <= 0)
     end
 
     #
@@ -39,12 +29,12 @@ module Gekko
 
       raise 'Order must be a Gekko::LimitOrder or a Gekko::MarketOrder' unless [LimitOrder, MarketOrder].include?(order.class)
 
-      raise Gekko::TickSizeMismatch unless (order.is_a?(MarketOrder) || (order.price % tick_size).zero?)
-
       if received.has_key?(order.id.to_s)
         tape << order.message(:reject, reason: "Duplicate ID <#{order.id.to_s}>")
 
       else
+        old_ticker = ticker
+
         self.received[order.id.to_s] = order
         tape << order.message(:received)
 
@@ -70,7 +60,6 @@ module Gekko
             end
           end
 
-
           tape << {
             type:             :execution,
             price:            trade_price,
@@ -99,9 +88,27 @@ module Gekko
           order_side.insert_order(order)
           tape << order.message(:open)
         end
+
+        tick! unless (ticker == old_ticker)
       end
     end
 
+    #
+    # Cancels an order given an ID
+    #
+    # @param order_id [String] The ID of the order to cancel
+    #
+    def cancel(order_id)
+      prev_bid = bid
+      prev_ask = ask
+
+      order = received[order_id.to_s]
+      dels = order.bid? ? bids.delete(order) : asks.delete(order)
+      dels && tape << order.message(:done, reason: :cancelled)
+
+      tick! if (prev_bid != bid) || (prev_ask != ask)
+    end
+
     #
     # Returns the current best ask price or +nil+ if there
     # are currently no asks
@@ -126,6 +133,13 @@ module Gekko
       ask && bid && (ask - bid)
     end
 
+    #
+    # Emits a ticker on the tape
+    #
+    def tick!
+      tape << { type: :ticker }.merge(ticker)
+    end
+
     #
     # Returns the current ticker
     #
@@ -137,6 +151,8 @@ module Gekko
         last:       tape.last_trade_price,
         bid:        bid,
         ask:        ask,
+        high_24h:   tape.high_24h,
+        low_24h:    tape.low_24h,
         spread:     spread,
         volume_24h: v24h,
         vwap_24h:   (v24h > 0) && (tape.quote_volume_24h * (10 ** base_precision)/ v24h)

data/lib/gekko/errors.rb

@@ -1,6 +1,3 @@
 module Gekko
 
-  # Raised when the price isn't a multiple of the tick size
-  class TickSizeMismatch < RuntimeError; end
-
 end

data/lib/gekko/tape.rb

@@ -24,17 +24,11 @@ module Gekko
       message[:sequence] = length
       logger && logger.info(message)
 
-      if message[:type] == :execution
-        # Keep last price up to date
-        @last_trade_price = message[:price]
+      super(message)
 
-        # Keep 24h volume up to date
-        @volume_24h       += message[:base_size]
-        @quote_volume_24h += message[:quote_size]
-        move_24h_cursor!
+      if message[:type] == :execution
+        update_ticker(message)
       end
-
-      super(message)
     end
 
     #
@@ -60,6 +54,47 @@ module Gekko
       @volume_24h
     end
 
+    #
+    # Returns the highest trade price that occurred during the last 24h
+    #
+    # @return [Fixnum] The last 24h high
+    #
+    def high_24h
+      move_24h_cursor!
+      @high_24h
+    end
+
+    #
+    # Returns the lowest trade price that occurred during the last 24h
+    #
+    # @return [Fixnum] The last 24h low
+    #
+    def low_24h
+      move_24h_cursor!
+      @low_24h
+    end
+
+    #
+    # Recalculates the previous 24h high and low
+    #
+    def recalc_high_low_24h!
+      @high_24h = nil
+      @low_24h  = nil
+
+      # Work backwards from current position until the cursor points to an event
+      # that's older than 24h
+      tmp_cursor  = (length - 1)
+      evt         = self[tmp_cursor]
+
+      while (evt && (evt[:time] >= time_24h_ago)) do
+        @high_24h = ((@high_24h.nil? || (evt[:price] > @high_24h)) && evt[:price]) || @high_24h
+        @low_24h  = ((@low_24h.nil?  || (evt[:price] < @low_24h))  && evt[:price]) || @low_24h
+
+        tmp_cursor -= 1
+        evt = (tmp_cursor >= 0) && self[tmp_cursor]
+      end
+    end
+
     #
     # Returns the traded amount of quote currency in the last 24h
     #
@@ -70,22 +105,67 @@ module Gekko
       @quote_volume_24h
     end
 
+    #
+    # Updates the ticker after an execution has been recorded
+    #
+    def update_ticker(execution)
+      price = execution[:price]
+
+      # Keep last price up to date
+      @last_trade_price = price
+
+      # Keep 24h volume up to date
+      @volume_24h       += execution[:base_size]
+      @quote_volume_24h += execution[:quote_size]
+
+      # Record new high/lows
+      if @high_24h.nil? || (@high_24h < price)
+        @high_24h = price
+      end
+
+      if @low_24h.nil? || (price < @low_24h)
+        @low_24h = price
+      end
+
+      move_24h_cursor!
+    end
+
+    #
+    # Returns the float timestamp of 24h ago
+    #
+    # @return [Float] Yesterday's cut-off timestamp
+    #
+    def time_24h_ago
+      Time.now.to_f - 24*3600
+    end
+
     #
     # Moves the cursor pointing to the first trade that happened during
-    # the last 24h and updates the volume along the way
+    # the last 24h. Every execution getting out of the 24h rolling window is
+    # passed to Tape#fall_out_of_24h_window  
     #
     def move_24h_cursor!
-      time_24h_ago = Time.now.to_f - 24*3600
-
       while(self[@cursor_24h] && ((self[@cursor_24h][:type] != :execution) || (self[@cursor_24h][:time] < time_24h_ago)))
-        if self[@cursor_24h] && self[@cursor_24h][:type] == :execution
-          @volume_24h       -= self[@cursor_24h][:base_size]
-          @quote_volume_24h -= self[@cursor_24h][:quote_size]
+        if self[@cursor_24h][:type] == :execution
+          fall_out_of_24h_window(self[@cursor_24h])
         end
 
         @cursor_24h += 1
       end
     end
+
+    #
+    # Updates the low, high, and volumes when an execution falls out of the rolling
+    # previous 24h window
+    # 
+    def fall_out_of_24h_window(execution)
+      @volume_24h       -= execution[:base_size]
+      @quote_volume_24h -= execution[:quote_size]
+
+      if [@high_24h, @low_24h].include?(execution[:price])
+        recalc_high_low_24h!
+      end
+    end
   end
 end
 

data/lib/gekko/version.rb

@@ -1,6 +1,6 @@
 module Gekko
   
   # The Gekko version string
-  VERSION = '0.1.0'
+  VERSION = '0.2.1'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gekko
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - David FRANCOIS
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2015-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuidtools