gekko 0.5.2 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 486109d7779f0dad9f4295d86f7c4e04a190aaea
-  data.tar.gz: 2b7855c833b96c746d9877145d5df44078cd306e
+  metadata.gz: 981305466dff1fb589c97f96fb4be28ca1b4e2ce
+  data.tar.gz: 123b650f9b0774614710cec547990609786f1dc2
 SHA512:
-  metadata.gz: 2374b2b91e9873fc91d61395dac62face02d86644949b82a1fe775745836e78f58695a8b2ab2ead6cdc3eb60a5b093de5ace2fef59fc49d930a9e3b11d234d73
-  data.tar.gz: 2bdbb61d58115c18f5cdb0907f6f4f2a6fb6bae2ccc7275950c1a1a7faab4495fd7850dd20ea72ae8eff10f3781837057ee2ca11d688b2d76d99a9ab91cc6bad
+  metadata.gz: bf435111f321867abc6d3dc3028e54a8da6791c2dc6b2bd216c45279f5bcc750be54332765d411d11a2486db735e67767d4fb5b0c1291893e8468d5eb9f5843b
+  data.tar.gz: 33210a4936da0df11359588b54773570a9f12f0002e85ae516931efdc0f763adb236074a7abea5869ac45eb34bd3f38d5763ef89461860af088b2965c23ba6ab

data/README.md

@@ -10,7 +10,6 @@ Gekko is not intended to maintain an accounting database, it just matches trade
 ## 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.rb

@@ -3,6 +3,7 @@ require 'uuidtools'
 # UUID shortcut
 UUID = UUIDTools::UUID
 
+require 'gekko/serialization'
 require 'gekko/order'
 require 'gekko/limit_order'
 require 'gekko/market_order'

data/lib/gekko/book.rb

@@ -1,10 +1,6 @@
-require 'oj'
-Oj.default_options = { mode: :compat }
-
 require 'gekko/book_side'
 require 'gekko/tape'
 require 'gekko/errors'
-require 'gekko/symbolize_keys'
 
 module Gekko
 
@@ -13,9 +9,9 @@ module Gekko
   #
   class Book
 
-    extend SymbolizeKeys
+    include Serialization
 
-    attr_accessor :pair, :bids, :asks, :tape, :received, :base_precision
+    attr_accessor :pair, :bids, :asks, :tape, :received, :base_precision, :multiplier
 
     def initialize(pair, opts = {})
       self.pair           = opts[:pair] || pair
@@ -23,16 +19,16 @@ module Gekko
       self.asks           = opts[:asks] || BookSide.new(:ask)
       self.tape           = opts[:tape] || Tape.new({ logger: opts[:logger] })
       self.base_precision = opts[:base_precision] || 8
+      self.multiplier     = BigDecimal(10 ** base_precision)
       self.received       = opts[:received] || {}
     end
 
     #
-    # Receives an order and executes it 
+    # Receives an order and executes it
     #
     # @param order [Order] The order to execute
     #
     def receive_order(order)
-
       raise 'Order must be a Gekko::LimitOrder or a Gekko::MarketOrder' unless [LimitOrder, MarketOrder].include?(order.class)
 
       if received.has_key?(order.id.to_s)
@@ -57,20 +53,30 @@ module Gekko
             next_match = opposite_side.first
 
           else
-            trade_price   = next_match.price
-            base_size   = [next_match.remaining, order.remaining].min
+            trade_price     = next_match.price
+            max_quote_size  = nil
+
+            if order.is_a?(MarketOrder)
+              max_size_possible_with_quote_margin = order.remaining_quote_margin && (order.remaining_quote_margin * multiplier / trade_price).round
+            end
+
+            base_size = [
+              next_match.remaining,
+              order.remaining,
+              max_size_possible_with_quote_margin
+            ].compact.min
 
             if order.is_a?(LimitOrder)
-              quote_size = (base_size * trade_price) / (10 ** base_precision)
+              quote_size = (base_size * trade_price) / multiplier
 
             elsif order.is_a?(MarketOrder)
-              if order.ask? || (order.remaining_quote_margin > ((trade_price * base_size) / (10 ** base_precision)))
-                quote_size = ((trade_price * base_size) / (10 ** base_precision))
-                order.remaining_quote_margin -= quote_size if order.bid?
+              if order.ask? || (order.remaining_quote_margin > (trade_price * base_size / multiplier))
+                quote_size = (trade_price * base_size / multiplier).round
+                order.remaining_quote_margin -= quote_size if order.quote_margin
+
               elsif order.bid?
                 quote_size = order.remaining_quote_margin
-                base_size = (order.remaining_quote_margin * (10 ** base_precision)) / trade_price
-                order.remaining_quote_margin -= quote_size
+                order.remaining_quote_margin = 0
               end
             end
 
@@ -84,7 +90,7 @@ module Gekko
               tick:             order.bid? ? :up : :down
             }
 
-            order.remaining       -= base_size
+            order.remaining       -= base_size if order.remaining
             next_match.remaining  -= base_size
 
             if next_match.filled?
@@ -118,7 +124,7 @@ module Gekko
 
       order = received[order_id.to_s]
       dels = order.bid? ? bids.delete(order) : asks.delete(order)
-      dels && tape << order.message(:done, reason: :cancelled)
+      dels && tape << order.message(:done, reason: :canceled)
 
       tick! if (prev_bid != bid) || (prev_ask != ask)
     end
@@ -188,17 +194,19 @@ module Gekko
         low_24h:    tape.low_24h,
         spread:     spread,
         volume_24h: v24h,
-        vwap_24h:   (v24h > 0) && (tape.quote_volume_24h * (10 ** base_precision)/ v24h)
+
+        # We'd like to return +nil+, not +false+ when we don't have any volume
+        vwap_24h:   ((v24h > 0) && (tape.quote_volume_24h * multiplier / v24h).to_i) || nil
       }
     end
 
     #
-    # Dumps the book to a JSON string
+    # Returns a +Hash+ representation of this +Book+ instance
     #
-    # @return [String] The serialized order book
+    # @return [Hash] The serializable representation
     #
-    def dump
-      Oj.dump({
+    def to_hash
+      {
         time:             Time.now.to_f,
         bids:             bids.to_hash,
         asks:             asks.to_hash,
@@ -206,23 +214,24 @@ module Gekko
         tape:             tape.to_hash,
         received:         received,
         base_precision:   base_precision
-      })
+      }
     end
 
     #
-    # Loads the book from a JSON string
+    # Loads the book from a hash
     #
-    # @param serialized [String] A serialized book
-    # @return [Gekko::Book] The deserialized book instance
+    # @param hsh [Hash] A Book hash
+    # @return [Gekko::Book] The loaded book instance
     #
-    def self.load(serialized)
-      hsh  = symbolize_keys(Oj.load(serialized))
+    def self.from_hash(hsh)
+      book = Book.new(hsh[:pair], {
+        bids: BookSide.new(:bid, orders: hsh[:bids].map { |o| symbolize_keys(o) }.sort { |a, b| b[:price] <=> a[:price] }),
+        asks: BookSide.new(:ask, orders: hsh[:asks].map { |o| symbolize_keys(o) }.sort { |a, b| a[:price] <=> b[:price] }),
+      })
 
-      hsh[:tape] = Tape.new(symbolize_keys(hsh[:tape]))
-      hsh[:bids] = BookSide.new(:bid, orders: hsh[:bids].map { |o| symbolize_keys(o) })
-      hsh[:asks] = BookSide.new(:ask, orders: hsh[:asks].map { |o| symbolize_keys(o) })
+      book.tape = Tape.from_hash(symbolize_keys(hsh[:tape])) if hsh[:tape]
 
-      Book.new(hsh[:pair], hsh)
+      book
     end
 
   end

data/lib/gekko/book_side.rb

@@ -10,6 +10,7 @@ module Gekko
     attr_accessor :side
 
     def initialize(side, opts = {})
+      # TODO "WARNING: Sort orders ?"
       raise "Incorrect side <#{side}>" unless [:bid, :ask].include?(side)
       @side = side
 

data/lib/gekko/limit_order.rb

@@ -10,6 +10,7 @@ module Gekko
     def initialize(side, id, size, price, expiration = nil)
       super(side, id, size, expiration)
       @price = price
+
       raise 'Price must be a positive integer' if @price.nil? || (!@price.is_a?(Fixnum) || (@price <= 0))
     end
 

data/lib/gekko/market_order.rb

@@ -8,21 +8,28 @@ module Gekko
 
     attr_accessor :quote_margin, :remaining_quote_margin
 
-    def initialize(side, id, size, quote_margin)
-      super(side, id, size)
+    def initialize(side, id, size, quote_margin, expiration = nil)
+      super(side, id, size, expiration)
 
       @quote_margin           = quote_margin
       @remaining_quote_margin = @quote_margin
 
-      raise 'Quote currency margin must be provided for a market bid'     if quote_margin.nil? && bid?
-      raise 'Quote currency margin can not be specified for a market ask' if quote_margin && ask?
+      if bid?
+        quote_margin.nil? && 
+          raise('Quote currency margin must be provided for a market bid')
+      elsif ask?
+        (quote_margin.nil? ^ size.nil?) ||
+          raise('Quote currency margin and size can not be both specified for a market ask')
+      end
     end
 
     #
     # Returns +true+ if the order is filled
     #
     def filled?
-      remaining.zero?
+      #binding.pry
+      (!size.nil? && remaining.zero?) ||
+        (!quote_margin.nil? && remaining_quote_margin.zero?)
     end
 
     #
@@ -30,7 +37,8 @@ module Gekko
     # executing further due to quote currency margin constraints
     #
     def done?
-      filled? || (bid? && remaining_quote_margin.zero?)
+      filled? ||
+        (bid? && remaining_quote_margin.zero?)
     end
 
   end

data/lib/gekko/order.rb

@@ -1,5 +1,3 @@
-require 'gekko/serialization'
-
 module Gekko
 
   #
@@ -9,7 +7,7 @@ module Gekko
   #
   class Order
 
-    include Gekko::Serialization
+    include Serialization
 
     attr_accessor :id, :side, :size, :remaining, :price, :expiration, :created_at
 
@@ -54,7 +52,7 @@ module Gekko
     # @return [Hash] The message we'll print on the tape
     #
     def message(type, extra_attrs = {})
-      {
+      hsh = {
         type:       type,
         order_id:   id.to_s,
         side:       side,
@@ -63,6 +61,14 @@ module Gekko
         price:      price,
         expiration: expiration
       }.merge(extra_attrs)
+
+      if is_a?(Gekko::MarketOrder)
+        hsh.delete(:price)
+        hsh[:quote_margin] = quote_margin
+        hsh[:remaining_quote_margin] = remaining_quote_margin
+      end
+
+      hsh
     end
 
     #
@@ -94,5 +100,47 @@ module Gekko
       expiration && (expiration <= Time.now.to_i)
     end
 
+    #
+    # Returns a +Hash+ representation of this +Order+ instance
+    #
+    # @return [Hash] The serializable representation
+    #
+    def to_hash
+      hsh = {
+        id:           id.to_s,
+        side:         side,
+        size:         size,
+        price:        price,
+        remaining:    remaining,
+        expiration:   expiration,
+        created_at:   created_at
+      }
+
+      if is_a?(Gekko::MarketOrder)
+        hsh.delete(:price)
+        hsh[:quote_margin] = quote_margin
+        hsh[:remaining_quote_margin] = remaining_quote_margin
+      end
+
+      hsh
+    end
+
+    #
+    # Initializes a +Gekko::Order+ subclass from a +Hash+ instance
+    #
+    # @param hsh [Hash] The order data
+    # @return [Gekko::Order] A trade order
+    #
+    def self.from_hash(hsh)
+      order = if hsh[:price]
+                LimitOrder.new(hsh[:side], UUID.parse(hsh[:id]), hsh[:size], hsh[:price], hsh[:expiration])
+              else
+                MarketOrder.new(hsh[:side], UUID.parse(hsh[:id]), hsh[:size], hsh[:quote_margin], hsh[:expiration])
+              end
+
+      order.created_at = hsh[:created_at] if hsh[:created_at]
+      order
+    end
+
   end
 end

data/lib/gekko/serialization.rb

@@ -1,9 +1,12 @@
 require 'gekko/symbolize_keys'
 
+require 'oj'
+Oj.default_options = { mode: :compat }
+
 module Gekko
 
   #
-  # Handles JSON serialization and deserialization of trade orders
+  # Handles JSON serialization and deserialization
   #
   module Serialization
 
@@ -30,23 +33,6 @@ module Gekko
       def deserialize(serialized)
         from_hash(symbolize_keys(Oj.load(serialized)))
       end
-
-      #
-      # Initializes a +Gekko::Order+ subclass from a +Hash+ instance
-      #
-      # @param hsh [Hash] The order data
-      # @return [Gekko::Order] A trade order
-      #
-      def from_hash(hsh)
-        order = if hsh[:price]
-                  LimitOrder.new(hsh[:side], UUID.parse(hsh[:id]), hsh[:size], hsh[:price], hsh[:expiration])
-                else
-                  MarketOrder.new(hsh[:side], UUID.parse(hsh[:id]), hsh[:size], hsh[:quote_margin])
-                end
-
-        order.created_at = hsh[:created_at] if hsh[:created_at]
-        order
-      end
     end
 
     #
@@ -59,31 +45,6 @@ module Gekko
       Oj.dump(to_hash)
     end
 
-    #
-    # Returns a +Hash+ representation of this +Order+ instance
-    #
-    # @return [Hash] The serializable representation
-    #
-    def to_hash
-      hsh = {
-        id:           id.to_s,
-        side:         side,
-        size:         size,
-        price:        price,
-        remaining:    remaining,
-        expiration:   expiration,
-        created_at:   created_at
-      }
-
-      if is_a?(Gekko::MarketOrder)
-        hsh.delete(:price)
-        hsh[:quote_margin] = quote_margin
-        hsh[:remaining_quote_margin] = remaining_quote_margin
-      end
-
-      hsh
-    end
-
   end
 end
 

data/lib/gekko/tape.rb

@@ -5,46 +5,23 @@ module Gekko
   #
   class Tape < Array
 
+    include Serialization
+
     # The number of seconds in 24h
     SECONDS_IN_24H = 60 * 60 * 24
 
     attr_accessor :logger, :last_trade_price
-    attr_reader :volume_24h, :high_24h, :low_24h
+    attr_reader :volume_24h, :high_24h, :low_24h, :open_24h, :var_24h
 
     def initialize(opts = {})
-      @logger           = opts[:logger]
-
-      @cursor           = opts[:cursor]           || 0
-      @cursor_24h       = opts[:cursor_24h]       || 0
-      @volume_24h       = opts[:volume_24h]       || 0
-      @quote_volume_24h = opts[:quote_volume_24h] || 0
+      @logger = opts[:logger]
 
-      @low_24h          = opts[:low_24h]
-      @high_24h         = opts[:high_24h]
-      @last_trade_price = opts[:last_trade_price]
-
-      opts[:events] && opts[:events].each_with_index { |obj, idx| self[idx] = obj }
+      @cursor           = 0
+      @cursor_24h       = 0
+      @volume_24h       = 0
+      @quote_volume_24h = 0
     end
 
-    #
-    # Returns this +Tape+ object as a +Hash+ for the purpose of serialization
-    #
-    # @return [Hash] The JSON-friendly +Hash+ representation
-    #
-    def to_hash
-      {
-        cursor:             @cursor,
-        cursor_24h:         @cursor_24h,
-        volume_24h:         @volume_24h,
-        high_24h:           @high_24h,
-        low_24h:            @low_24h,
-        quote_volume_24h:   @quote_volume_24h,
-        last_trade_price:   @last_trade_price,
-        events:             self
-      }
-    end
-
-
     #
     # Prints a message on the tape
     #
@@ -107,7 +84,6 @@ module Gekko
     # @return [Fixnum] The last 24h quote currency volume
     #
     def quote_volume_24h
-      #move_24h_cursor!
       @quote_volume_24h
     end
 
@@ -148,7 +124,7 @@ module Gekko
     #
     # Moves the cursor pointing to the first trade that happened during
     # the last 24h. Every execution getting out of the 24h rolling window is
-    # passed to Tape#fall_out_of_24h_window  
+    # passed to Tape#fall_out_of_24h_window
     #
     def move_24h_cursor!
       while(self[@cursor_24h] && (self[@cursor_24h][:time] < time_24h_ago))
@@ -163,15 +139,55 @@ module Gekko
     #
     # 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]
+      @open_24h         = execution[:price]
+      @var_24h          = @last_trade_price && ((@last_trade_price - @open_24h) / @open_24h.to_f)
 
       if [@high_24h, @low_24h].include?(execution[:price])
         recalc_high_low_24h!
       end
     end
+
+    #
+    # Returns this +Tape+ object as a +Hash+ for the purpose of serialization
+    #
+    # @return [Hash] The JSON-friendly +Hash+ representation
+    #
+    def to_hash
+      {
+        cursor:             @cursor,
+        cursor_24h:         @cursor_24h,
+        volume_24h:         @volume_24h,
+        high_24h:           @high_24h,
+        low_24h:            @low_24h,
+        open_24h:           @open_24h,
+        var_24h:            @var_24h,
+        quote_volume_24h:   @quote_volume_24h,
+        last_trade_price:   @last_trade_price,
+        events:             self
+      }
+    end
+
+    #
+    # Loads a +Tape+ object from a hash
+    #
+    # @param hsh [Hash] The +Tape+ data
+    #
+    def self.from_hash(hsh)
+      tape = Tape.new
+
+      hsh[:events].each do |evt|
+        e = symbolize_keys(evt)
+        e[:type] = e[:type].to_sym
+        tape << e
+      end
+
+      tape
+    end
+
   end
 end
 

data/lib/gekko/version.rb

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

metadata

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