kucoin 0.1.0

data/lib/kucoin/constants.rb

@@ -0,0 +1,34 @@
+module Kucoin
+  module Constants
+    
+    IN_SECONDS = {
+      minute: 60,
+      hour:   3600,
+      day:    86400,
+      week:   604800
+    }
+    
+    STANDARD_KLINE_RESOLUTIONS = {
+      one_minute:      "1min",
+      five_minutes:    "5min",
+      fifteen_minutes: "15min",
+      thirty_minutes:  "30min",
+      one_hour:        "1hour",
+      eight_hours:     "8hour",
+      one_day:         "1day",
+      one_week:        "1week" 
+    }
+    
+    TRADING_VIEW_KLINE_RESOLUTIONS = {
+      one_minute:      "1",
+      five_minutes:    "5",
+      fifteen_minutes: "15",
+      thirty_minutes:  "30",
+      one_hour:        "60",
+      eight_hours:     "480",
+      one_day:         "D",
+      one_week:        "W"
+    }
+    
+  end
+end

data/lib/kucoin/errors.rb

@@ -0,0 +1,11 @@
+module Kucoin
+  module Errors
+    class Error < StandardError; end;
+    class ResponseError < Kucoin::Errors::Error; end;
+    
+    MAPPING = {
+      404 => -> { raise ::Kucoin::Errors::ResponseError.new("Endpoint couldn't be found. Make sure the endpoint you're calling is a supported KuCoin API Endpoint.") },
+    }
+    
+  end
+end

data/lib/kucoin/extensions/hash.rb

@@ -0,0 +1,27 @@
+class Hash
+  
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+  
+  def transform_keys
+    result = {}
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+  
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+  
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+  
+end

data/lib/kucoin/extensions/string.rb

@@ -0,0 +1,13 @@
+class String
+  
+  def underscore
+    word = self.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+  
+end

data/lib/kucoin/models/balance.rb

@@ -0,0 +1,13 @@
+module Kucoin
+  module Models
+    class Balance < Base
+      MAPPING  =   {
+        coin_type:          :string,
+        balance:            :float,
+        balance_str:        :string,
+        freeze_balance:     :float,
+        freeze_balance_str: :string
+      }
+    end
+  end
+end

data/lib/kucoin/models/base.rb

@@ -0,0 +1,26 @@
+module Kucoin
+  module Models
+    class Base
+      
+      def initialize(hash)
+        self.class::MAPPING.keys.each { |key| self.class.send(:attr_accessor, key) }
+        
+        hash.each do |key, value|
+          key             =     key.to_s.underscore.to_sym
+          type            =     self.class::MAPPING.fetch(key, nil)
+          value           =     value && type ? ::Kucoin::Utilities::Parsing.convert_value(value, type, use_ms_for_time: true) : value
+          self.send("#{key}=", value) if self.respond_to?(key)
+        end
+      end
+      
+      def attributes
+        Hash[instance_variables.map { |name| [name.to_s.gsub(/^@/, "").to_sym, instance_variable_get(name)] }]
+      end
+      
+      def self.parse(data)
+        data&.collect { |item| self.new(item) }
+      end
+      
+    end
+  end
+end

data/lib/kucoin/models/coin.rb

@@ -0,0 +1,20 @@
+module Kucoin
+  module Models
+    class Coin < Base
+      MAPPING  =   {
+        name:                 :string,
+        coin:                 :string,
+        info_url:             :string,
+        trade_precision:      :integer,
+        deposit_remart:       :string,
+        confirmation_count:   :integer,
+        withdraw_min_fee:     :float,
+        withdraw_min_amount:  :float,
+        withdraw_fee_rate:    :float,
+        withdraw_remart:      :string,
+        enable_withdraw:      :boolean,
+        enable_deposit:       :boolean
+      }
+    end
+  end
+end

data/lib/kucoin/models/coin_address.rb

@@ -0,0 +1,17 @@
+module Kucoin
+  module Models
+    class CoinAddress < Base
+      MAPPING  =   {
+        oid:                :string,
+        address:            :string,
+        context:            :string,
+        user_oid:           :string,
+        coin_type:          :string,
+        created_at:         :time,
+        deleted_at:         :time,
+        updated_at:         :time,
+        last_received_at:   :time
+      }
+    end
+  end
+end

data/lib/kucoin/models/deal.rb

@@ -0,0 +1,20 @@
+module Kucoin
+  module Models
+    class Deal < Base
+      MAPPING  =   {
+        oid:              :string,
+        order_oid:        :string,
+        coin_type:        :string,
+        coin_type_pair:   :string,
+        deal_direction:   :string,
+        direction:        :string,
+        deal_price:       :float,
+        amount:           :float,
+        deal_value:       :float,
+        fee:              :float,
+        fee_rate:         :float,
+        created_at:       :time
+      }
+    end
+  end
+end

data/lib/kucoin/models/ohlcv.rb

@@ -0,0 +1,35 @@
+module Kucoin
+  module Models
+    class OHLCV < Base
+      MAPPING   =   {
+        timestamp:  :time,
+        open:       :float,
+        high:       :float,
+        low:        :float,
+        close:      :float,
+        volume:     :float
+      }
+      
+      def self.parse(data)
+        ohlcvs      =   []
+        
+        timestamps  =   data.fetch("t", [])
+        opens       =   data.fetch("o", [])
+        highs       =   data.fetch("h", [])
+        lows        =   data.fetch("l", [])
+        closes      =   data.fetch("c", [])
+        volumes     =   data.fetch("v", [])
+        
+        if timestamps&.any? && opens&.any? && highs&.any? && lows&.any? && closes&.any? && volumes&.any?
+          timestamps.each_with_index do |timestamp, index|
+            item    =   {timestamp: timestamp, open: opens[index], high: highs[index], low: lows[index], close: closes[index], volume: volumes[index]}  
+            ohlcvs <<   ::Kucoin::Models::OHLCV.new(item)
+          end
+        end
+        
+        return ohlcvs
+      end
+      
+    end
+  end
+end

data/lib/kucoin/models/order_book.rb

@@ -0,0 +1,53 @@
+module Kucoin
+  module Models
+    class OrderBook
+      attr_accessor :symbol, :timestamp, :asks, :bids
+      
+      ARRAY_MAPPING         =   {
+        0 => :price,
+        1 => :amount,
+        2 => :volume
+      }
+      
+      def initialize(hash, type: :nil)
+        self.symbol         =   hash.fetch("symbol", nil)
+        self.timestamp      =   ::Kucoin::Utilities::Parsing.epoch_to_time(hash.fetch("timestamp", nil), ms: true) if hash.has_key?("timestamp") && !hash.fetch("timestamp", nil).to_s.empty?
+
+        self.bids           =   []
+        self.asks           =   []
+
+        process(hash.fetch("data", []), type: type)
+      end
+      
+      def process(data, type: nil)
+        pp data
+        
+        if data.is_a?(Hash)
+          ["BUY", "SELL"].each do |type|
+            process_orders(data.fetch(type.to_s, []), type: type)
+          end
+        elsif data.is_a?(Array)
+          process_orders(data, type: type)
+        end
+      end
+      
+      def process_orders(orders, type: "BUY")
+        orders.each do |item|
+          data              =   {}
+          
+          item.each_with_index do |value, index|
+            data[ARRAY_MAPPING[index]] = value
+          end
+          
+          case type
+            when "BUY"
+              self.bids << data
+            when "SELL"
+              self.asks << data
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/kucoin/models/ticker.rb

@@ -0,0 +1,24 @@
+module Kucoin
+  module Models
+    class Ticker < Base
+      MAPPING  =   {
+        coin_type:        :string,
+        trading:          :boolean,
+        symbol:           :string,
+        last_deal_price:  :float,
+        buy:              :float,
+        sell:             :float,
+        change:           :float,
+        coin_type_pair:   :string,
+        sort:             :integer,
+        fee_rate:         :float,
+        vol_value:        :float,
+        high:             :float,
+        datetime:         :time,
+        vol:              :float,
+        low:              :float,
+        change_rate:      :float
+      }
+    end
+  end
+end

data/lib/kucoin/models/trade.rb

@@ -0,0 +1,38 @@
+module Kucoin
+  module Models
+    class Trade < Base
+      ARRAY_MAPPING     =   {
+        0 => "timestamp",
+        1 => "order_type",
+        2 => "price",
+        3 => "amount",
+        4 => "volume"
+      }
+      
+      MAPPING           =   {
+        timestamp:  :time,
+        order_type: :string,
+        price:      :float,
+        amount:     :float,
+        volume:     :float,
+      }
+      
+      def self.parse(response)
+        trades              =   []
+        
+        response&.each do |item|
+          data              =   {}
+          
+          item.each_with_index do |value, index|
+            data[ARRAY_MAPPING[index]] = value
+          end
+          
+          trades << ::Kucoin::Models::Trade.new(data)
+        end
+        
+        return trades
+      end
+
+    end
+  end
+end

data/lib/kucoin/models/user.rb

@@ -0,0 +1,31 @@
+module Kucoin
+  module Models
+    class User < Base
+      MAPPING  =   {
+        oid:                        :string,
+        name:                       :string,
+        nickname:                   :string,
+        email:                      :string,
+        phone:                      :string,
+        referrer_code:              :string,
+        language:                   :string,
+        csrf:                       :string,
+        login_record:               :hash,
+        base_bonus_rate:            :float,
+        base_fee_rate:              :float,
+        credential_status:          :string,
+        currency:                   :string,
+        photo_credential_validated: :boolean,
+        video_validated:            :boolean,
+        has_credential:             :boolean,
+        phone_validated:            :boolean,
+        credential_validated:       :boolean,
+        google_two_fa_binding:      :boolean,
+        has_trade_password:         :boolean,
+        email_validated:            :boolean,
+        is_china_visitor:           :boolean,
+        is_suspend:                 :boolean
+      }
+    end
+  end
+end

data/lib/kucoin/rest/authentication.rb

@@ -0,0 +1,38 @@
+module Kucoin
+  module Rest
+    module Authentication
+      
+      def authenticate!(path, params)
+        data              =   sign_message(path, params)
+        
+        {
+          'KC-API-KEY'        =>  self.configuration.key,
+          'KC-API-NONCE'      =>  data[:nonce],
+          'KC-API-SIGNATURE'  =>  data[:signature],
+        }
+      end
+      
+      def nonce
+        (Time.now.to_f * 1000).to_i.to_s
+      end
+      
+      def sign_message(path, params = nil)
+        path              =   signature_path(path)
+        nonced            =   nonce
+        params            =   compose_params(params)
+        message           =   "#{path}/#{nonced}/#{params}"
+        signature         =   ::Kucoin::Utilities::Encoding.sign(message, secret: self.configuration.secret)
+        
+        return {nonce: nonced, signature: signature}
+      end
+      
+      def compose_params(params)
+        return params unless params.is_a? Hash
+        uri               =   Addressable::URI.new
+        uri.query_values  =   params
+        uri.query
+      end
+            
+    end
+  end  
+end

data/lib/kucoin/rest/client.rb

@@ -0,0 +1,99 @@
+module Kucoin
+  module Rest
+    class Client
+      attr_accessor :url, :configuration
+      
+      def initialize(configuration: ::Kucoin.configuration)
+        self.configuration    =   configuration
+        self.url              =   "#{self.configuration.api_url}/v#{self.configuration.api_version}"
+      end
+      
+      include ::Kucoin::Rest::Errors
+      include ::Kucoin::Rest::Authentication
+      
+      include ::Kucoin::Rest::Public::Currencies
+      include ::Kucoin::Rest::Public::Languages
+      include ::Kucoin::Rest::Public::Ticker
+      include ::Kucoin::Rest::Public::Orders
+      include ::Kucoin::Rest::Public::Trades
+      include ::Kucoin::Rest::Public::Markets
+      include ::Kucoin::Rest::Public::Klines
+      
+      include ::Kucoin::Rest::Private::User
+      include ::Kucoin::Rest::Private::Languages
+      include ::Kucoin::Rest::Private::Invitations
+      include ::Kucoin::Rest::Private::Transfers
+      include ::Kucoin::Rest::Private::Balances
+      include ::Kucoin::Rest::Private::Trading
+            
+      def configured?
+        !self.configuration.key.to_s.empty? && !self.configuration.secret.to_s.empty?
+      end
+
+      def check_credentials!
+        unless configured?
+          raise ::Kucoin::Errors::MissingConfigError.new("Kucoin gem hasn't been properly configured.")
+        end
+      end
+      
+      def to_uri(path)
+        "#{self.url}#{path}"
+      end
+      
+      def signature_path(path)
+        "/v#{self.configuration.api_version}#{path}"
+      end
+      
+      def parse(response)
+        error?(response)
+        response
+      end
+
+      def get(path, params: {}, options: {})
+        request path, method: :get, params: params, options: options
+      end
+
+      def post(path, params: {}, data: {}, options: {})
+        request path, method: :post, params: params, data: data, options: options
+      end
+
+      def request(path, method: :get, params: {}, data: {}, options: {})
+        should_auth   =   options.fetch(:authenticate, false)
+        user_agent    =   options.fetch(:user_agent, self.configuration.faraday.fetch(:user_agent, nil))
+        proxy         =   options.fetch(:proxy, nil)
+    
+        connection    =   Faraday.new(url: to_uri(path)) do |builder|
+          builder.headers["User-Agent"]       =   user_agent if !user_agent.to_s.empty?
+          builder.headers["Accept-Language"]  =   "en_EN"
+          
+          builder.headers.merge!(authenticate!(path, params)) if should_auth && method.eql?(:get)
+          builder.headers.merge!(authenticate!(path, data))   if should_auth && method.eql?(:post)
+          
+          builder.request  :url_encoded if method.eql?(:post)
+          builder.response :logger      if self.configuration.verbose_faraday?
+          builder.response :json
+      
+          if proxy
+            puts "[Kucoin::Rest::Client] - Will connect to Kucoin using proxy: #{proxy.inspect}" if self.configuration.verbose_faraday?
+            builder.proxy = proxy
+          end
+      
+          builder.adapter self.configuration.faraday.fetch(:adapter, :net_http)
+        end
+    
+        case method
+          when :get
+            connection.get do |request|
+              request.params  =   params if params && !params.empty?
+            end&.body
+          when :post
+            connection.post do |request|
+              request.body    =   data
+              request.params  =   params if params && !params.empty?
+            end&.body
+        end
+      end
+            
+    end
+  end  
+end