kucoin-api 0.2.0

data/lib/kucoin/api/endpoints/trade/orders.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    module Endpoints
+      class Trade
+        class Orders < Trade
+          def create client_oid, side, symbol, options={}
+            options = { clientOid: client_oid, side: side, symbol: symbol }.merge(options)
+            assert_required_param options, :side, side_types
+            assert_param_is_one_of options, :type, order_types if options.has_key?(:type)
+            auth.ku_request :post, :index, **options
+          end
+          alias place create
+
+          def index options={}
+            auth.ku_request :get, :index, **options
+          end
+          alias all index
+          alias list index
+
+          def delete_all options={}
+            auth.ku_request :delete, :index, **options
+          end
+          alias cancel_all delete_all
+
+          def recent
+            auth.ku_request :get, :recent
+          end
+
+          def show order_id
+            auth.ku_request :get, :show, order_id: order_id
+          end
+          alias get show
+          alias detail show
+
+          def delete order_id
+            auth.ku_request :delete, :show, order_id: order_id
+          end
+          alias cancel delete
+        end
+      end
+    end
+  end
+end

data/lib/kucoin/api/endpoints/user.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    module Endpoints
+      class User < Base; end
+    end
+  end
+end

data/lib/kucoin/api/endpoints/user/accounts.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    module Endpoints
+      class User
+        class Accounts < User
+          def create currency, type
+            options = { currency: currency, type: type }
+            assert_param_is_one_of options, :type, account_types
+            auth.ku_request :post, :index, **options
+          end
+
+          def index options={}
+            auth.ku_request :get, :index, **options
+          end
+          alias all index
+          alias list index
+
+          def inner_transfer client_oid, pay_account_id, rec_account_id, amount
+            auth.ku_request :post, :inner_transfer, clientOid: client_oid, payAccountId: pay_account_id, recAccountId: rec_account_id, amount: amount
+          end
+
+          def show account_id
+            auth.ku_request :get, :show, account_id: account_id
+          end
+          alias get show
+          alias detail show
+
+          def ledgers account_id, options={}
+            auth.ku_request :get, :ledgers, account_id: account_id, **options
+          end
+
+          def holds account_id
+            auth.ku_request :get, :holds, account_id: account_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kucoin/api/endpoints/user/deposits.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    module Endpoints
+      class User
+        class Deposits < User
+          def create currency
+            auth.ku_request :post, :create, currency: currency
+          end
+
+          def index options={}
+            auth.ku_request :get, :index, **options
+          end
+          alias all index
+          alias list index
+
+          def show currency
+            auth.ku_request :get, :show, currency: currency
+          end
+          alias get show
+          alias detail show
+        end
+      end
+    end
+  end
+end

data/lib/kucoin/api/endpoints/user/withdrawals.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    module Endpoints
+      class User
+        class Withdrawals < User
+          def create currency, address, amount, options={}
+            auth.ku_request :post, :index, currency: currency, address: address, amount: amount, **options
+          end
+          alias apply create
+
+          def index options={}
+            auth.ku_request :get, :index, **options
+          end
+          alias all index
+          alias list index
+
+          def quotas currency
+            auth.ku_request :get, :quotas, currency: currency
+          end
+
+          def delete withdrawal_id
+            auth.ku_request :delete, :delete, withdrawal_id: withdrawal_id
+          end
+          alias cancel delete
+        end
+      end
+    end
+  end
+end

data/lib/kucoin/api/endpoints/websocket.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    module Endpoints
+      class Websocket < Base
+        def public
+          Response.new(open.ku_request :post, :public)
+        end
+
+        def private
+          Response.new(auth.ku_request :post, :private)
+        end
+
+        private
+
+        class Response
+          attr_reader :token, :endpoint, :ping_interval
+          def initialize response
+            @token = response["token"]
+            @endpoint = response["instanceServers"][0]["endpoint"]
+            @ping_interval = response["instanceServers"][0]["pingInterval"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kucoin/api/error.rb

@@ -0,0 +1,11 @@
+module Kucoin
+  module Api
+    class Error < StandardError; end
+    class MissingApiKeyError < StandardError; end
+    class MissingApiSecretError < StandardError; end
+    class MissingApiPassphraseError < StandardError; end
+    class ClientError < StandardError; end
+    class MissingParamError < StandardError; end
+    class InvalidParamError < StandardError; end
+  end
+end

data/lib/kucoin/api/middleware/auth_request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    module Middleware
+      class AuthRequest < Faraday::Middleware
+        def initialize app, api_key, api_secret, api_passphrase
+          super(app)
+          @api_key = api_key.to_s
+          @api_secret = api_secret.to_s
+          @api_passphrase = api_passphrase.to_s
+        end
+
+        def call env
+          raise Kucoin::Api::MissingApiKeyError.new('API KEY not provided') if @api_key.empty?
+          raise Kucoin::Api::MissingApiSecretError.new('API SECRET not provided') if @api_secret.empty?
+          raise Kucoin::Api::MissingApiPassphraseError.new('API PASSPHRASE not provided') if @api_passphrase.empty?
+          env[:request_headers]['KC-API-KEY'] = @api_key
+          env[:request_headers]['KC-API-SIGN'] = signature(env)
+          env[:request_headers]['KC-API-PASSPHRASE'] = @api_passphrase
+          @app.call env
+        end
+
+        private
+
+        def signature env
+          Base64.strict_encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), @api_secret, str_to_sign(env)))
+        end
+
+        def str_to_sign env
+          "#{env[:request_headers]['KC-API-TIMESTAMP']}#{env.method.upcase}#{env.url.request_uri}#{query_string(env)}"
+        end
+
+        def query_string env
+          return if [:get, :delete].include?(env.method.to_sym)
+          params = {}
+          begin
+            params.merge!(::JSON.parse(env.body.to_s))
+          rescue JSON::ParserError => e
+          end
+          params.to_json
+        end
+      end
+    end
+  end
+end

data/lib/kucoin/api/middleware/nonce_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    module Middleware
+      class NonceRequest < Faraday::Middleware
+        def call env
+          env[:request_headers]["KC-API-TIMESTAMP"] = DateTime.now.strftime('%Q')
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/kucoin/api/rest.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    class REST
+      BASE_URL          = 'https://openapi-v2.kucoin.com'.freeze
+      SANDBOX_BASE_URL  = 'https://openapi-sandbox.kucoin.com'.freeze
+
+      extend Kucoin::Api::Endpoints
+      generate_endpoint_methods
+
+      attr_reader :api_key, :api_secret, :api_passphrase
+      attr_reader :adapter
+
+      def initialize api_key: Kucoin::Api.default_key, api_secret: Kucoin::Api.default_secret, api_passphrase: Kucoin::Api.default_passphrase, adapter: Faraday.default_adapter, sandbox: false
+        @api_key = api_key
+        @api_secret = api_secret
+        @api_passphrase = api_passphrase
+        @adapter = adapter
+        @sandbox = sandbox
+      end
+      def sandbox?; @sandbox == true end
+
+      def base_url
+        sandbox? ? SANDBOX_BASE_URL : BASE_URL
+      end
+
+      def open endpoint
+        Connection.new(endpoint, url: base_url) do |conn|
+          conn.request :json
+          conn.response :json, content_type: 'application/json'
+          conn.adapter adapter
+        end
+      end
+
+      def auth endpoint
+        Connection.new(endpoint, url: base_url) do |conn|
+          conn.request :json
+          conn.response :json, content_type: 'application/json'
+          conn.use Kucoin::Api::Middleware::NonceRequest
+          conn.use Kucoin::Api::Middleware::AuthRequest, api_key, api_secret, api_passphrase
+          conn.adapter adapter
+        end
+      end
+    end
+  end
+end

data/lib/kucoin/api/rest/connection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Kucoin
+  module Api
+    class REST
+      class Connection
+        attr_reader :endpoint, :client
+        def initialize endpoint, options={}, &block
+          @endpoint = endpoint
+          @client = ::Faraday.new(options, &block)
+        end
+
+        def ku_request method, subpath, options = {}
+          response = client.public_send(method) do |req|
+
+            # substitute path parameters and remove from options hash
+            endpoint_url = endpoint.url(subpath).dup
+            options.each do |option, value|
+              path_param = /:#{option}/
+              if endpoint_url.match? path_param
+                options.delete(option)
+                endpoint_url.gsub!(path_param, value.to_s)
+              end
+            end
+
+            req.url endpoint_url
+
+            # parameters go into request body, not headers on POSTs
+            if method == :post
+              req.body = options
+            else
+              req.params.merge!(options)
+            end
+          end
+          success_or_error response
+        end
+
+        private
+
+        def success_or_error response
+          body = response.body.is_a?(Hash) ? response.body : JSON.parse(response.body)
+          return body['data'] if body['code'].to_i == 200000
+          return body if response.status == 200
+          raise Kucoin::Api::ClientError.new("#{body["code"] || body["status"]} - #{body["msg"] || body["message"]}")
+        rescue => e
+          raise Kucoin::Api::ClientError.new("#{e.message}\n#{response.body}")
+        end
+      end
+    end
+  end
+end

data/lib/kucoin/api/version.rb

@@ -0,0 +1,5 @@
+module Kucoin
+  module Api
+    VERSION = "0.2.0"
+  end
+end

data/lib/kucoin/api/websocket.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Kucoin
+  module Api
+    class Websocket
+      class << self
+        def request_id; rand(Time.now.to_i) end
+
+        def subscribe channel:, params: {}
+          stream  = {id: request_id, privateChannel: false, response: true}.merge(params)
+          params = {
+            id: stream[:id], type: 'subscribe', topic: stream[:topic],
+            privateChannel: stream[:privateChannel], response: stream[:response],
+            tunnelId: stream[:tunnelId]
+          }.select { |k,v| !v.nil? }
+          channel.send(params.to_json)
+        end
+
+        def open_tunnel channel:, params: {}
+          stream  = {id: request_id, response: true}.merge(params)
+          params = {
+            id: stream[:id], type: 'openTunnel', newTunnelId: stream[:newTunnelId], response: stream[:response]
+          }
+          channel.send(params.to_json)
+        end
+      end
+
+      attr_reader :rest_client
+
+      def initialize rest_client: Kucoin::Api::REST.new
+        @rest_client = rest_client
+      end
+
+      def connect private: false, params: {}, methods:
+        create_stream(private ? auth_client(params: params) : open_client(params: params), methods: methods)
+      end
+
+      # Public: Create a WebSocket stream
+      #
+      # :stream - The Hash used to define the stream
+      #   :id             - Unique string to mark the request
+      #   :topic          - The topic you want to subscribe to
+      #   :privateChannel - The user will only receive messages related himself on the topic(default is false)
+      #   :response       - To return the ack messages after the subscriptions succeed(default is true)
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #            the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def start stream:, methods:
+        channel = connect(private: !!stream[:privateChannel], methods: methods)
+        self.class.subscribe channel: channel, params: stream
+        channel
+      end
+
+      # Public: Create a WebSocket stream for multiplex tunnels
+      #
+      # :stream - The Hash used to define the stream
+      #   :id             - Unique string to mark the request
+      #   :newTunnelId    - Required
+      #   :privateChannel - The user will only receive messages related himself on the topic(default is false)
+      #
+      def multiplex stream:, methods:
+        channel = connect(private: !!stream[:privateChannel], methods: methods)
+        self.class.open_tunnel channel: channel, params: stream
+        channel
+      end
+
+      # PUBLIC
+      def ticker symbols:, methods:
+        start stream: { topic: topic_path('/market/ticker', symbols) }, methods: methods
+      end
+
+      def all_ticker methods:
+        ticker symbols: :all, methods: methods
+      end
+
+      def snapshot symbol:, methods:
+        start stream: { topic: "/market/snapshot:#{symbol}" }, methods: methods
+      end
+      alias symbol_snapshot snapshot
+      alias market_snapshot snapshot
+
+      def level_2_market_data symbols:, methods:
+        start stream: { topic: topic_path('/market/level2', symbols) }, methods: methods
+      end
+
+      def match_execution_data symbols:, methods:, private_channel: false
+        start stream: { topic: topic_path('/market/match', symbols), privateChannel: private_channel }, methods: methods
+      end
+
+      def full_match_engine_data symbols:, methods:, private_channel: false
+        start stream: { topic: topic_path('/market/level3', symbols), privateChannel: private_channel }, methods: methods
+      end
+
+      # PRIVATE
+      def stop_order_received_event symbols: , methods:
+        full_match_engine_data symbols: symbols, methods: methods, private_channel: true
+      end
+      alias stop_order_activate_event stop_order_received_event
+
+      def balance methods:
+        start stream: { topic: '/account/balance', privateChannel: true }, methods: methods
+      end
+
+      private
+
+      def open_client params: {}
+        get_client(rest_client.websocket.public, params: params)
+      end
+
+      def auth_client params: {}
+        get_client(rest_client.websocket.private, params: params)
+      end
+
+      def get_client response, params: {}
+        url = ["#{response.endpoint}?token=#{response.token}", URI.encode_www_form(params)].join('&')
+        Faye::WebSocket::Client.new(url, [], ping: response.ping_interval)
+      end
+
+      def create_stream websocket, methods:
+        attach_methods websocket, methods
+        websocket
+      end
+
+      # Internal: Iterate through methods passed and add them to the WebSocket
+      #
+      # websocket - The Faye::WebSocket::Client to apply methods to
+      #
+      # methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def attach_methods websocket, methods
+        methods.each_pair do |key, method|
+          websocket.on(key) { |event| method.call(event) }
+        end
+      end
+
+      def topic_path path, values=[]
+        values = [values] unless values.is_a?(Array)
+        "#{path}:#{values.compact.join(',')}"
+      end
+    end
+  end
+end