gekko 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6a24e973cb010d9b1f8067d9bea9cb30a1c3bc4
-  data.tar.gz: f120b77ebf50b3a973a886dc4b8561249c395169
+  metadata.gz: 4a6c74d9cd4db77db4b045b3cbef970af72ad93b
+  data.tar.gz: 2cc81dd40f090dbe5b1e512a8e973daff6e0310c
 SHA512:
-  metadata.gz: 0d14739c0de58e63f2ce1039018911f3689a59c833f1871e136ef6076730337493d709b2efe9e43ff4883228ae795a76a8a66c7c89a3d68dad0c0229132e29ea
-  data.tar.gz: 396fb3177eb9c2fbcdf289fe36ee1cb6abb1658aa4db4eda8b7f3bcbf5e08ec60ee799f487cc3793f8f57f740f06b147d50680208438b4007f8bbd399d672cef
+  metadata.gz: 1fed15e7db3bc630c741eed42d7e191ce1390894abc9dbfed90e4bcb5161dac6d680ba8bd8aab3198854574abd35e94676d89237ae28685c64565bf4dda43c51
+  data.tar.gz: b66b9ad7f75edea38f2391572a2dbb3d6172008ca96338f4799745d6f22c959112a16406e40c8b31235f7c16c7454358e91d2204b9e320cce633465b628af6ca

data/lib/gekko/book.rb

@@ -24,73 +24,110 @@ module Gekko
       self.base_precision = opts[:base_precision] || 8
       self.multiplier     = BigDecimal(10 ** base_precision)
       self.received       = opts[:received] || {}
+
+      @triggered_stops = []
     end
 
     #
     # Receives an order and executes it
     #
     # @param order [Order] The order to execute
+    # @param execute_triggered_stops [Boolean] Whether to also execute the STOP orders triggered 
+    #   by the current received order executions
     #
-    def receive_order(order)
-      raise 'Order must be a Gekko::LimitOrder or a Gekko::MarketOrder' unless [LimitOrder, MarketOrder].include?(order.class)
+    def receive_order(order, stop_order_execution = false)
+      raise "Order must be a Gekko::LimitOrder or a Gekko::MarketOrder."      unless [LimitOrder, MarketOrder].include?(order.class)
+      raise "Can't receive a new STOP before a first trade has taken place."  if order.stop? && ticker[:last].nil?
+
+      # We need to initialize the stop_price for trailing stops if necessary
+      if order.stop? && !order.stop_price
+        if order.stop_percent
+          order.stop_price = ticker[:last] + (ticker[:last] * order.stop_percent / Gekko::Order::TRL_STOP_PCT_MULTIPLIER * (order.bid? ? 1 : -1)).round
+        elsif order.stop_offset
+          order.stop_price = ticker[:last] + order.stop_offset * (order.bid? ? 1 : -1)
+        end
+      end
+
+      # The side of the received order
+      current_side = (order.ask? ? asks : bids)
 
       # The side from which we'll pop orders
       opposite_side = order.bid? ? asks : bids
 
-      if received.has_key?(order.id.to_s)
+      if received.has_key?(order.id.to_s) && !stop_order_execution
         tape << order.message(:reject, reason: :duplicate_id)
 
-      elsif order.expired?
-        tape << order.message(:reject, reason: :expired)
+      else
+        self.received[order.id.to_s] = order
 
-      elsif order.post_only && order.crosses?(opposite_side.first)
-        tape << order.message(:reject, reason: :would_execute)
+        if order.expired?
+          tape << order.message(:reject, reason: :expired)
 
-      else
-        old_ticker = ticker
+        elsif order.stop? && !order.should_trigger?(tape.last_trade_price)
+          current_side.stops << order # Add the STOP to the list of currently active STOPs
 
-        self.received[order.id.to_s] = order
-        tape << order.message(:received)
+        elsif order.post_only && order.crosses?(opposite_side.first)
+          tape << order.message(:reject, reason: :would_execute)
 
-        order_side    = order.bid? ? bids : asks
-        next_match    = opposite_side.first
-        prev_match_id = nil
+        else
+          old_ticker = ticker
+          tape << order.message(:received)
+
+          order_side    = order.bid? ? bids : asks
+          next_match    = opposite_side.first
+          prev_match_id = nil
 
-        while !order.done? && order.crosses?(next_match)
-          # If we match against the same order twice in a row, something went seriously
-          # wrong, we'd rather noisily die at this point.
-          raise 'Infinite matching loop detected !!' if (prev_match_id == next_match.id)
-          prev_match_id = next_match.id
+          while !order.done? && order.crosses?(next_match)
+            # If we match against the same order twice in a row, something went seriously
+            # wrong, we'd rather noisily die at this point.
+            raise 'Infinite matching loop detected !!' if (prev_match_id == next_match.id)
+            prev_match_id = next_match.id
 
-          if next_match.expired?
-            tape << opposite_side.shift.message(:done, reason: :expired)
-            next_match = opposite_side.first
+            if next_match.expired?
+              tape << opposite_side.shift.message(:done, reason: :expired)
+              next_match = opposite_side.first
 
-          elsif order.uid == next_match.uid
-            # Same user/account associated to order, we cancel the next match
-            tape << opposite_side.shift.message(:done, reason: :canceled)
-            next_match = opposite_side.first
+            elsif order.uid == next_match.uid
+              # Same user/account associated to order, we cancel the next match
+              tape << opposite_side.shift.message(:done, reason: :canceled)
+              next_match = opposite_side.first
+
+            else
+              execute_trade(next_match, order)
+
+              if next_match.filled?
+                tape << opposite_side.shift.message(:done, reason: :filled)
+                next_match = opposite_side.first
+              end
+            end
+          end
 
+          if order.filled?
+            tape << order.message(:done, reason: :filled)
+          elsif order.fill_or_kill?
+            tape << order.message(:done, reason: :killed)
           else
-            execute_trade(next_match, order)
+            order_side.insert_order(order)
+            tape << order.message(:open)
+          end
 
-            if next_match.filled?
-              tape << opposite_side.shift.message(:done, reason: :filled)
-              next_match = opposite_side.first
+          current_side.stops.each do |stop|
+            if stop.should_trigger?(tape.last_trade_price)
+              @triggered_stops << current_side.stops.delete(stop)
             end
           end
-        end
 
-        if order.filled?
-          tape << order.message(:done, reason: :filled)
-        elsif order.fill_or_kill?
-          tape << order.message(:done, reason: :killed)
-        else
-          order_side.insert_order(order)
-          tape << order.message(:open)
-        end
+          opposite_side.stops.each { |s| s.update_trailing_stop(tape.last_trade_price) }
+
+          if !stop_order_execution
+            # We only want to execute triggered stops at the top level as to correctly order them
+            while t = @triggered_stops.shift
+              receive_order(t, true)
+            end
 
-        tick! unless (ticker == old_ticker)
+            tick! unless (ticker == old_ticker)
+          end
+        end
       end
     end
 
@@ -154,10 +191,14 @@ module Gekko
       prev_ask = ask
 
       order = received[order_id.to_s]
-      dels = order.bid? ? bids.delete(order) : asks.delete(order)
-      dels && tape << order.message(:done, reason: :canceled)
 
-      tick! if (prev_bid != bid) || (prev_ask != ask)
+      if order
+        s = order.bid? ? bids : asks
+        dels = s.delete(order) || s.stops.delete(order)
+        dels && tape << order.message(:done, reason: :canceled)
+
+        tick! if (prev_bid != bid) || (prev_ask != ask)
+      end
     end
 
     #
@@ -168,12 +209,7 @@ module Gekko
       prev_ask = ask
 
       [bids, asks].each do |bs|
-        bs.reject! do |order| 
-          if order.expired?
-            tape << order.message(:done, reason: :expired)
-            true
-          end
-        end
+        bs.remove_expired! { |tape_msg| tape << tape_msg }
       end
 
       tick! if (prev_bid != bid) || (prev_ask != ask)
@@ -256,8 +292,8 @@ module Gekko
     #
     def self.from_hash(hsh)
       book = Book.new(hsh[:pair], {
-        bids: BookSide.new(:bid, orders: hsh[:bids].map { |o| symbolize_keys(o) }),
-        asks: BookSide.new(:ask, orders: hsh[:asks].map { |o| symbolize_keys(o) })
+        bids: BookSide.from_hash(:bid, hsh[:bids]),
+        asks: BookSide.from_hash(:ask, hsh[:asks])
       })
 
       [:bids, :asks].each { |s| book.send(s).each { |ord| book.received[ord.id.to_s] = ord } }

data/lib/gekko/book_side.rb

@@ -5,16 +5,23 @@ module Gekko
   #
   class BookSide < Array
 
-    attr_accessor :side
+    include Serialization
+
+    attr_accessor :side, :stops
 
     def initialize(side, opts = {})
+      super()
+
       raise "Incorrect side <#{side}>" unless [:bid, :ask].include?(side)
-      @side = side
+      @side   = side
+      @stops  = []
 
       if opts[:orders]
         opts[:orders].each_with_index { |obj, idx| self[idx] = Order.from_hash(obj) }
         sort!
       end
+
+      opts[:stops].each_with_index { |obj, idx| stops[idx] = Order.from_hash(obj) } if opts[:stops]
     end
 
     #
@@ -23,7 +30,21 @@ module Gekko
     # @return [Hash] The serializable representation
     #
     def to_hash
-      map(&:to_hash)
+      { orders: map(&:to_hash), stops: stops.map(&:to_hash) }
+    end
+
+    #
+    # Returns a +Gekko::BookSide+ instance from a hash
+    #
+    # @param side [Symbol] Either +:bid+ or +:ask+
+    # @param h [Hash] The hash representation of a book side
+    # @return [Gekko::BookSide] The represented book side
+    #
+    def self.from_hash(side, h)
+      h = symbolize_keys(h)
+      bs = new(side, orders: h[:orders].map { |o| symbolize_keys(o) })
+      bs.stops = h[:stops].map { |o| Gekko::Order.from_hash(symbolize_keys(o)) }
+      bs
     end
 
     #
@@ -64,5 +85,19 @@ module Gekko
       side == :bid
     end
 
+    #
+    # Removes the expired book orders and STOPs from this side
+    #
+    def remove_expired!
+      [self, stops].each do |orders|
+        orders.reject! do |order|
+          if order.expired?
+            yield(order.message(:done, reason: :expired))
+            true
+          end
+        end
+      end
+    end
+
   end
 end

data/lib/gekko/order.rb

@@ -9,24 +9,40 @@ module Gekko
 
     include Serialization
 
-    attr_accessor :id, :uid, :side, :size, :remaining, :price, :expiration, :created_at, :post_only
+    #
+    # Multiplier applied to the trailing STOP percentage to be able to pass it around as integer
+    #
+    TRL_STOP_PCT_MULTIPLIER = BigDecimal(10000)
+
+    attr_accessor :id, :uid, :side, :size, :remaining, :price, :expiration, :created_at, :post_only,
+      :stop_price, :stop_percent, :stop_offset
 
     def initialize(side, id, uid, size, opts = {})
-      @id         = id
-      @uid        = uid
-      @side       = side && side.to_sym
-      @size       = size
-      @remaining  = @size
-      @expiration = opts[:expiration]
-      @created_at = Time.now.to_f
-      @post_only  = opts[:post_only]
-
-      raise 'Orders must have an UUID'                    unless @id && @id.is_a?(UUID)
-      raise 'Orders must have a user ID'                  unless @uid && @uid.is_a?(UUID)
-      raise 'Side must be either :bid or :ask'            unless [:bid, :ask].include?(@side)
-      raise 'Size must be a positive integer'             if (@size && (!@size.is_a?(Fixnum) || @size <= 0))
-      raise 'Expiration must be omitted or be an integer' unless (@expiration.nil? || (@expiration.is_a?(Fixnum) && @expiration > 0))
-      raise 'The order creation timestamp can''t be nil'  if !@created_at
+      @id           = id
+      @uid          = uid
+      @side         = side && side.to_sym
+      @size         = size
+      @remaining    = @size
+      @expiration   = opts[:expiration]
+      @created_at   = Time.now.to_f
+      @post_only    = opts[:post_only]
+      @stop_price   = opts[:stop_price]
+      @stop_percent = opts[:stop_percent]
+      @stop_offset  = opts[:stop_offset]
+
+      raise 'Orders must have an UUID'                        unless @id && @id.is_a?(UUID)
+      raise 'Orders must have a user ID'                      unless @uid && @uid.is_a?(UUID)
+      raise 'Side must be either :bid or :ask'                unless [:bid, :ask].include?(@side)
+      raise 'Size must be a positive integer'                 if (@size && (!@size.is_a?(Fixnum) || @size <= 0))
+      raise 'Stop price must be a positive integer'           if (@stop_price && (!@stop_price.is_a?(Fixnum) || @stop_price <= 0))
+      raise 'Trailing percentage must be a positive integer'  if (@stop_percent && (!@stop_percent.is_a?(Fixnum) || @stop_percent <= 0 || @stop_percent >= TRL_STOP_PCT_MULTIPLIER))
+      raise 'Trailing offset must be a positive integer'      if (@stop_offset && (!@stop_offset.is_a?(Fixnum) || @stop_offset <= 0))
+      raise 'Expiration must be omitted or be an integer'     unless (@expiration.nil? || (@expiration.is_a?(Fixnum) && @expiration > 0))
+      raise 'The order creation timestamp can''t be nil'      if !@created_at
+
+      if (((@stop_price && 1 )|| 0) + ((@stop_percent && 1 ) || 0) + ((@stop_offset && 1) || 0)) > 1
+        raise 'Stop orders must specify exactly one of either stop price, trailing percentage, or trailing offset.'
+      end
     end
 
     #
@@ -45,6 +61,28 @@ module Gekko
       end
     end
 
+    #
+    # Returns +true+ if the order is a STOP order, +false+ otherwise
+    #
+    # @return [Boolean] Whether this order is a STOP
+    #
+    def stop?
+      !!(stop_price || stop_percent || stop_offset)
+    end
+
+    #
+    # Returns +true+ if the given price should trigger this order's execution.
+    #
+    # @param p [Fixnum] The price to which we want to compare the STOP price
+    # @return [Boolean] Whether this order should trigger
+    #
+    def should_trigger?(p)
+      p || raise("Provided price can't be nil")
+      stop? || raise("Called Order#should_trigger? on a non-stop order")
+
+      (bid? && (stop_price <= p)) || (ask? && (stop_price >= p))
+    end
+
     #
     # Creates a message in order to print it ont the tape
     #
@@ -126,6 +164,16 @@ module Gekko
         hsh[:remaining_quote_margin] = remaining_quote_margin
       end
 
+      if stop?
+        hsh.merge!({
+          stop: {
+            price:   stop_price,
+            offset:  stop_offset,
+            percent: stop_percent
+          }
+        })
+      end
+
       hsh
     end
 
@@ -136,7 +184,34 @@ module Gekko
     # @return [Gekko::Order] A trade order
     #
     def self.from_hash(hsh)
-      (hsh[:price] ? LimitOrder : MarketOrder).from_hash(hsh)
+      order = (hsh[:price] ? LimitOrder : MarketOrder).from_hash(hsh)
+
+      if hsh[:stop]
+        hsh[:stop] = symbolize_keys(hsh[:stop])
+        order.stop_price    = hsh[:stop][:price]
+        order.stop_offset   = hsh[:stop][:offset]
+        order.stop_percent  = hsh[:stop][:percent]
+      end
+
+      order
+    end
+
+    #
+    # Updates the stop price according to either the +stop_percent+ or
+    # or the +stop_offset+ attributes
+    #
+    # @param p [Fixnum] The price used to update the +stop_price+
+    #
+    def update_trailing_stop(p)
+      sign = bid? ? 1 : -1
+
+      if stop_percent
+        new_price = p + (p * stop_percent * sign / TRL_STOP_PCT_MULTIPLIER).round
+        self.stop_price = new_price if (bid? && (new_price < stop_price)) || (ask? && (new_price > stop_price))
+      elsif stop_offset
+        new_price = p + stop_offset * sign
+        self.stop_price = new_price if (bid? && (new_price < stop_price)) || (ask? && (new_price > stop_price))
+      end
     end
 
   end

data/lib/gekko/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gekko
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - David FRANCOIS
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-17 00:00:00.000000000 Z
+date: 2016-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuidtools