cryptomarket-sdk 1.0.1 → 3.0.0

data/lib/cryptomarket/HttpManager.rb

@@ -1,75 +0,0 @@
-require 'net/http'
-require 'uri'
-require 'json'
-require 'base64'
-require 'rest-client'
-require_relative 'exceptions'
-
-module Cryptomarket
-    class HttpManager
-        @@apiUrl = 'https://api.exchange.cryptomkt.com'
-        @@apiVersion = '/api/2/'
-
-        
-        def initialize(apiKey:, apiSecret:)
-            @apiKey = apiKey
-            @apiSecret = apiSecret
-        end
-
-        def getCredential(httpMethod, method, params)
-            timestamp = Time.now.to_i.to_s
-            msg = httpMethod + timestamp + @@apiVersion + method
-            if not params.nil? and params.keys.any?
-                if httpMethod.upcase == 'GET' or httpMethod.upcase == 'PUT'
-                    msg += '?'
-                end
-                msg += URI.encode_www_form params
-            end
-            digest = OpenSSL::Digest.new 'sha256'
-            signature = OpenSSL::HMAC.hexdigest digest, @apiSecret, msg
-            encoded = Base64.encode64(@apiKey + ':' + timestamp + ':' + signature).delete "\n"
-            return 'HS256 ' + encoded
-        end
-        
-        def makeRequest(method:, endpoint:, params:nil, public:false)
-            uri = URI(@@apiUrl + @@apiVersion + endpoint)
-            if not params.nil?
-                params = Hash[params.sort_by {|key, val| key.to_s }]
-            end
-            headers = Hash.new
-            if not public
-                headers['Authorization'] = getCredential(method.upcase, endpoint, params)
-            end
-            if (method.upcase == 'GET' or method.upcase =='PUT') and not params.nil?
-                uri.query = URI.encode_www_form params
-                params = nil
-            end
-            begin
-                response = RestClient::Request.execute(
-                    method: method.downcase.to_sym, 
-                    url: uri.to_s,
-                    payload: params, 
-                    headers: headers)
-                return handleResponse(response)
-            rescue RestClient::ExceptionWithResponse => e
-                response = e.response
-                return handleResponse(response)
-            end
-        end
-        
-        def handleResponse(response)
-            result = response.body
-            parsed_result = JSON.parse result
-            if response.code != 200 and not parsed_result['error'].nil?
-                error = parsed_result['error']
-                msg = "(code=#{error['code']}): #{error['message']}"
-                if not error['description'].nil?
-                    msg += ": #{error['description']}"
-                end
-                exception = Cryptomarket::APIException.new error
-                raise exception, msg
-            end
-            return parsed_result
-        end
-    end
-end

data/lib/cryptomarket/utils.rb

@@ -1,57 +0,0 @@
-module Cryptomarket
-    module Utils
-        def extend_hash_with_pagination!(hash, sort: nil, by:nil, from: nil, till: nil, limit: nil, offset: nil)
-            if not sort.nil?
-                hash['sort'] = sort
-            end
-            if not by.nil?
-                hash['by'] = by
-            end
-            if not from.nil?
-                hash['from'] = from
-            end
-            if not till.nil?
-                hash['till'] = till
-            end
-            if not limit.nil?
-                hash['limit'] = limit
-            end
-            if not offset.nil?
-                hash['offset'] = offset
-            end
-        end
-
-        def extend_hash_with_order_params! hash, symbol:nil, side:nil, quantity:nil, type:nil, timeInForce:nil, price:nil, stopPrice:nil, expireTime:nil, strictValidate:nil, postOnly:nil
-            if not symbol.nil?
-                hash['symbol'] = symbol
-            end
-            if not side.nil?
-                hash['side'] = side
-            end
-            if not quantity.nil?
-                hash['quantity'] = quantity
-            end
-            if not type.nil?
-                hash['type'] = type
-            end
-            if not timeInForce.nil?
-                hash['timeInForce'] = timeInForce
-            end
-            if not price.nil?
-                hash['price'] = price
-            end
-            if not stopPrice.nil?
-                hash['stopPrice'] = stopPrice
-            end
-            if not expireTime.nil?
-                hash['expireTime'] = expireTime
-            end
-            if not strictValidate.nil?
-                hash['strictValidate'] = strictValidate
-            end
-            if not postOnly.nil?
-                hash['postOnly'] = postOnly
-            end
-        end
-    end
-end

data/lib/cryptomarket/websocket/accountClient.rb

@@ -1,150 +0,0 @@
-require_relative "authClient"
-require_relative"../utils"
-
-module Cryptomarket
-    module Websocket
-
-        # AccountClient connects via websocket to cryptomarket to get account information of the user. uses SHA256 as auth method and authenticates automatically.
-        #
-        # +string+ +apiKey+:: the user api key
-        # +string+ +apiSecret+:: the user api secret
-        # +Proc+ +callback+:: Optional. A +Proc+ to call with the client once the connection is established and the authentication is successful. if an error ocurrs is return as the fist parameter of the callback: callback(err, client)
-
-        class AccountClient < AuthClient
-            include Utils
-            
-            # Creates a new client and authenticates it to the server
-            def initialize(apiKey:, apiSecret:)
-                transaction = "transaction"
-                balance = "balance"
-                super(
-                    url:"wss://api.exchange.cryptomkt.com/api/2/ws/account", 
-                    apiKey:apiKey, 
-                    apiSecret:apiSecret, 
-                    subscriptionKeys:{
-                        "unsubscribeTransactions" => transaction,
-                        "subscribeTransactions" => transaction,
-                        "updateTransaction" => transaction,
-        
-                        "unsubscribeBalance" => balance,
-                        "subscribeBalance" => balance,
-                        "balance" => balance,
-                    })
-            end
-
-            # get the account balance as a list of balances. non-zero balances only
-            #
-            # https://api.exchange.cryptomarket.com/#request-balance
-            
-            def getAccountBalance(callback)
-                sendById('getBalance', callback)
-            end
-
-            # Get a list of transactions of the account. Accepts only filtering by Datetime
-            #
-            # https://api.exchange.cryptomarket.com/#find-transactions
-            #
-            # Parameters:
-            # +Proc+ +callback+:: 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| ...}
-            # +string+ +currency+:: Optional. Currency to filter transactions by.
-            # +string+ +sort+:: Optional. sort direction. 'ASC' or 'DESC' default is 'DESC'
-            # +string+ +from+:: Optional. Initial value of the queried interval
-            # +string+ +till+:: Optional. Last value of the queried interval
-            # +integer+ +limit+:: Optional. Trades per query. Defaul is 100. Max is 1000
-            # +integer+ +offset+:: Optional. Default is 0. Max is 100000
-            # +bool+ +showSenders+:: Optional. If true incluedes senders addresses. Default is false.
-
-            def findTransactions(callback, currency:nil, sort:nil, from:nil, till:nil, limit:nil, offset:nil, showSenders:nil)
-                params = Hash.new
-                if not currency.nil?
-                    params['currency'] = currency
-                end
-                if not showSenders.nil?
-                    params['showSenders'] = showSenders
-                end
-                extend_hash_with_pagination! params, sort:sort, from:from, till:till, limit:limit, offset:offset
-                sendById('findTransactions', callback, params)
-            end
-
-            # LoadTransactions gets a list of transactions of the account. Accepts only filtering by Index
-            #
-            # https://api.exchange.cryptomarket.com/#find-transactions
-            #
-            # Parameters:
-            # +Proc+ +callback+:: 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| ...}
-            # +string+ +currency+:: Optional. Currency to filter transactions by.
-            # +string+ +sort+:: Optional. sort direction. 'ASC' or 'DESC' default is 'ASC'
-            # +string+ +from+:: Optional. Initial value of the queried interval (Included)
-            # +string+ +till+:: Optional. Last value of the queried interval (Excluded)
-            # +integer+ +limit+:: Optional. Trades per query. Defaul is 100. Max is 1000
-            # +integer+ +offset+:: Optional. Default is 0. Max is 100000
-            # +bool+ +showSenders+:: Optional. If true incluedes senders addresses. Default is false.
-            
-            def loadTransactions(callback, currency:nil, sort:nil, from:nil, till:nil, limit:nil, offset:nil, showSenders:nil)
-                params = Hash.new
-                if not currency.nil?
-                    params['currency'] = currency
-                end
-                if not showSenders.nil?
-                    params['showSenders'] = showSenders
-                end
-                extend_hash_with_pagination! params, sort:sort, from:from, till:till, limit:limit, offset:offset
-                sendById('loadTransactions', callback, params)
-            end
-
-            # subscribes to a feed of transactions
-            #
-            # A transaction notification occurs each time the transaction has been changed:
-            # such as creating a transaction, updating the pending state (for example the hash assigned)
-            # or completing a transaction. This is the easiest way to track deposits or develop real-time asset monitoring.
-            #
-            # A combination of the recovery mechanism and transaction subscription provides reliable and consistent information
-            # regarding transactions. For that, you should store the latest processed index and
-            # requested possible gap using a "loadTransactions" method after connecting or reconnecting the Websocket.
-            #
-            # https://api.exchange.cryptomarket.com/#subscription-to-the-transactions
-            #
-            # +Proc+ +callback+:: A +Proc+ to call with the result data. It takes one argument. a feed of reports
-            # +Proc+ +resultCallback+:: 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 subscribeToTransactions(callback, resultCallback:nil)
-                sendSubscription('subscribeTransactions', callback, {}, resultCallback)
-            end
-
-            # unsubscribe to the transaction feed.
-            #
-            # https://api.exchange.cryptomkt.com/#subscription-to-the-transactions
-            #
-            # +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 unsubscribeToTransactions(callback:nil)
-                sendUnsubscription('unsubscribeTransactions', callback, {})
-            end
-
-            # subscribes to a feed of balances
-            #
-            # This subscription aims to provide an easy way to be informed of the current balance state. 
-            # If the state has been changed or potentially changed the "balance" event will come with the actual state. 
-            # Please be aware that only non-zero values present.
-            #
-            # https://api.exchange.cryptomkt.com/#subscription-to-the-balance
-            #
-            # +Proc+ +callback+:: A +Proc+ to call with the result data. It takes one argument. a feed of balances
-            # +Proc+ +resultCallback+:: 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 subscribeToBalance(callback, resultCallback:nil)
-                sendSubscription('subscribeBalance', callback, {}, resultCallback)
-            end
-
-            # unsubscribe to the balance feed.
-            #
-            # https://api.exchange.cryptomkt.com/#subscription-to-the-balance
-            #
-            # +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 unsubscribeToBalance(callback:nil)
-                sendUnsubscription('unsubscribeBalance', callback, {})
-            end
-        end
-    end
-end

data/lib/cryptomarket/websocket/authClient.rb

@@ -1,53 +0,0 @@
-require "securerandom"
-require_relative "wsClientBase"
-
-module Cryptomarket
-    module Websocket
-        class AuthClient < ClientBase
-            # Creates a new client
-            def initialize(url:, apiKey:, apiSecret:, subscriptionKeys:)
-                @apiKey = apiKey
-                @apiSecret = apiSecret
-                super url:url, subscriptionKeys:subscriptionKeys
-                @authed = false
-            end
-
-            def connected?
-                return (super.connected? and @authed)
-            end
-
-            # connects via websocket to the exchange and authenticates it.
-            def connect
-                super
-                authenticate(Proc.new {|err, result|
-                    if not err.nil?
-                        raise err
-                    end
-                    @authed = true
-                })
-                while not @authed
-                    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)
-                nonce = SecureRandom.hex
-                digest = OpenSSL::Digest.new 'sha256'
-                signature = OpenSSL::HMAC.hexdigest digest, @apiSecret, nonce
-                params = {
-                    'algo'=> 'HS256',
-                    'pKey'=> @apiKey,
-                    'nonce'=> nonce,
-                    'signature'=> signature
-                }
-                return sendById('login', callback, params)
-            end
-        end
-    end
-end

data/lib/cryptomarket/websocket/callbackCache.rb

@@ -1,51 +0,0 @@
-module Cryptomarket
-    module Websocket
-        class CallbackCache 
-            def initialize() 
-                @callbacks = Hash.new
-                @nextId = 1
-            end
-
-            def getNextId
-                _nextId = @nextId
-                @nextId+= 1
-                if @nextId < 0
-                    @nextId = 1
-                end
-                return _nextId
-            end
-
-            def storeCallback(callback)
-                id = getNextId()
-                @callbacks[id] = callback
-                return id
-            end
-
-            def popCallback(id)
-                if not @callbacks.has_key? id
-                    return nil
-                end
-                callback = @callbacks[id]
-                @callbacks.delete(id)
-                return callback
-            end
-
-            def storeSubscriptionCallback(key, callback) 
-                @callbacks[key] = callback
-            end
-
-            def getSubscriptionCallback(key)
-                if not @callbacks.has_key? key
-                    return nil
-                end
-                return @callbacks[key]
-            end
-
-            def deleteSubscriptionCallback(key) 
-                if @callbacks.has_key? key
-                    @callbacks.delete(key)
-                end
-            end
-        end
-    end
-end

data/lib/cryptomarket/websocket/orderbookCache.rb

@@ -1,123 +0,0 @@
-require "bigdecimal"
-
-module Cryptomarket
-    module Websocket
-        class OrderbookCache 
-
-            # orderbook states
-            @@UPDATING = 0
-            @@WAITING = 1
-            @@BROKEN = 2
-            # order book side ordering direction
-            @@ASCENDING = 3
-            @@DESCENDING = 4
-
-            def initialize() 
-                @orderbooks = Hash.new
-                @orderbooks_states = Hash.new
-            end
-
-            def update(method, key, updateData) 
-                case method
-                when 'snapshotOrderbook'
-                    @orderbooks_states[key] = @@UPDATING
-                    @orderbooks[key] = updateData
-                    return @orderbooks[key]
-                when 'updateOrderbook'
-                    if @orderbooks_states[key] != @@UPDATING
-                        return
-                    end
-                    oldOrderbook = @orderbooks[key]
-                    if updateData['sequence'] - oldOrderbook['sequence'] != 1
-                        @orderbooks_states[key] = @@BROKEN
-                        return
-                    end
-                    oldOrderbook['sequence'] = updateData['sequence']
-                    oldOrderbook['timestamp'] = updateData['timestamp']
-                    if updateData.has_key? 'ask'
-                        oldOrderbook['ask'] = updateBookSide(oldOrderbook['ask'], updateData['ask'], @@ASCENDING)
-                    end
-                    if updateData.has_key? 'bid'
-                        oldOrderbook['bid'] = updateBookSide(oldOrderbook['bid'], updateData['bid'], @@DESCENDING)
-                    end
-                end
-            end
-
-            def updateBookSide(oldList, updateList, sortDirection) 
-                newList = Array.new
-                oldIdx = 0
-                updateIdx = 0
-                while (oldIdx < oldList.length && updateIdx < updateList.length) 
-                    updateEntry = updateList[updateIdx]
-                    oldEntry = oldList[oldIdx]
-                    order = priceOrder(oldEntry, updateEntry, sortDirection)
-                    if (order == 0) 
-                        if not zeroSize(updateEntry)
-                            newList.push(updateEntry)
-                        end
-                        updateIdx+= 1
-                        oldIdx+= 1
-                    elsif (order == 1)
-                        newList.push(oldEntry)
-                        oldIdx+= 1
-                    else 
-                        newList.push(updateEntry)
-                        updateIdx+= 1
-                    end
-                end
-                if updateIdx == updateList.length
-                    for idx in oldIdx..oldList.length-1
-                        oldEntry = oldList[idx]
-                        newList.push(oldEntry)
-                    end
-                end
-                if (oldIdx == oldList.length)
-                    for idx in updateIdx..updateList.length-1
-                        updateEntry = updateList[idx]
-                        if not zeroSize(updateEntry)
-                            newList.push(updateEntry)
-                        end
-                    end
-                end 
-                return newList
-            end
-
-            def zeroSize(entry) 
-                size = BigDecimal(entry['size'])
-                return size == BigDecimal("0.00")
-            end
-            
-            def priceOrder(oldEntry, updateEntry, sortDirection) 
-                oldPrice = BigDecimal(oldEntry['price'])
-                updatePrice = BigDecimal(updateEntry['price'])
-                # puts oldEntry.to_s() +"\t" + updateEntry.to_s()
-                direction = 1
-                if oldPrice > updatePrice
-                    direction = -1
-                end
-                if oldPrice == updatePrice
-                    direction = 0
-                end
-                if sortDirection == @@ASCENDING
-                    return direction
-                end
-                return -direction
-            end
-
-            def getOrderbook(key)
-                return Marshal.load(Marshal.dump(@orderbooks[key]))
-            end
-
-            def orderbookBroken(key)
-                return @orderbooks_states[key] == @@BROKEN
-            end
-            def orderbookWating(key)
-                return @orderbooks_states[key] == @@WAITING
-            end
-
-            def waitOrderbook(key)
-                @orderbooks_states[key] = @@WAITING
-            end
-        end
-    end
-end