cryptomarket-sdk 1.0.0 → 3.0.0

data/lib/cryptomarket/constants.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Cryptomarket
+  module Args
+    module Sort
+      ASC = 'ASC'
+      DESC = 'DESC'
+    end
+
+    module Period # rubocop:disable Style/Documentation
+      _1_MINS = 'M1' # rubocop:disable Naming/VariableName
+      _3_MINS = 'M3' # rubocop:disable Naming/VariableName
+      _5_MINS = 'M5' # rubocop:disable Naming/VariableName
+      _15_MINS = 'M15' # rubocop:disable Naming/VariableName
+      _30_MINS = 'M30' # rubocop:disable Naming/VariableName
+      _1_HOURS = 'H1' # rubocop:disable Naming/VariableName
+      _4_HOURS = 'H4' # rubocop:disable Naming/VariableName
+      _1_DAYS = 'D1' # rubocop:disable Naming/VariableName
+      _7_DAYS = 'D7' # rubocop:disable Naming/VariableName
+      _1_MONTHS = '1M' # rubocop:disable Naming/VariableName
+    end
+
+    module Side
+      BUY = 'buy'
+      SELL = 'sell'
+    end
+
+    module OrderType
+      LIMIT = 'limit'
+      MARKET = 'market'
+      STOP_LIMIT = 'stopLimit'
+      STOP_MARKET = 'stopMarket'
+      TAKE_PROFIT_LIMIT = 'takeProfitLimit'
+      TAKE_PROFIT_MARKET = 'takeProfitMarket'
+    end
+
+    module TimeInForce
+      GTC = 'GTC'  # Good till canceled
+      IOC = 'IOC'  # Immediate or cancell
+      FOK = 'FOK'  # Fill or kill
+      DAY = 'Day'  # Good for the day
+      GTD = 'GDT'  # Good till date
+    end
+
+    module IdentifyBy
+      USERNAME = 'username'
+      EMAIL = 'email'
+    end
+
+    module Offchain
+      NEVER = 'never'
+      OPTIONALLY = 'optionally'
+      REQUIRED = 'required'
+    end
+
+    module Account
+      SPOT = 'spot'
+      WALLET = 'wallet'
+    end
+
+    module TransactionType
+      DEPOSIT = 'DEPOSIT'
+      WITHDRAW = 'WITHDRAW'
+      TRANSFER = 'TRANSFER'
+      SAWAP = 'SAWAP'
+    end
+
+    module TransactionSubtype
+      UNCLASSIFIED = 'UNCLASSIFIED'
+      BLOCKCHAIN = 'BLOCKCHAIN'
+      AIRDROP = 'AIRDROP'
+      AFFILIATE = 'AFFILIATE'
+      STAKING = 'STAKING'
+      BUY_CRYPTO = 'BUY_CRYPTO'
+      OFFCHAIN = 'OFFCHAIN'
+      FIAT = 'FIAT'
+      SUB_ACCOUNT = 'SUB_ACCOUNT'
+      WALLET_TO_SPOT = 'WALLET_TO_SPOT'
+      SPOT_TO_WALLET = 'SPOT_TO_WALLET'
+      WALLET_TO_DERIVATIVES = 'WALLET_TO_DERIVATIVES'
+      DERIVATIVES_TO_WALLET = 'DERIVATIVES_TO_WALLET'
+      CHAIN_SWITCH_FROM = 'CHAIN_SWITCH_FROM'
+      CHAIN_SWITCH_TO = 'CHAIN_SWITCH_TO'
+      INSTANT_EXCHANGE = 'INSTANT_EXCHANGE'
+    end
+
+    module TransactionStatus
+      CREATED = 'CREATED'
+      PENDING = 'PENDING'
+      FAILED = 'FAILED'
+      SUCCESS = 'SUCCESS'
+      ROLLED_BACK = 'ROLLED_BACK'
+    end
+
+    module SortBy
+      CREATED_AT = 'created_at'
+      ID = 'id'
+    end
+
+    module Contingency
+      ALL_OR_NONE = 'allOrNone'
+      AON = 'allOrNone'
+      ONE_CANCEL_OTHER = 'oneCancelOther'
+      OCO = 'oneCancelOther'
+      ONE_TRIGGER_OTHER = 'oneTriggerOther'
+      OTO = 'oneTriggerOther'
+      ONE_TRIGGER_ONE_CANCEL_OTHER = 'oneTriggerOneCancelOther'
+      OTOCO = 'oneTriggerOneCancelOther'
+    end
+
+    module NotificationType
+      SNAPSHOT = 'snapshot'
+      UPDATE = 'update'
+      DATA = 'data'
+      COMMAND = 'command'
+    end
+
+    module SubscriptionMode
+      UPDATES = 'updates'
+      BATCHES = 'batches'
+    end
+  end
+end

data/lib/cryptomarket/credentials_factory.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'base64'
+require 'rest-client'
+require 'date'
+require_relative 'exceptions'
+
+module Cryptomarket
+  # Builds a credential used by the cryptomarket server
+  class CredentialsFactory
+    def initialize(api_version:, api_key:, api_secret:, window: nil)
+      @api_version = api_version
+      @api_key = api_key
+      @api_secret = api_secret
+      @window = window
+    end
+
+    def get_credential(http_method, method, params)
+      timestamp = DateTime.now.strftime('%Q')
+      msg = build_credential_message(http_method, method, timestamp, params)
+      digest = OpenSSL::Digest.new 'sha256'
+      signature = OpenSSL::HMAC.hexdigest digest, @api_secret, msg
+      signed = "#{@api_key}:#{signature}:#{timestamp}"
+      signed += ":#{@window}" unless @window.nil?
+      encoded = Base64.encode64(signed).delete "\n"
+      "HS256 #{encoded}"
+    end
+
+    def build_credential_message(http_method, method, timestamp, params)
+      msg = http_method + @api_version + method
+      msg += if http_method.upcase == 'POST'
+               params
+             else
+               not_post_params(http_method, params)
+             end
+      msg += timestamp
+      msg += @window unless @window.nil?
+      msg
+    end
+
+    def not_post_params(http_method, params)
+      msg = ''
+      if !params.nil? && params.keys.any?
+        msg += '?' if http_method.upcase == 'GET'
+        msg += URI.encode_www_form(params)
+      end
+      msg
+    end
+  end
+end

data/lib/cryptomarket/exceptions.rb

@@ -1,24 +1,23 @@
-module Cryptomarket
-    class SDKException < ::StandardError
-    end
+# frozen_string_literal: true
 
-    class APIException < SDKException
-        def initialize(hash)
-            @code = hash['code']
-            @message = hash['message']
-            @description = hash['description']
-        end
+module Cryptomarket
+  class SDKException < ::StandardError
+  end
 
-        def code
-            return @code
-        end
+  # Exception representing an error from the server
+  class APIException < SDKException
+    def initialize(hash)
+      @code = hash['code']
+      raw_message = hash['message']
+      @description = hash.key?('description') ? hash['description'] : ''
+      @message = "#{self.class.name} (code=#{@code}): #{raw_message}. #{@description}"
+      super
+    end
 
-        def message
-            return @message
-        end
+    attr_reader :code, :message, :description
 
-        def description
-            return @description
-        end
+    def to_s
+      @message
     end
-end
+  end
+end

data/lib/cryptomarket/http_manager.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'base64'
+require 'rest-client'
+require 'date'
+require_relative 'exceptions'
+require_relative 'credentials_factory'
+
+def post?(method)
+  method.upcase == 'POST'
+end
+
+def get?(method)
+  method.upcase == 'GET'
+end
+
+def put?(method)
+  method.upcase == 'PUT'
+end
+
+def patch?(method)
+  method.upcase == 'PATCH'
+end
+
+module Cryptomarket
+  # Manager of http requests to the cryptomarket server
+  class HttpManager
+    @@API_URL = 'https://api.exchange.cryptomkt.com' # rubocop:disable Naming/VariableName,Style/ClassVars
+    @@API_VERSION = '/api/3/' # rubocop:disable Naming/VariableName,Style/ClassVars
+
+    def initialize(api_key:, api_secret:, window: nil)
+      @credential_factory = Cryptomarket::CredentialsFactory.new(
+        api_version: @@API_VERSION, api_key: api_key, api_secret: api_secret, window: window
+      )
+    end
+
+    def make_request(method:, endpoint:, params: nil, public: false)
+      uri = URI(@@API_URL + @@API_VERSION + endpoint)
+      payload = build_payload(params)
+      headers = build_headers(method, endpoint, payload, public)
+      if ((method.upcase == 'GET') || (method.upcase == 'PUT')) && !payload.nil?
+        uri.query = URI.encode_www_form payload
+        payload = nil
+      end
+      do_request(method, uri, payload, headers)
+    end
+
+    def make_post_request(method:, endpoint:, params: nil)
+      uri = URI(@@API_URL + @@API_VERSION + endpoint)
+      payload = build_payload(params)
+      do_request(method, uri, payload, build_post_headers(endpoint, payload))
+    end
+
+    def build_headers(method, endpoint, params, public)
+      return {} if public
+
+      { 'Authorization' => @credential_factory.get_credential(method.upcase, endpoint, params) }
+    end
+
+    def build_payload(params)
+      return nil if params.nil?
+
+      payload = params.compact
+      payload = Hash[payload.sort_by { |key, _val| key.to_s }] if payload.is_a?(Hash)
+      payload
+    end
+
+    def do_request(method, uri, payload, headers)
+      args = { method: method.downcase.to_sym, url: uri.to_s, headers: headers }
+      if post?(method) || patch?(method)
+        args[:payload] = post?(method) ? payload.to_json : payload
+      end
+      response = RestClient::Request.execute(**args)
+      handle_response(response)
+    rescue RestClient::ExceptionWithResponse => e
+      handle_response(e.response)
+    end
+
+    def build_post_headers(endpoint, params)
+      { 'Content-Type' => 'application/json',
+        'Authorization' => @credential_factory.get_credential('POST'.upcase, endpoint, params.to_json) }
+    end
+
+    def handle_response(response)
+      result = response.body
+      parsed_result = JSON.parse result
+      if (response.code != 200) && !parsed_result['error'].nil?
+        error = parsed_result['error']
+        exception = Cryptomarket::APIException.new error
+        raise exception
+      end
+      parsed_result
+    end
+  end
+end

data/lib/cryptomarket/websocket/auth_client.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'client_base'
+
+module Cryptomarket
+  module Websocket
+    # A websocket client that authenticates at the moment of connection
+    class AuthClient < ClientBase
+      # Creates a new client
+      def initialize(url:, api_key:, api_secret:, subscription_keys:, window: nil)
+        @api_key = api_key
+        @api_secret = api_secret
+        @window = window
+        super url: url, subscription_keys: subscription_keys
+        @authed = false
+      end
+
+      def connected?
+        (super.connected? and @authed)
+      end
+
+      # connects via websocket to the exchange and authenticates it.
+      def connect
+        super
+        authenticate(proc { |err, _result|
+          raise err unless err.nil?
+
+          @authed = true
+        })
+        wait_authed
+      end
+
+      def wait_authed
+        current_try = 0
+        max_tries = 60
+        while !@authed && (current_try < max_tries)
+          current_try += 1
+          sleep(1)
+        end
+      end
+
+      # Authenticates the websocket
+      #
+      # https://api.exchange.cryptomkt.com/#socket-session-authentication
+      #
+      # +Proc+ +callback+:: Optional. A +Proc+ to call with the result data. It takes two arguments, err and result.
+      # err is None for successful calls, result is None for calls with error: Proc.new {|err, result| ...}
+
+      def authenticate(callback = nil)
+        timestamp = Time.now.to_i * 1000
+        digest = OpenSSL::Digest.new 'sha256'
+        message = timestamp.to_s
+        message += @window.to_s unless @window.nil?
+        signature = OpenSSL::HMAC.hexdigest digest, @api_secret, message.to_s
+        params = build_auth_payload timestamp, signature
+        request('login', callback, params)
+      end
+
+      def build_auth_payload(timestamp, signature)
+        params = {
+          'type' => 'HS256',
+          'api_key' => @api_key,
+          'timestamp' => timestamp,
+          'signature' => signature
+        }
+        params['window'] = @window unless @window.nil?
+        params
+      end
+    end
+  end
+end

data/lib/cryptomarket/websocket/callback_cache.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'reusable_callback'
+
+module Cryptomarket
+  module Websocket
+    # A cache store for callbacks. uses reusable callbacks, so it cans use a callback for more than one time.
+    # Each callback stored
+    class CallbackCache
+      def initialize
+        @reusable_callbacks = {}
+        @subscription_callbacks = {}
+        @next_id = 1
+      end
+
+      def _get_next_id
+        next_id = @next_id
+        @next_id += 1
+        @next_id = 1 if @next_id.negative?
+        next_id
+      end
+
+      def store_callback(callback, call_count = 1)
+        id = _get_next_id
+        @reusable_callbacks[id] = ReusableCallback.new(callback, call_count)
+        id
+      end
+
+      def get_callback(id)
+        return nil unless @reusable_callbacks.key? id
+
+        callback, done_using = @reusable_callbacks[id].get_callback
+        @reusable_callbacks.delete(id) if done_using
+        callback
+      end
+
+      def store_subscription_callback(key, callback)
+        @subscription_callbacks[key] = callback
+      end
+
+      def get_subscription_callback(key)
+        return nil unless @subscription_callbacks.key? key
+
+        @subscription_callbacks[key]
+      end
+
+      def delete_subscription_callback(key)
+        return unless @subscription_callbacks.key? key
+
+        @subscription_callbacks.delete(key)
+      end
+    end
+  end
+end

data/lib/cryptomarket/websocket/client_base.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'callback_cache'
+require_relative 'ws_manager'
+require_relative '../exceptions'
+
+module Cryptomarket
+  module Websocket
+    # websockt client able to handle requests and subscriptions
+    class ClientBase
+      def initialize(url:, subscription_keys:, on_connect: -> {}, on_error: ->(error) {}, on_close: -> {})
+        @subscription_keys = subscription_keys
+        @callback_cache = CallbackCache.new
+        @ws_manager = WSManager.new self, url: url
+        @on_connect = on_connect
+        @on_error = on_error
+        @on_close = on_close
+      end
+
+      def connected?
+        @ws_manager.connected?
+      end
+
+      # connects via websocket to the exchange, it blocks until the connection is stablished
+      def connect
+        @ws_manager.connect
+        sleep(1) until @ws_manager.connected?
+      end
+
+      def on_open
+        @on_connect.call
+      end
+
+      def on_connect=(callback = nil, &block)
+        callback ||= block
+        @on_connect = callback
+      end
+
+      def on_connect
+        @on_connect.call
+      end
+
+      def on_error=(callback = nil, &block)
+        callback ||= block
+        @on_error = callback
+      end
+
+      def on_error(error)
+        @on_error.call(error)
+      end
+
+      def on_close=(callback = nil, &block)
+        callback ||= block
+        @on_close = callback
+      end
+
+      def on_close
+        @on_close.call
+      end
+
+      def close
+        @ws_manager.close
+      end
+
+      def send_subscription(method, callback, params, result_callback)
+        @callback_cache.store_subscription_callback(@subscription_keys[method][0], callback)
+        store_callback_and_send(method, params, result_callback)
+      end
+
+      def send_unsubscription(method, callback, params)
+        @callback_cache.delete_subscription_callback(@subscription_keys[method][0])
+        store_callback_and_send(method, params, callback)
+      end
+
+      def request(method, callback, params = {}, call_count = 1)
+        store_callback_and_send(method, params, callback, call_count)
+      end
+
+      def store_callback_and_send(method, params, callback_to_store = nil, call_count = 1)
+        params = params.compact unless params.nil?
+        payload = { 'method' => method, 'params' => params }
+        unless callback_to_store.nil?
+          id = @callback_cache.store_callback(callback_to_store, call_count)
+          payload['id'] = id
+        end
+        @ws_manager.send(payload)
+      end
+
+      def handle(message)
+        if message.key? 'id'
+          handle_response(message)
+        elsif message.key? 'method'
+          handle_notification(message)
+        end
+      end
+
+      def handle_notification(notification)
+        method = notification['method']
+        method_data = @subscription_keys[method]
+        notification_type = method_data[1]
+        callback = @callback_cache.get_subscription_callback(method_data[0])
+        return if callback.nil?
+
+        callback.call(notification['params'], notification_type)
+      end
+
+      def get_callback_for_response(response)
+        id = response['id']
+        return if id.nil?
+
+        @callback_cache.get_callback(id)
+      end
+
+      def handle_response(response)
+        callback = get_callback_for_response(response)
+        return if callback.nil?
+
+        if response.key? 'error'
+          callback.call(Cryptomarket::APIException.new(response['error']), nil)
+          nil
+        end
+        handle_good_response(response, callback)
+      end
+
+      def handle_good_response(response, callback)
+        result = response['result']
+        if result.is_a?(Hash) && result.key?('data')
+          callback.call(nil, result['data'])
+        else
+          callback.call(nil, result)
+        end
+      end
+    end
+  end
+end