bitmex-api 0.0.3 → 0.1.0

data/TODOs.org

@@ -5,7 +5,8 @@
    CLOSED: [2019-01-14] SCHEDULED: <2019-01-14 Fri>
 ** DONE auth for REST-API endpoints
    CLOSED: [2019-01-16 Wed] SCHEDULED: <2019-01-15 Tue> DEADLINE: <2019-01-16 Wed>
-** TODO auth for private subscription topics
+** DONE auth for private subscription topics
+   CLOSED: [2019-02-01 Fri] SCHEDULED: <2019-02-01 Fri>
 ** move from rspec to minitest
 ** configure autorun
 ** hearbeat, ping/pong
@@ -18,8 +19,15 @@
 ** DONE orderbook, order resource
    CLOSED: [2019-01-29 Tue] SCHEDULED: <2019-01-29 Tue>
 ** refactoring: use class methods when working with multiple entities
-** issue: {"error":{"message":"Signature not valid.","name":"HTTPError"}} in user#executions
+** bug: {"error":{"message":"Signature not valid.","name":"HTTPError"}} in user#executions
 ** DONE liquidation, leaderboard, insurance, instrument, funding, execution, chat, announcement
    CLOSED: [2019-01-30 Wed] SCHEDULED: <2019-01-30 Wed>
 ** DONE refactoring: extract websocket common logic
    CLOSED: [2019-01-31 Thu] SCHEDULED: <2019-01-31 Thu>
+** DONE refactoring: extract REST API implemenration
+   CLOSED: [2019-02-08 Fri] SCHEDULED: <2019-02-08 Fri>
+** DONE add idiomatic websocket support for all resources
+   CLOSED: [2019-02-10 Sun 16:57] SCHEDULED: <2019-02-10 Sun>
+** refactoring: make user model to extend base class as well
+** DONE Release 1.0: API endpoints, examples in README
+   CLOSED: [2019-02-11 Mon] SCHEDULED: <2019-02-11 Mon>

data/bin/chat.rb

@@ -6,6 +6,6 @@ require 'bitmex'
 puts 'Listening to chat message from English channel...'
 
 client = Bitmex::Client.new
-client.listen chat: 1 do |message|
+client.websocket.listen chat: 1 do |message|
   puts "#{message.user}: #{message.message}"
 end

data/bitmex.gemspec

@@ -1,7 +1,6 @@
-
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "bitmex/version"
+require 'bitmex/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'bitmex-api'
@@ -9,45 +8,45 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Iulian Costan']
   spec.email         = ['iulian.costan@gmail.com']
 
-  spec.summary       = %q{Ruby library for BitMEX API}
-  spec.description   = %q{Ruby library for BitMEX API}
+  spec.summary       = 'Fully-featured, idiomatic Ruby library for BitMEX API'
+  spec.description   = 'Fully-featured, idiomatic Ruby library for BitMEX API'
   spec.homepage      = 'https://github.com/icostan/bitmex-api-ruby'
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
-    spec.metadata["allowed_push_host"] = 'https://rubygems.org'
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
 
-    spec.metadata["homepage_uri"] = spec.homepage
-    spec.metadata["source_code_uri"] = 'https://github.com/icostan/bitmex-api-ruby.git'
-    spec.metadata["changelog_uri"] = 'https://github.com/icostan/bitmex-api-ruby/blob/master/CHANGELOG.md'
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/icostan/bitmex-api-ruby.git'
+    spec.metadata['changelog_uri'] = 'https://github.com/icostan/bitmex-api-ruby/blob/master/CHANGELOG.md'
   else
-    raise "RubyGems 2.0 or newer is required to protect against " \
-      "public gem pushes."
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
   end
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency 'httparty'
-  spec.add_dependency 'hashie'
-  spec.add_dependency 'faye-websocket'
   spec.add_dependency 'eventmachine'
+  spec.add_dependency 'faye-websocket'
+  spec.add_dependency 'hashie'
+  spec.add_dependency 'httparty'
 
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'bump'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'dotenv'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'pry-doc'
-  spec.add_development_dependency 'simplecov'
-  spec.add_development_dependency 'dotenv'
-  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'reek'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
 end

data/lib/bitmex.rb

@@ -16,10 +16,14 @@ require 'bitmex/instrument'
 require 'bitmex/user'
 require 'bitmex/apikey'
 require 'bitmex/websocket'
+require 'bitmex/rest'
 
 # Bitmex module
 module Bitmex
+  # Bitmex standard error
   class Error < StandardError; end
+  # 403 Forbidden
+  class ForbiddenError < Error; end
 
   TESTNET_HOST = 'testnet.bitmex.com'.freeze
   MAINNET_HOST = 'www.bitmex.com'.freeze
@@ -31,4 +35,15 @@ module Bitmex
     data = verb + path + expires.to_s + params
     OpenSSL::HMAC.hexdigest 'SHA256', api_secret, data
   end
+
+  def self.headers(api_key, api_secret, verb, path, body)
+    return {} unless api_key || api_secret
+
+    expires = Time.now.utc.to_i + 60
+    {
+      'api-expires' => expires.to_s,
+      'api-key' => api_key,
+      'api-signature' => Bitmex.signature(api_secret, verb, path, expires, body)
+    }
+  end
 end

data/lib/bitmex/apikey.rb

@@ -5,17 +5,17 @@ module Bitmex
     attr_reader :api_key
 
     # Create new Apikey
-    # @param client [Bitmex::Client] the rest client
+    # @param rest [Bitmex::Rest] the rest client
     # @param api_key [String] public apikey
-    def initialize(client, api_key = nil)
-      super client
+    def initialize(rest, api_key = nil)
+      super rest
       @api_key = api_key
     end
 
     # Get your API Keys
     # @return [Array] the api keys
     def all
-      client.get apikey_path, auth: true do |response|
+      rest.get apikey_path, auth: true do |response|
         response_handler response
       end
     end
@@ -23,7 +23,7 @@ module Bitmex
     # NOT SUPPORTED
     # #return 403 Access Denied
     def enable
-      client.post apikey_path(:enable) do |response|
+      rest.post apikey_path(:enable) do |response|
         response_handler response
       end
     end
@@ -31,7 +31,7 @@ module Bitmex
     # NOT SUPPORTED
     # @return 403 Access Denied
     def disable
-      client.post apikey_path(:disable) do |response|
+      rest.post apikey_path(:disable) do |response|
         response_handler response
       end
     end

data/lib/bitmex/base.rb

@@ -2,25 +2,31 @@ module Bitmex
   # Base class for all Bitmex models
   # @author Iulian Costan
   class Base
-    attr_reader :client
+    attr_reader :rest, :websocket
 
-    # @param client [Bitmex::Client] the client object
-    def initialize(client)
-      @client = client
+    # @param rest [Bitmex::Rest] the rest implementation
+    # @param websocket [Bitmex::Websocket] the websocket implementation
+    def initialize(rest, websocket = nil)
+      @rest = rest
+      @websocket = websocket
     end
 
     protected
 
+    def check_binsize(bin_size)
+      raise ArgumentError, 'invalid bin_size' unless %w[1m 5m 1h 1d].include? bin_size.to_s
+    end
+
     def response_handler(response)
-      client.response_handler response
+      rest.response_handler response
     end
 
-    def requires!(arg, args)
+    def requires(arg, args)
       raise ArgumentError, "argument '#{arg}' is required" unless args.include? arg
     end
 
     def base_path(resource, action)
-      client.base_path resource, action
+      rest.base_path resource, action
     end
   end
 end

data/lib/bitmex/chat.rb

@@ -4,48 +4,46 @@ module Bitmex
   class Chat < Base
     # Get chat messages
     # @example Get last 10 messages for channel 1
-    #   messages = client.chat.messages channel_id: 1, count: 10, reverse: true
+    #   messages = client.chat.messages channelID: 1, count: 10, reverse: true
     # @param options [Hash] options to filter by
     # @option options [Integer] :count (100) number of results to fetch.
     # @option options [Integer] :start starting ID for results
     # @option options [Boolean] :reverse If true, will sort results newest first
     # @option options [Integer] :channelID Channel id. GET /chat/channels for ids. Leave blank for all.
     # @return [Array] the messages
-    def messages(options = { count: 100, reverse: true })
-      params = {
-        count: options[:count], start: options[:start],
-        reverse: options[:reverse], channelID: options[:channel_id]
-      }
-      client.get chat_path, params: params do |response|
-        response_handler response
+    # @yield [Hash] the message
+    def messages(options = { count: 100, reverse: true }, &ablock)
+      if block_given?
+        websocket.listen chat: options[:channelID], &ablock
+      else
+        rest.get chat_path, params: options
       end
     end
 
     # Get available channels
     # @return [Array] the available channels
     def channels
-      client.get chat_path(:channels) do |response|
-        response_handler response
-      end
+      rest.get chat_path(:channels)
     end
 
     # Get connected users
     # @return [Bitmex::Mash] an array with browser users in the first position and API users (bots) in the second position.
-    def stats
-      client.get chat_path(:connected) do |response|
-        response_handler response
+    # @yield [Hash] the stats
+    def stats(&ablock)
+      if block_given?
+        websocket.listen connected: nil, &ablock
+      else
+        rest.get chat_path(:connected)
       end
     end
 
     # Send a chat message
     # @param message [String] the message to send
     # @param options [Hash] filter options
-    # @option options [Integer] :channel_id (1) channel to post to
-    def send(message, options = { channel_id: 1 })
-      params = { message: message, channelID: options[:channel_id] }
-      client.post chat_path, params: params do |response|
-        response_handler response
-      end
+    # @option options [Integer] :channelID (1) channel to post to
+    def send(message, options = { channelID: 1 })
+      params = { message: message, channelID: options[:channelID] }
+      rest.post chat_path, params: params
     end
 
     private

data/lib/bitmex/client.rb

@@ -1,15 +1,6 @@
-require 'json'
-require 'faye/websocket'
-require 'eventmachine'
-require 'logger'
-
 module Bitmex
+  # Main client interface for Bitmex API.
   class Client
-    include HTTParty
-    # logger ::Logger.new(STDOUT), :debug, :curl
-
-    AUTHORIZATIONS = %w(apikey execution position globalnotification order leaderboard quote user userevent)
-
     attr_reader :host, :api_key, :api_secret
 
     # Create new client instance
@@ -24,45 +15,53 @@ module Bitmex
 
     # Get site announcements
     # @return [Array] the public announcements
-    def announcements
-      get base_path(:announcement) do |response|
-        response_handler response
+    def announcements(&ablock)
+      if block_given?
+        websocket.listen announcement: nil, &ablock
+      else
+        rest.get :announcement
       end
     end
 
     # Persistent API Keys for Developers
     # @return [Bitmex::Apikey] the apikey instance
     def apikey(api_key = nil)
-      Bitmex::Apikey.new self, api_key
+      Bitmex::Apikey.new rest, api_key
     end
 
     # Trollbox Data
     # @return [Bitmex::Chat] the chat instance
     def chat
-      Bitmex::Chat.new self
+      Bitmex::Chat.new rest, websocket
     end
 
     # Tradeable Contracts, Indices, and History
     # @return [Bitmex::Instrument] the instrument model
     def instrument
-      Bitmex::Instrument.new self
+      Bitmex::Instrument.new rest, websocket
     end
 
     # Get funding history
     # @!macro bitmex.filters
     # @return [Array] the history
-    def funding(filters = {})
-      get base_path(:funding), params: filters do |response|
-        response_handler response
+    # @yield [Hash] the funding data
+    def funding(filters = {}, &ablock)
+      if block_given?
+        websocket.listen funding: nil, &ablock
+      else
+        rest.get :funding, params: filters
       end
     end
 
     # Get insurance fund history
     # @!macro bitmex.filters
     # @return [Array] the history
-    def insurance(filters = {})
-      get base_path(:insurance), params: filters do |response|
-        response_handler response
+    # @yield [Hash] the insurance data
+    def insurance(filters = {}, &ablock)
+      if block_given?
+        websocket.listen insurance: nil, &ablock
+      else
+        rest.get :insurance, params: filters
       end
     end
 
@@ -70,17 +69,24 @@ module Bitmex
     # @param ranking [notional ROE] the ranking type
     # @return [Array] current leaders
     def leaderboard(ranking = 'notional')
-      get base_path(:leaderboard), params: { method: ranking } do |response|
-        response_handler response
-      end
+      rest.get :leaderboard, params: { method: ranking }
     end
 
     # Get liquidation orders
+    # @example Get liquidations orders
+    #   liquidations = client.liquidations symbol: 'XBTUSD'
+    # @example Listen for liquidation orders
+    #   client.liquidations symbol: 'XBTUSD' do |liquidation|
+    #     puts liquidation.inspect
+    #   end
     # @!macro bitmex.filters
     # @return [Array] the liquidations
-    def liquidations(filters = {})
-      get base_path(:liquidation), params: filters do |response|
-        response_handler response
+    # @yield [Hash] the liquidation data
+    def liquidations(filters = {}, &ablock)
+      if block_given?
+        websocket.listen liquidation: filters[:symbol], &ablock
+      else
+        rest.get :liquidation, params: filters
       end
     end
 
@@ -88,7 +94,7 @@ module Bitmex
     # @return [Bitmex::Order] the order model
     def orders
       # TODO: use class method
-      Bitmex::Order.new(self)
+      Bitmex::Order.new rest, websocket
     end
 
     # Get an order by id
@@ -98,17 +104,27 @@ module Bitmex
     def order(orderID: nil, clOrdID: nil)
       raise ArgumentError, 'either orderID or clOrdID is required' if orderID.nil? && clOrdID.nil?
 
-      Bitmex::Order.new(self, orderID, clOrdID)
+      Bitmex::Order.new rest, websocket, orderID, clOrdID
     end
 
-    # Get current orderbook in vertical format
+    # Get current Level 2 orderbook in vertical format
+    # @example Get the first level
+    #   orderbook = client.orderbook 'XBTUSD', depth: 1
+    # @example Listen to orderbook changes
+    #   client.orderbook 'XBTUSD' do |orderbook|
+    #     puts orderbook.inspect
+    #   end
     # @param symbol [String] instrument symbol, send a series (e.g. XBT) to get data for the nearest contract in that series
     # @param depth [Integer] orderbook depth per side. send 0 for full depth.
     # @return [Array] the orderbook
-    def orderbook(symbol, depth: 25)
-      params = { symbol: symbol, depth: depth }
-      get base_path('orderbook/L2'), params: params do |response|
-        response_handler response
+    # @yield [Hash] the orderbook data
+    def orderbook(symbol, depth: 25, &ablock)
+      raise ArgumentError, 'symbol is required' unless symbol
+
+      if block_given?
+        websocket.listen orderBookL2: symbol, &ablock
+      else
+        rest.get 'orderbook/L2', params: { symbol: symbol, depth: depth }
       end
     end
 
@@ -116,209 +132,64 @@ module Bitmex
     # @return [Array] the list of positions
     def positions
       # TODO: use class method
-      Bitmex::Position.new(self).all
+      Bitmex::Position.new rest, websocket
     end
 
     # Get an open position
     # @param symbol [String] symbol of position
     # @return [Bitmex::Position] open position
     def position(symbol)
-      Bitmex::Position.new(self, symbol)
+      Bitmex::Position.new rest, websocket, symbol
     end
 
     # Best Bid/Offer Snapshots & Historical Bins
     # @return [Bitmex::Quote] the quote model
     def quotes
       # TODO: use class method
-      Bitmex::Quote.new self
+      Bitmex::Quote.new rest, websocket
     end
 
     # Get model schemata for data objects returned by this AP
     # @return [Hash] the schema
     def schema
-      get base_path(:schema) do |response|
-        response_handler response
-      end
+      rest.get :schema
     end
 
     # Get settlement history
     # @return [Array] the settlement history
-    def settlement
-      get base_path(:settlement) do |response|
-        response_handler response
+    # @yield [Hash] the settlement data
+    def settlements(&ablock)
+      if block_given?
+        websocket.listen settlement: nil, &ablock
+      else
+        rest.get :settlement
       end
     end
 
     # Exchange statistics
     # @return [Bitmex::Stats] the stats model
     def stats
-      Bitmex::Stats.new self
+      Bitmex::Stats.new rest
     end
 
     # Individual and bucketed trades
     # @return [Bitmex::Trade] the trade model
     def trades
-      Bitmex::Trade.new self
+      Bitmex::Trade.new rest, websocket
     end
 
     # Account operations
     # @return [Bitmex::User] the user model
     def user
-      Bitmex::User.new self
-    end
-
-    # Listen to generic topics
-    # @param topics [Hash] topics to listen to e.g. { trade: "XBTUSD" }
-    # @yield [data] data pushed via websocket
-    def listen(topics, &ablock)
-      EM.run do
-        topics.each do |topic, symbol|
-          websocket.subscribe topic, symbol, &ablock
-        end
-      end
-    end
-
-    #
-    # Stop websocket listener
-    #
-    def stop
-      EM.stop_event_loop
+      Bitmex::User.new rest, websocket
     end
 
     def websocket
-      @websocket ||= Websocket.new realtime_url
-    end
-
-    # TODO: move these methods into rest client
-    def get(path, params: {}, auth: false, &ablock)
-      options = {}
-      options[:query] = params unless params.empty?
-      options[:headers] = headers 'GET', path, '' if auth
-
-      response = self.class.get "#{domain_url}#{path}", options
-      yield response
-    end
-
-    def put(path, params: {}, auth: true, json: true)
-      body = json ? params.to_json.to_s : URI.encode_www_form(params)
-
-      options = {}
-      options[:body] = body
-      options[:headers] = headers 'PUT', path, body, json: json if auth
-
-      response = self.class.put "#{domain_url}#{path}", options
-      yield response
-    end
-
-    def post(path, params: {}, auth: true, json: true)
-      body = json ? params.to_json.to_s : URI.encode_www_form(params)
-
-      options = {}
-      options[:body] = body
-      options[:headers] = headers 'POST', path, body, json: json if auth
-
-      response = self.class.post "#{domain_url}#{path}", options
-      yield response
-    end
-
-    def delete(path, params: {}, auth: true, json: true)
-      body = json ? params.to_json.to_s : URI.encode_www_form(params)
-
-      options = {}
-      options[:body] = body
-      options[:headers] = headers 'DELETE', path, body, json: json if auth
-
-      response = self.class.delete "#{domain_url}#{path}", options
-      yield response
-    end
-
-    def base_path(resource, action = '')
-      "/api/v1/#{resource}/#{action}"
-    end
-
-    def response_handler(response)
-      fail response.body unless response.success?
-
-      if response.parsed_response.is_a? Array
-        response.to_a.map { |s| Bitmex::Mash.new s }
-      else
-        Bitmex::Mash.new response
-      end
-    end
-
-    private
-
-    def method_missing(m, *args, &ablock)
-      name = m.to_s.gsub '_', ''
-      params = args.first || {}
-      type = params&.delete :type
-      types = self.class.const_get "#{name.upcase}_ARGS"
-      check! type, types
-
-      params[:auth] = auth_required? name
-
-      execute name, type, params do |response|
-        # p response.body
-        if response.parsed_response.is_a? Array
-          response.to_a.map do |s|
-            Bitmex::Mash.new s
-          end
-        else
-          Bitmex::Mash.new response
-        end
-      end
-    end
-
-    def auth_required?(action)
-      AUTHORIZATIONS.include? action
-    end
-
-    def execute(endpoint, type, params, &ablock)
-      url = "#{rest_url}/#{endpoint}/#{type}"
-      path = "/api/v1/#{endpoint}/#{type}"
-      auth = params&.delete(:auth)
-      params = nil if params&.empty?
-
-      options = { query: params }
-      options[:headers] = headers 'GET', path, '' if auth
-
-      response = self.class.get url, options
-      fail response.body unless response.success?
-      yield response
-    end
-
-    def headers(verb, path, body, json: true)
-      raise 'api_key and api_secret are required' unless api_key || api_secret
-
-      expires = Time.now.utc.to_i + 60
-      headers = {
-        'api-expires' => expires.to_s,
-        'api-key' => api_key,
-        'api-signature' => Bitmex.signature(api_secret, verb, path, expires, body)
-      }
-      if json
-        headers['Content-Type'] = 'application/json'
-      else
-        headers['Content-Type'] = 'application/x-www-form-urlencoded'
-      end
-      headers
-    end
-
-    def check!(type, types)
-      return true if type.nil? or type == ''
-      raise ArgumentError, "invalid argument #{type}, only #{types} are supported" if !types.include?(type.to_s)
-    end
-
-    def rest_url
-      "https://#{host}/api/v1"
-    end
-
-    def domain_url
-      "https://#{host}"
+      @websocket ||= Websocket.new host, api_key: api_key, api_secret: api_secret
     end
 
-    def realtime_url
-      "wss://#{host}/realtime"
+    def rest
+      @rest ||= Rest.new host, api_key: api_key, api_secret: api_secret
     end
   end
 end