deribit 1.3.2

data/lib/deribit/api.rb

@@ -0,0 +1,206 @@
+module Deribit
+  class API
+    attr_reader :request
+
+    def initialize(key, secret, test_server: nil)
+      @request = Request.new(key, secret, test_server: test_server)
+    end
+
+    def orderbook(instrument)
+      request.send(path: "/api/v1/public/getorderbook", params: {instrument: instrument})
+    end
+
+    def instruments(expired: false, only_active: true)
+      response = request.send(path: '/api/v1/public/getinstruments', params: {expired: expired})
+      if response.is_a?(Array) and only_active
+        response = response.select {|i| i[:isActive] == true}
+      end
+
+      response
+    end
+
+    def index
+      request.send(path: '/api/v1/public/index', params: {})
+    end
+
+    def test
+      request.send(path: '/api/v1/public/test', params: {})
+    end
+
+    def currencies
+      request.send(path: '/api/v1/public/getcurrencies', params: {})
+    end
+
+    def last_trades(instrument, count: nil, since: nil)
+      params = {instrument: instrument}
+      params[:count] = count if count
+      params[:since] = since if since
+
+      request.send(path: '/api/v1/public/getlasttrades', params: params)
+    end
+
+    def summary(instrument = 'all')
+      params = {}
+      params[:instrument] = instrument if instrument
+
+      request.send(path: '/api/v1/public/getsummary', params: params)
+    end
+
+    def margins(instrument, quantity: 1, price: 0.01)
+      params = {
+          instrument: instrument,
+          quantity:   quantity,
+          price:      price
+      }
+
+      request.send(path: '/api/v1/private/getmargins', params: params)
+    end
+
+    def account(full: false)
+      params = {
+        ext: full
+      }
+
+      request.send(path: '/api/v1/private/account', params: params)
+    end
+
+
+    #  | Name         | Type       | Decription                                                                        |
+    #  |--------------|------------|-----------------------------------------------------------------------------------|
+    #  | `instrument` | `string`   | Required, instrument name                                                         |
+    #  | `quantity`   | `integer`  | Required, quantity, in contracts ($10 per contract for futures, ฿1 — for options) |
+    #  | `price`      | `float`    | Required, USD for futures, BTC for options                                        |
+    #  | `type`       | `string`   | Required, "limit", "market" or for futures only: "stop_limit"                     |
+    #  | `stopPx`     | `string`   | Required, needed for stop_limit order, defines stop price                         |
+    #  | `post_only`  | `boolean`  | Optional, if true then the order will be POST ONLY                                |
+    #  | `label`      | `string`   | Optional, user defined maximum 32-char label for the order                        |
+    #  | `max_show`   | `string`   | Optional, optional parameter, if "0" then the order will be hidden                |
+    #  | `adv`        | `string`   | Optional, can be "implv", "usd", or absent (advanced order type)                  |
+
+    def buy(instrument, quantity, price, type: "limit", stopPx: nil, execInst: "index_price", post_only: nil, reduce_only: nil, label: nil, max_show: nil, adv: nil)
+      params = {
+          instrument: instrument,
+          quantity:   quantity,
+          price:      price
+      }
+
+      %i(type stopPx post_only reduce_only label max_show adv execInst).each do |var|
+        variable = eval(var.to_s)
+        params[var] = variable if variable
+      end
+
+      request.send(path: '/api/v1/private/buy', params: params)
+    end
+
+
+    #  | Name         | Type       | Decription                                                                        |
+    #  |--------------|------------|-----------------------------------------------------------------------------------|
+    #  | `instrument` | `string`   | Required, instrument name                                                         |
+    #  | `quantity`   | `integer`  | Required, quantity, in contracts ($10 per contract for futures, ฿1 — for options) |
+    #  | `price`      | `float`    | Required, USD for futures, BTC for options                                        |
+    #  | `post_only`  | `boolean`  | Optional, if true then the order will be POST ONLY                                |
+    #  | `label`      | `string`   | Optional, user defined maximum 32-char label for the order                        |
+    #  | `max_show`   | `string`   | Optional, optional parameter, if "0" then the order will be hidden                |
+    #  | `adv`        | `string`   | Optional, can be "implv", "usd", or absent (advanced order type)                  |
+    #
+
+    def sell(instrument, quantity, price, type: "limit", stopPx: nil, execInst: "index_price", post_only: nil, reduce_only: nil, label: nil, max_show: nil, adv: nil)
+      params = {
+          instrument: instrument,
+          quantity:   quantity,
+          price:      price
+      }
+
+      %i(type stopPx post_only reduce_only label max_show adv execInst).each do |var|
+        variable = eval(var.to_s)
+        params[var] = variable if variable
+      end
+
+      request.send(path: '/api/v1/private/sell', params: params)
+    end
+
+    #
+    #  | Name         | Type       | Decription                                                                        |
+    #  |--------------|------------|-----------------------------------------------------------------------------------|
+    #  | `order_id`   | `integer`  | Required, ID of the order returned by "sell" or "buy" request                     |
+    #  | `quantity`   | `integer`  | Required, quantity, in contracts ($10 per contract for futures, ฿1 — for options) |
+    #  | `price`      | `float`    | Required, USD for futures, BTC for options                                        |
+    #  | `post_only`  | `boolean`  | Optional, if true then the order will be POST ONLY                                |
+    #  | `adv`        | `string`   | Optional, can be "implv", "usd", or absent (advanced order type)                  |
+
+    def edit(order_id, quantity, price, post_only: nil, adv: nil, stopPx: nil)
+      params = {
+        orderId:    order_id,
+        quantity:   quantity,
+        price:      price
+      }
+
+      %i(post_only adv stopPx).each do |var|
+        variable = eval(var.to_s)
+        params[var] = variable if variable
+      end
+
+      request.send(path: '/api/v1/private/edit', params: params)
+    end
+
+    def cancel(order_id)
+      params = {
+        "orderId": order_id
+      }
+
+      request.send(path: '/api/v1/private/cancel', params: params)
+    end
+
+    def cancel_all(type = "all")
+      params = {
+        "type": type
+      }
+
+      request.send(path: '/api/v1/private/cancelall', params: params)
+    end
+
+    def open_orders(instrument: nil, order_id: nil, type: nil)
+      params = {}
+      params[:instrument] = instrument if instrument
+      params[:orderId]    = order_id if order_id
+      params[:type]       = type if type
+
+      request.send(path: '/api/v1/private/getopenorders', params: params)
+    end
+
+    def positions
+      request.send(path: '/api/v1/private/positions', params: {})
+    end
+
+    def order_state(order_id)
+      params = {
+        "orderId": order_id
+      }
+
+      request.send(path: '/api/v1/private/orderstate', params: params)
+    end
+
+    def order_history(instrument: nil, count: nil, offset: nil)
+      params = {}
+      params[:instrument] = instrument if instrument
+      params[:count] = count if count
+      params[:offset] = offset if offset
+
+      request.send(path: '/api/v1/private/orderhistory', params: params)
+    end
+
+    def trade_history(instrument: nil, count: nil, start_trade_id: nil)
+      params = {}
+
+      %i(count instrument).each do |var|
+        variable = eval(var.to_s)
+        params[var] = variable if variable
+      end
+
+      params[:startTradeId] = start_trade_id if start_trade_id
+
+      request.send(path: '/api/v1/private/tradehistory', params: params)
+    end
+
+  end
+end

data/lib/deribit/error.rb

@@ -0,0 +1,24 @@
+module Deribit
+  class Error < StandardError
+    attr_reader :code, :msg
+
+    def initialize(code: nil, json: {}, message: nil)
+      @code = code || json[:code]
+      @msg = message || json[:msg]
+    end
+
+    def inspect
+      message = ""
+      message += "(#{code}) " unless code.nil?
+      message += "#{msg}" unless msg.nil?
+    end
+
+    def message
+      inspect
+    end
+
+    def to_s
+      inspect
+    end
+  end
+end

data/lib/deribit/immutable_header_key.rb

@@ -0,0 +1,34 @@
+class Deribit::ImmutableHeaderKey
+  attr_reader :key
+
+  def initialize(key)
+    @key = key
+  end
+
+  def downcase
+    self
+  end
+
+  def capitalize
+    self
+  end
+
+  def split(*)
+    [self]
+  end
+
+  def hash
+    key.hash
+  end
+
+  def eql?(other)
+    key.eql? other.key.eql?
+  end
+
+  def to_s
+    def self.to_s
+      key
+    end
+    self
+  end
+end

data/lib/deribit/request.rb

@@ -0,0 +1,91 @@
+require 'base64'
+require 'net/http'
+
+module Deribit
+  class Request
+    attr_accessor :key, :secret, :base_uri
+
+    def initialize(key, secret, test_server: nil)
+      test_server = ENV['DERIBIT_TEST_SERVER']  if test_server == nil
+      @key = key
+      @secret = secret
+      @base_uri = test_server ? URI(TEST_URL) : URI(SERVER_URL)
+    end
+
+    def send(path: DEFAULT_REQUEST_PATH, params: {})
+      uri = base_uri + path
+
+			if path.start_with?(PRIVATE_PATH)
+        request = Net::HTTP::Post.new(uri.path)
+        request.body = URI.encode_www_form(params)
+        request.add_field 'x-deribit-sig', generate_signature(path, params)
+
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+      else
+        uri.query = URI.encode_www_form(params)
+        response = Net::HTTP.get_response(uri)
+      end
+
+      if is_error_response?(response)
+        raise Error.new(code: response.code)
+      else
+        process(response)
+      end
+    end
+
+    def process(response)
+      json = JSON.parse(response.body, symbolize_names: true)
+
+      raise Error.new(message: "Failed for #{key}: " + json[:message])  unless json[:success]
+
+      if json.include?(:result)
+        json[:result]
+      elsif json.include?(:message)
+        json[:message]
+      else
+        "ok"
+      end
+    end
+
+    def generate_signature(path, params = {})
+      timestamp = Time.now.utc.to_i + 1000
+
+      signature_data = {
+        _:       timestamp,
+        _ackey:  key,
+        _acsec:  secret,
+        _action: path
+       }
+
+      signature_data.update(params)
+      sorted_signature_data = signature_data.sort
+
+      converter = ->(data){
+        key = data[0]
+        value = data[1]
+        if value.is_a?(Array)
+          [key.to_s, value.join].join('=')
+        else
+          [key.to_s, value.to_s].join('=')
+        end
+      }
+
+      items = sorted_signature_data.map(&converter)
+      signature_string = items.join('&')
+
+      sha256 = OpenSSL::Digest::SHA256.new
+      sha256_signature = sha256.digest(signature_string.encode('utf-8'))
+
+      base64_signature = Base64.encode64(sha256_signature).encode('utf-8')
+
+      [key, timestamp, base64_signature].join('.').strip
+    end
+
+    def is_error_response?(response)
+      code = response.code.to_i
+      code == 0 || code >= 400
+    end
+  end
+end

data/lib/deribit/version.rb

@@ -0,0 +1,3 @@
+module Deribit
+  VERSION = "1.3.2"
+end

data/lib/deribit/ws/handler.rb

@@ -0,0 +1,56 @@
+module Deribit
+  class WS
+    
+    class Handler
+      attr_accessor :timestamp
+      
+      AVAILABLE_METHODS = [
+        :account, 
+        :getcurrencies, 
+        :subscribe, 
+        :subscribed, 
+        :unsubscribe, 
+        :buy,
+        :sell, 
+        :trade, 
+        :trade_event, 
+        :order_book_event, 
+        :user_order_event, 
+        :user_orders_event, 
+        :announcements, 
+        :index, 
+        :heartbeat,
+        :order,
+        :pong
+      ]
+      SILENT = [:setheartbeat, :subscribed, :heartbeat, :"public API test"]
+
+      def initialize
+        @timestamp = Time.now.to_i
+      end
+
+      def method_missing(m, *json, &block)
+        return false  if SILENT.include?(m.to_sym)
+        
+        puts "Delegating #{m}"
+        if AVAILABLE_METHODS.include?(m.to_sym)
+          notice(json)
+        else
+          super
+        end
+      end
+
+      def notice(json)
+        return json.each { |e| notice(e) }  if json.is_a?(Array)
+
+        msg = json.is_a?(String) ? json : json[:message]
+        puts "Notice: #{msg}"  if msg && !SILENT.include?(msg.to_sym)
+      end
+
+      def handle_error(json, error)
+        puts "Alert! #{error.class} on message: '#{json.try(:fetch, :message)}', #{json.inspect}. Message: #{error.full_message}"
+      end
+    end
+
+  end
+end

data/lib/deribit/ws.rb

@@ -0,0 +1,285 @@
+require 'websocket-client-simple'
+
+module Deribit
+  class WS
+    AVAILABLE_EVENTS = [:order_book, :trade, :my_trade, :user_order, :index, :portfolio, :announcement]
+
+    attr_reader :socket, :response, :ids_stack, :handler, :subscribed_instruments
+
+    def initialize(key, secret, handler: Handler, test_server: nil)
+      test_server  = ENV["DERIBIT_TEST_SERVER"]  if test_server == nil
+      @request     = Request.new(key, secret, test_server: test_server)
+      @socket      = connect(test_server ? WS_TEST_URL : WS_SERVER_URL)
+      @handler     = handler.instance_of?(Class) ? handler.new : handler
+      @ids_stack  = []
+
+      # the structure of subscribed_instruments: {'event_name' => ['instrument1', 'instrument2']]}
+      @subscribed_instruments = {}
+
+      start_handle
+    end
+
+    def add_subscribed_instruments(instruments: , events: )
+      instruments = [instruments] unless instruments.is_a?(Array)
+
+      events.each do |event|
+        _event = event.to_sym
+        @subscribed_instruments[_event] = if sub_instr = @subscribed_instruments[_event]
+                                            (sub_instr + instruments).uniq
+                                          else
+                                            instruments.uniq
+                                          end
+      end
+    end
+
+    def connect(url)
+      puts "Connecting to #{url}"
+      WebSocket::Client::Simple.connect(url)
+    end
+
+    def reconnect!
+      @socket = connect
+      start_handle
+      sleep 3
+      resubscribe!
+    end
+
+    def resubscribe!
+      if subscribed_instruments.any?
+        subscribed_instruments.each do |event, instruments|
+          p "Reconnecting to event: #{event} at instrument: #{instruments}"
+          subscribe(instruments, events: event.to_s)
+        end
+      end
+    end
+
+    def close
+      @socket.close
+    end
+
+    def ping
+      message = {action: "/api/v1/public/ping"}
+      @socket.send(message.to_json)
+    end
+
+    def test
+      message = {action: "/api/v1/public/test"}
+      @socket.send(message.to_json)
+    end
+
+    # events to be reported, possible events:
+    # "order_book" -- order book change
+    # "trade" -- trade notification
+    # "announcements" -- announcements (list of new announcements titles is send)
+    # "user_order" -- change of user orders (openning, cancelling, filling)
+    # "my_trade" -- filtered trade notification, only trades of the
+    # subscribed user are reported with trade direction "buy"/"sell" from the
+    # subscribed user point of view ("I sell ...", "I buy ..."), see below.
+    # Note, for "index" - events are ignored and can be []
+    def subscribe(instruments = ['BTC-PERPETUAL'] , events: ["user_order"], arguments: {})
+      instruments = [instruments]  unless instruments.is_a?(Array)
+      events = [events]  unless events.is_a?(Array)
+
+      raise "Events must include only #{AVAILABLE_EVENTS.join(", ")} actions" if events.map{|e| AVAILABLE_EVENTS.include?(e.to_sym)}.index(false) or events.empty?
+      raise "instruments are required" if instruments.empty?
+
+      arguments = arguments.merge(instrument: instruments, event: events)
+      send(path: '/api/v1/private/subscribe', arguments: arguments)
+    end
+
+    #unsubscribe for all notifications if instruments is empty
+    def unsubscribe(instruments=[])
+      instruments = [instruments] unless instruments.is_a?(Array)
+      send(path: '/api/v1/private/unsubscribe')
+      sleep(0.2)
+      if instruments.any?
+        @subscribed_instruments.each do |event, _instruments|
+          @subscribed_instruments[event] = _instruments - instruments
+          subscribe(@subscribed_instruments[event], events: [event])
+          sleep(0.2)
+        end
+      end
+    end
+
+    #  | Name         | Type       | Decription                                                                        |
+    #  |--------------|------------|-----------------------------------------------------------------------------------|
+    #  | `instrument` | `string`   | Required, instrument name                                                         |
+    #  | `quantity`   | `integer`  | Required, quantity, in contracts ($10 per contract for futures, ฿1 — for options) |
+    #  | `price`      | `float`    | Required, USD for futures, BTC for options                                        |
+    #  | `type`       | `string`   | Required, "limit", "market" or for futures only: "stop_limit"                     |
+    #  | `stopPx`     | `string`   | Required, needed for stop_limit order, defines stop price                         |
+    #  | `post_only`  | `boolean`  | Optional, if true then the order will be POST ONLY                                |
+    #  | `label`      | `string`   | Optional, user defined maximum 32-char label for the order                        |
+    #  | `max_show`   | `string`   | Optional, optional parameter, if "0" then the order will be hidden                |
+    #  | `adv`        | `string`   | Optional, can be "implv", "usd", or absent (advanced order type)                  |
+
+    def buy(instrument, quantity, price, type: "limit", stopPx: nil, execInst: "mark_price", post_only: nil, label: nil, max_show: nil, adv: nil)
+      params = {
+          instrument: instrument,
+          quantity:   quantity
+      }
+      params[:price] = price if price
+
+      %i(type stopPx post_only label max_show adv execInst).each do |var|
+        variable = eval(var.to_s)
+        params[var] = variable if variable
+      end
+
+      send(path: '/api/v1/private/buy', arguments: params)
+    end
+
+    #  | Name         | Type       | Decription                                                                        |
+    #  |--------------|------------|-----------------------------------------------------------------------------------|
+    #  | `instrument` | `string`   | Required, instrument name                                                         |
+    #  | `quantity`   | `integer`  | Required, quantity, in contracts ($10 per contract for futures, ฿1 — for options) |
+    #  | `price`      | `float`    | Required, USD for futures, BTC for options                                        |
+    #  | `post_only`  | `boolean`  | Optional, if true then the order will be POST ONLY                                |
+    #  | `label`      | `string`   | Optional, user defined maximum 32-char label for the order                        |
+    #  | `max_show`   | `string`   | Optional, optional parameter, if "0" then the order will be hidden                |
+    #  | `adv`        | `string`   | Optional, can be "implv", "usd", or absent (advanced order type)                  |
+    #
+
+    def sell(instrument, quantity, price, type: "limit", stopPx: nil, execInst: "mark_price", post_only: nil, label: nil, max_show: nil, adv: nil)
+      params = {
+          instrument: instrument,
+          quantity:   quantity
+      }
+      params[:price] = price if price
+
+      %i(type stopPx post_only label max_show adv execInst).each do |var|
+        variable = eval(var.to_s)
+        params[var] = variable if variable
+      end
+
+      send(path: '/api/v1/private/sell', arguments: params)
+    end
+
+    def account
+      send(path: '/api/v1/private/account')
+    end
+
+    def instruments(expired: false)
+      send(path: '/api/v1/public/getinstruments', arguments: {expired: expired})
+    end
+
+    def currencies
+      send(path: '/api/v1/public/getcurrencies')
+    end
+
+    def summary(instrument = 'BTC-PERPETUAL')
+      send(path: '/api/v1/public/getsummary', arguments: { instrument: instrument })
+    end
+
+    def openorders(instrument: "BTC-PERPETUAL", order_id: nil, type: nil)
+      params = {}
+      params[:instrument] = instrument if instrument
+      params[:orderId]    = order_id if order_id
+      params[:type]       = type if type
+
+      send(path: '/api/v1/private/getopenorders', arguments: params)
+    end
+
+    def cancel(order_id)
+      params = {
+        "orderId": order_id
+      }
+
+      send(path: '/api/v1/private/cancel', arguments: params)
+    end
+
+    def cancel_all(type = "all")
+      params = {
+        "type": type
+      }
+
+      send(path: '/api/v1/private/cancelall', arguments: params)
+    end
+
+    def set_heartbeat(interval = "60")
+      params = {
+        "interval": interval
+      }
+
+      send(path: '/api/v1/public/setheartbeat', arguments: params)
+    end
+
+    def handle_notifications(notifications)
+      return if notifications.empty?
+      notification, *tail = notifications
+      handler.send(notification[:message], notification[:result])
+
+      handle_notifications(tail)
+    end
+
+    private
+
+    def start_handle
+      instance = self
+      @socket.on :message do |msg|
+        # puts "msg = #{msg.inspect}"
+        begin
+          if msg.type == :text
+            json = JSON.parse(msg.data, symbolize_names: true)
+            puts "Subscribed!" if json[:message] == "subscribed"
+
+            if json[:message] == "test_request"
+              # puts "Got test request: #{json.inspect}" # DEBUG
+              instance.test
+            elsif json[:id] and stack_id = instance.ids_stack.find{|i| i[json[:id]]}
+              method  = stack_id[json[:id]][0]
+              #pass the method to handler
+              params = instance.ids_stack.delete(stack_id)
+
+              #save subscribed_instruments for resubscribe in unsubscribe action
+              if method == 'subscribe'
+                params = params[json[:id]][1][:arguments]
+                instance.add_subscribed_instruments(instruments: params[:instrument], events: params[:event])
+              end
+
+              instance.handler.send(method, json)
+            elsif json[:notifications]
+              instance.handle_notifications(json[:notifications])
+            else
+              instance.handler.send(:notice, json)
+            end
+
+            instance.handler.timestamp = Time.now.to_i
+          elsif msg.type == :close
+            puts "trying to reconnect = got close event, msg: #{msg.inspect}"
+            instance.reconnect!
+          end
+        rescue StandardError => e 
+          instance.handler.handle_error(json, e)
+        end
+      end
+
+      @socket.on :error do |e|
+        puts e
+      end
+    end
+
+    def send(path: , arguments: {})
+      return unless path
+      params = {action: path, arguments: arguments}
+      sig = @request.generate_signature(path, arguments)
+      params[:sig] = sig
+      params[:id] = Time.now.to_i
+
+      action = path[/\/api.*\/([^\/]+)$/, 1]
+      put_id(params[:id], [action, params])
+
+      p params
+      @socket.send(params.to_json)
+    end
+
+
+    def put_id(id, action)
+      @ids_stack << {id => action}
+    end
+
+    def pop_id(id)
+      @ids_stack.delete(id)
+    end
+  end
+
+end