kucoin 0.1.0

data/lib/kucoin/rest/errors.rb

@@ -0,0 +1,30 @@
+module Kucoin
+  module Rest
+    module Errors
+      
+      def error?(response)
+        if response.is_a?(Hash) && (response.has_key?("error") || response.has_key?("code")) 
+          status      =   nil
+          message     =   nil
+          
+          if response.has_key?("error")
+            error     =   response.fetch("error", nil)
+            status    =   response.fetch("status", nil)
+            message   =   response.fetch("message", nil)
+          elsif response.has_key?("code") && response.fetch("code", nil).eql?("ERROR")
+            message   =   response.fetch("msg", nil)
+          end
+          
+          if !message.to_s.empty?
+            if status.nil?
+              raise ::Kucoin::Errors::ResponseError.new(message)
+            else
+              ::Kucoin::Errors::MAPPING.fetch(status, nil)&.call
+            end
+          end
+        end
+      end
+            
+    end
+  end  
+end

data/lib/kucoin/rest/private/balances.rb

@@ -0,0 +1,34 @@
+module Kucoin
+  module Rest
+    module Private
+      module Balances
+        
+        def wallet_records(coin, type: :deposit, status: :finished, limit: nil, page: nil, options: {})
+          options.merge!(authenticate: true)
+          
+          type      =   type.to_s.upcase
+          status    =   status.to_s.upcase
+          
+          params    =   {type: type, status: status, limit: limit, page: page}
+          params.delete_if { |key, value| value.nil? }
+          
+          parse(get("/account/#{coin}/wallet/records", params: params, options: options))&.fetch("data", {})
+        end
+        
+        def coin_balance(coin, options: {})
+          options.merge!(authenticate: true)          
+          
+          response  =   parse(get("/account/#{coin}/balance", options: options))&.fetch("data", {})
+          ::Kucoin::Models::Balance.new(response) if response
+        end
+        
+        def balance(options: {})
+          options.merge!(authenticate: true)          
+          response  =   parse(get("/account/balance", options: options))&.fetch("data", {})
+          ::Kucoin::Models::Balance.parse(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/private/invitations.rb

@@ -0,0 +1,24 @@
+module Kucoin
+  module Rest
+    module Private
+      module Invitations
+        
+        def invitation_count(options: {})
+          options.merge!(authenticate: true)
+          parse(get("/referrer/descendant/count", options: options))&.fetch("data", {})
+        end
+        
+        def promotion_reward(options: {})
+          options.merge!(authenticate: true)
+          parse(get("/account/promotion/info", options: options))&.fetch("data", {})
+        end
+        
+        def promotion_summary(options: {})
+          options.merge!(authenticate: true)
+          parse(get("/account/promotion/sum", options: options))&.fetch("data", {})
+        end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/private/languages.rb

@@ -0,0 +1,14 @@
+module Kucoin
+  module Rest
+    module Private
+      module Languages
+        
+        def change_language(language, options: {})
+          options.merge!(authenticate: true)
+          parse(post("/user/change-lang", data: {lang: language}, options: options))&.fetch("success", false)
+        end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/private/trading.rb

@@ -0,0 +1,113 @@
+module Kucoin
+  module Rest
+    module Private
+      module Trading
+                
+        def create_buy_order(symbol, price:, amount:, options: {})
+          create_order(symbol, type: :buy, price: price, amount: amount, options: options)
+        end
+        
+        def create_sell_order(symbol, price:, amount:, options: {})
+          create_order(symbol, type: :sell, price: price, amount: amount, options: options)
+        end
+        
+        def create_order(symbol, type: :buy, price:, amount:, options: {})
+          options.merge!(authenticate: true)
+
+          payload   =     {
+            symbol: symbol.to_s.upcase,
+            type:   type.to_s.upcase,
+            price:  price,
+            amount: amount
+          }
+          
+          parse(post("/order", data: payload, options: options))
+        end
+        
+        def cancel_order(symbol, type: :buy, order_id:, options: {})
+          options.merge!(authenticate: true)
+          
+          payload   =     {
+            orderOid: order_id,
+            type:     type.to_s.upcase
+          }
+          
+          response  =   parse(post("/#{symbol}/cancel-order", data: payload, options: options))
+        end
+        
+        def cancel_all_orders(symbol, type: :buy, options: {})
+          options.merge!(authenticate: true)
+          
+          payload   =     {
+            symbol:   symbol.to_s.upcase,
+            type:     type.to_s.upcase
+          }
+          
+          response  =   parse(post("/order/cancel-all", data: payload, options: options))
+        end
+        
+        def active_orders(symbol, type: :buy, options: {})
+          options.merge!(authenticate: true)
+          
+          params    =   {
+            symbol: symbol.to_s.upcase,
+            type:   type.to_s.upcase
+          }
+          
+          response  =   parse(get("/order/active", params: params, options: options))
+        end
+        
+        def dealt_orders(symbol: nil, type: nil, before: nil, since: nil, limit: nil, page: nil, options: {})
+          options.merge!(authenticate: true)
+          
+          params    =   {
+            symbol: symbol.to_s.upcase,
+            type:   type.to_s.upcase,
+            before: before,
+            since:  since,
+            limit:  limit,
+            page:   page
+          }
+          
+          params.delete_if { |key, value| value.nil? }
+          
+          response  =   parse(get("/order/dealt", params: params, options: options))&.dig("data", "datas")
+          ::Kucoin::Models::Deal.parse(response) if response
+        end
+        
+        def symbol_dealt_orders(symbol, type: nil, limit: nil, page: nil, options: {})
+          options.merge!(authenticate: true)
+          
+          params    =   {
+            symbol: symbol.to_s.upcase,
+            type:   type.to_s.upcase,
+            limit:  limit,
+            page:   page
+          }
+          
+          params.delete_if { |key, value| value.nil? }
+          
+          response  =   parse(get("/deal-orders", params: params, options: options))&.dig("data", "datas")
+          ::Kucoin::Models::Deal.parse(response) if response
+        end
+        
+        def order_detail(symbol, order_id:, type: :buy, limit: nil, page: nil, options: {})
+          options.merge!(authenticate: true)
+          
+          params    =   {
+            symbol:     symbol.to_s.upcase,
+            orderOid:   order_id,
+            type:       type.to_s.upcase,
+            limit:      limit,
+            page:       page
+          }
+          
+          params.delete_if { |key, value| value.nil? }
+          
+          response  =   parse(get("/order/detail", params: params, options: options))&.fetch("data", {})
+        end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/private/transfers.rb

@@ -0,0 +1,25 @@
+module Kucoin
+  module Rest
+    module Private
+      module Transfers
+        
+        def get_coin_address(coin, options: {})
+          options.merge!(authenticate: true)
+          response = parse(get("/account/#{coin}/wallet/address", options: options))&.fetch("data", {})
+          ::Kucoin::Models::CoinAddress.new(response) if response
+        end
+        
+        def create_withdrawal(coin, amount:, address:, options: {})
+          options.merge!(authenticate: true)
+          parse(post("/account/#{coin}/withdraw/apply", data: {coin: coin, amount: amount, address: address}, options: options))
+        end
+        
+        def cancel_withdrawal(coin, transaction_id:, options: {})
+          options.merge!(authenticate: true)
+          parse(post("/account/#{coin}/withdraw/cancel", data: {txOid: transaction_id}, options: options))
+        end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/private/user.rb

@@ -0,0 +1,15 @@
+module Kucoin
+  module Rest
+    module Private
+      module User
+        
+        def user_info(options: {})
+          options.merge!(authenticate: true)
+          response = parse(get("/user/info", options: options))&.fetch("data", {})
+          ::Kucoin::Models::User.new(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/public/currencies.rb

@@ -0,0 +1,13 @@
+module Kucoin
+  module Rest
+    module Public
+      module Currencies
+        
+        def exchange_rates(options: {})
+          parse(get("/open/currencies", options: options))&.dig("data", "rates")
+        end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/public/klines.rb

@@ -0,0 +1,85 @@
+module Kucoin
+  module Rest
+    module Public
+      module Klines
+        
+        # Not working propely / not implemented?
+        def kline_data(symbol, type: :one_hour, from: nil, to: nil, limit: 100, options: {})
+          to      ||=   Time.now.utc
+          from    ||=   default_from_time(type, to)
+          from      =   from.to_i unless from.is_a?(Integer)
+          to        =   to.to_i   unless to.is_a?(Integer)
+          
+          type      =   ::Kucoin::Constants::STANDARD_KLINE_RESOLUTIONS[type]
+          
+          params    =   {
+            symbol: symbol,
+            type:   type,
+            from:   from,
+            to:     to,
+            limit:  limit
+          }
+          
+          params.delete_if { |key, value| value.nil? }
+          
+          response  = parse(get("/open/kline", params: params, options: options))&.fetch("data", {})
+        end
+        
+        #
+        # TradingView related endpoints: 
+        # 
+        def kline_config(options: {})
+          parse(get("/open/chart/config", options: options))
+        end
+        
+        def chart_symbol(symbol, options: {})
+          response    =   parse(get("/open/chart/symbols", params: {symbol: symbol}, options: options))
+        end
+        
+        def chart_kline_data(symbol, resolution: :one_hour, from: nil, to: nil, options: {})
+          to        ||=   Time.now.utc
+          from      ||=   default_from_time(resolution, to)
+          from        =   from.to_i unless from.is_a?(Integer)
+          to          =   to.to_i   unless to.is_a?(Integer)
+          
+          resolution  =   ::Kucoin::Constants::TRADING_VIEW_KLINE_RESOLUTIONS[resolution]
+          
+          params    =   {
+            symbol:       symbol,
+            resolution:   resolution,
+            from:         from,
+            to:           to
+          }
+          
+          params.delete_if { |key, value| value.nil? }
+          
+          response    =   parse(get("/open/chart/history", params: params, options: options))
+          ::Kucoin::Models::OHLCV.parse(response) if response
+        end
+        
+        private
+          def default_from_time(type, time = Time.now.utc)
+            case type
+              when :one_minute
+                time - (1 * ::Kucoin::Constants::IN_SECONDS[:minute])
+              when :five_minutes
+                time - (5 * ::Kucoin::Constants::IN_SECONDS[:minute])
+              when :fifteen_minutes
+                time - (15 * ::Kucoin::Constants::IN_SECONDS[:minute])
+              when :thirty_minutes
+                time - (30 * ::Kucoin::Constants::IN_SECONDS[:minute])
+              when :one_hour
+                time - (1 * ::Kucoin::Constants::IN_SECONDS[:hour])
+              when :eight_hours
+                time - (8 * ::Kucoin::Constants::IN_SECONDS[:hour])
+              when :one_day
+                time - (1 * ::Kucoin::Constants::IN_SECONDS[:day])
+              when :one_week
+                time - (1 * ::Kucoin::Constants::IN_SECONDS[:week])
+            end
+          end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/public/languages.rb

@@ -0,0 +1,13 @@
+module Kucoin
+  module Rest
+    module Public
+      module Languages
+        
+        def languages(options: {})
+          parse(get("/open/lang-list", options: options))&.fetch("data", [])
+        end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/public/markets.rb

@@ -0,0 +1,33 @@
+module Kucoin
+  module Rest
+    module Public
+      module Markets
+        
+        def markets(options: {})
+          parse(get("/open/markets", options: options))&.fetch("data", {})
+        end
+        
+        # /market/open/symbols is also available, seems to be the same endpoint
+        def market_symbols(market, options: {})
+          response    =   parse(get("/open/symbols", params: {market: market}, options: options))&.fetch("data", {})
+          ::Kucoin::Models::Ticker.parse(response) if response
+        end
+        
+        def trending_symbols(market, options: {})
+          response    =   parse(get("/market/open/coins-trending", params: {market: market}, options: options))&.fetch("data", {})
+        end
+        
+        def coins(options: {})
+          response    =   parse(get("/market/open/coins", options: options))&.fetch("data", {})
+          ::Kucoin::Models::Coin.parse(response) if response
+        end
+        
+        def coin_info(coin, options: {})
+          response    =   parse(get("/market/open/coin-info", params: {coin: coin}, options: options))&.fetch("data", {})
+          ::Kucoin::Models::Coin.new(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/kucoin/rest/public/orders.rb

@@ -0,0 +1,39 @@
+module Kucoin
+  module Rest
+    module Public
+      module Orders
+        
+        def orders(symbol, limit: 100, group: nil, options: {})
+          get_orders(symbol: symbol, endpoint: "/open/orders", params: order_params(symbol, group, limit), type: nil, options: options)
+        end
+        
+        def buy_orders(symbol, limit: 100, group: nil, options: {})
+          get_orders(symbol: symbol, endpoint: "/open/orders-buy", params: order_params(symbol, group, limit), type: "BUY", options: options)
+        end
+        
+        def sell_orders(symbol, limit: 100, group: nil, options: {})
+          get_orders(symbol: symbol, endpoint: "/open/orders-sell", params: order_params(symbol, group, limit), type: "SELL", options: options)
+        end
+        
+        private
+          def get_orders(symbol:, endpoint:, params: {}, type: nil, options: {})
+            response = parse(get(endpoint, params: params, options: options))&.merge("symbol" => symbol)
+            ::Kucoin::Models::OrderBook.new(response, type: type) if response
+          end
+          
+          def order_params(symbol, group = nil, limit = nil)
+            params          =   {
+              symbol: symbol,
+              group:  group,
+              limit:  limit
+            }
+            
+            params.delete_if { |key, value| value.nil? }
+          
+            return params
+          end
+      
+      end
+    end
+  end
+end