binance-ruby 0.4 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 187b7d39acf68364d1b7117bab98bcb580bfb7f771d9f8cc5e54108fc57545da
-  data.tar.gz: bbfd2f1b1dc3df0ad9be8a5c6aa7c18aea49b44f56ff1e72da6ebc4e6a24d5a9
+  metadata.gz: '09f5f77206284ebedb2a0f1d95e8c82c332362ad5c447244081c52447754da65'
+  data.tar.gz: 17ade78a7eaff0f6d8d4538cebde68877c4e0b6e6838f844068fefb3d60c5957
 SHA512:
-  metadata.gz: 77e1563be39775bc8dbfc21f349571a17a08b87e81262fc6f90dc2164445088ffdb47672ac61f750fb73f92c318654f6b0e5b6a742fce24c03b662b31a540ebb
-  data.tar.gz: 5524b974767756f2da4984c6d7dcdfafe1dbcd40a8b3781b8b7552c3cb070516061fef2821d6fd673bcebdff8be9999d5c8217159ac5c460d35a17fcb6b8c5c0
+  metadata.gz: ae97db01f0ca888aa4c0ff933455286934a0526cc19beeddd1ce23b992f884ae3ae6a4f3d2137f992b1dd4182ff2377bcec85bacdc02126926dea85d7546e259
+  data.tar.gz: 07d4309dc23201d4bb120353a14caece000904535297fdd15f07efcea2c854a9c0688ed9891cc420ee77b156780c91ac41862049596c682b6ea74389e81ede29

data/lib/binance-ruby.rb

@@ -1,12 +1,15 @@
-require 'active_support/core_ext/string'
-require 'awrence'
-require 'httparty'
+require "active_support/core_ext/string"
+require "awrence"
+require "httparty"
 
-require 'binance/api'
-require 'binance/api/account'
-require 'binance/api/configuration'
-require 'binance/api/data_stream'
-require 'binance/api/error'
-require 'binance/api/order'
-require 'binance/api/request'
+require "binance/api"
+require "binance/api/account"
+require "binance/api/configuration"
+require "binance/api/data_stream"
+require "binance/api/error"
+require "binance/api/margin"
+require "binance/api/margin/account"
+require "binance/api/margin/order"
+require "binance/api/order"
+require "binance/api/request"
 require "binance/api/version"

data/lib/binance/api.rb

@@ -3,49 +3,49 @@ module Binance
     class << self
       # Valid limits:[5, 10, 20, 50, 100, 500, 1000]
       def candlesticks!(endTime: nil, interval: nil, limit: 500, startTime: nil, symbol: nil)
-        raise Error.new(message: 'interval is required') unless interval
-        raise Error.new(message: 'symbol is required') unless symbol
+        raise Error.new(message: "interval is required") unless interval
+        raise Error.new(message: "symbol is required") unless symbol
         params = { endTime: endTime, interval: interval, limit: limit, startTime: startTime, symbol: symbol }
-        Request.send!(api_key_type: :read_info, path: '/api/v1/klines', params: params)
+        Request.send!(api_key_type: :read_info, path: "/api/v1/klines", params: params)
       end
 
       def compressed_aggregate_trades!(endTime: nil, fromId: nil, limit: 500, startTime: nil, symbol: nil)
         raise Error.new(message: "symbol is required") unless symbol
         params = {
-          endTime: endTime, fromId: fromId, limit: limit, startTime: startTime, symbol: symbol
+          endTime: endTime, fromId: fromId, limit: limit, startTime: startTime, symbol: symbol,
         }.delete_if { |key, value| value.nil? }
-        Request.send!(api_key_type: :read_info, path: '/api/v1/aggTrades', params: params)
+        Request.send!(api_key_type: :read_info, path: "/api/v1/aggTrades", params: params)
       end
 
       def depth!(symbol: nil, limit: 100)
         raise Error.new(message: "symbol is required") unless symbol
         params = { limit: limit, symbol: symbol }
-        Request.send!(api_key_type: :read_info, path: '/api/v1/depth', params: params)
+        Request.send!(api_key_type: :read_info, path: "/api/v1/depth", params: params)
       end
 
       def exchange_info!
-        Request.send!(api_key_type: :read_info, path: '/api/v1/exchangeInfo')
+        Request.send!(api_key_type: :read_info, path: "/api/v1/exchangeInfo")
       end
 
       def historical_trades!(symbol: nil, limit: 500, fromId: nil)
         raise Error.new(message: "symbol is required") unless symbol
         params = { fromId: fromId, limit: limit, symbol: symbol }
-        Request.send!(api_key_type: :read_info, path: '/api/v1/historicalTrades', params: params, security_type: :market_data)
+        Request.send!(api_key_type: :read_info, path: "/api/v1/historicalTrades", params: params, security_type: :market_data)
       end
 
       def info!(recvWindow: nil)
         timestamp = Configuration.timestamp
         params = { recvWindow: recvWindow, timestamp: timestamp }.delete_if { |key, value| value.nil? }
-        Request.send!(api_key_type: :read_info, path: '/api/v3/account', params: params, security_type: :user_data)
+        Request.send!(api_key_type: :read_info, path: "/api/v3/account", params: params, security_type: :user_data)
       end
 
       def ping!
-        Request.send!(path: '/api/v1/ping')
+        Request.send!(path: "/api/v1/ping")
       end
 
       def ticker!(symbol: nil, type: nil)
         ticker_type = type&.to_sym
-        error_message = "type must be one of: #{ticker_types.join(', ')}. #{type} was provided."
+        error_message = "type must be one of: #{ticker_types.join(", ")}. #{type} was provided."
         raise Error.new(message: error_message) unless ticker_types.include? ticker_type
         path = ticker_path(type: ticker_type)
         params = symbol ? { symbol: symbol } : {}
@@ -53,13 +53,13 @@ module Binance
       end
 
       def time!
-        Request.send!(path: '/api/v1/time')
+        Request.send!(path: "/api/v1/time")
       end
 
       def trades!(symbol: nil, limit: 500)
         raise Error.new(message: "symbol is required") unless symbol
         params = { limit: limit, symbol: symbol }
-        Request.send!(api_key_type: :read_info, path: '/api/v1/trades', params: params)
+        Request.send!(api_key_type: :read_info, path: "/api/v1/trades", params: params)
       end
 
       private
@@ -67,8 +67,8 @@ module Binance
       def ticker_path(type:)
         case type
         when :daily
-          '/api/v1/ticker/24hr'
-        when :price, :bookTicker
+          "/api/v1/ticker/24hr"
+        when :price, :bookTicker, :avgPrice
           "/api/v3/ticker/#{type.to_s.camelize(:lower)}"
         end
       end

data/lib/binance/api/configuration.rb

@@ -1,43 +1,58 @@
-require 'openssl'
-require 'base64'
+require "openssl"
+require "base64"
 
 module Binance
   module Api
     class Configuration
       class << self
-        attr_writer :api_key, :read_info_api_key, :trading_api_key, :withdrawals_api_key
-        attr_writer :secret_key
-        
+        attr_writer :api_key, :locale, :read_info_api_key, :secret_key,
+          :trading_api_key, :withdrawals_api_key
+
         def api_key(type: nil)
           raise Error.new(message: "invalid security_type type: #{type}.") unless type.nil? || api_key_types.include?(type)
           instance_api_key(type: type) || ENV["BINANCE_#{type.to_s.humanize.upcase}_API_KEY"] ||
-          instance_api_key             || ENV["BINANCE_API_KEY"]
+          instance_api_key || ENV["BINANCE_API_KEY"]
+        end
+
+        def tld
+          tld = ENV["BINANCE_TLD"]&.downcase&.to_sym || :com
+          validate_tld!(tld)
+          tld
         end
-        
+
         def secret_key
-          instance_variable_get("@secret_key") || ENV['BINANCE_SECRET_KEY']
+          instance_variable_get("@secret_key") || ENV["BINANCE_SECRET_KEY"]
         end
 
         def signed_request_signature(payload:)
           raise Error.new(message: "environment variable 'BINANCE_SECRET_KEY' is required " \
-            "for signed requests.") unless secret_key
+                          "for signed requests.") unless secret_key
           digest = OpenSSL::Digest::SHA256.new
           OpenSSL::HMAC.hexdigest(digest, secret_key, payload)
         end
 
         def timestamp
-          Time.now.utc.strftime('%s%3N')
+          Time.now.utc.strftime("%s%3N")
+        end
+
+        def validate_tld!(tld)
+          error_message = "Invalid tld (top-level-domain): #{tld}. Use one of: #{allowed_tlds.join(", ")}."
+          raise Error.new(message: error_message) unless allowed_tlds.include?(tld&.to_sym)
         end
 
         private
 
+        def allowed_tlds
+          [:com, :us]
+        end
+
         def api_key_types
           [:none, :read_info, :trading, :withdrawals].freeze
         end
 
         def instance_api_key(type: nil)
-          var = "#{type.to_s.downcase}_api_key".sub(/^\_/, '')
-          instance_variable_get('@' + var)
+          var = "#{type.to_s.downcase}_api_key".sub(/^\_/, "")
+          instance_variable_get("@" + var)
         end
       end
     end

data/lib/binance/api/error.rb

@@ -1,7 +1,7 @@
 module Binance
   module Api
     class Error < StandardError
-      attr_reader :code, :msg
+      attr_reader :code, :msg, :symbol
 
       class << self
         # https://github.com/binance-exchange/binance-official-api-docs/blob/master/errors.md
@@ -10,9 +10,10 @@ module Binance
         end
       end
 
-      def initialize(code: nil, json: {}, message: nil)
+      def initialize(code: nil, json: {}, message: nil, symbol: nil)
         @code = code || json[:code]
         @msg = message || json[:msg]
+        @symbol = message || json[:symbol]
       end
 
       def inspect

data/lib/binance/api/margin.rb

@@ -0,0 +1,43 @@
+module Binance
+  module Api
+    module Margin
+      class << self
+        # Your Margin Wallet balance determines the amount of funds you can borrow,
+        # following a fixed rate of 5:1 (5x).
+        def borrow!(asset: nil, amount: nil, recvWindow: nil)
+          timestamp = Configuration.timestamp
+          params = {
+            asset: asset, amount: amount, recvWindow: recvWindow, timestamp: timestamp,
+          }.delete_if { |_, value| value.nil? }
+          ensure_required_keys!(params: params)
+          path = "/sapi/v1/margin/loan"
+          Request.send!(api_key_type: :trading, method: :post, path: path,
+                        params: params, security_type: :margin, tld: Configuration.tld)
+        end
+
+        def repay!(asset: nil, isIsolated: nil, amount: nil, recvWindow: nil)
+          timestamp = Configuration.timestamp
+          params = {
+            asset: asset, amount: amount, recvWindow: recvWindow, timestamp: timestamp,
+          }.delete_if { |_, value| value.nil? }
+          ensure_required_keys!(params: params)
+          path = "/sapi/v1/margin/repay"
+          Request.send!(api_key_type: :trading, method: :post, path: path,
+                        params: params, security_type: :margin, tld: Configuration.tld)
+        end
+
+        private
+
+        def ensure_required_keys!(params:)
+          keys = required_margin_keys.dup
+          missing_keys = keys.select { |key| params[key].nil? }
+          raise Error.new(message: "required keys are missing: #{missing_keys.join(", ")}") unless missing_keys.empty?
+        end
+
+        def required_margin_keys
+          [:asset, :amount, :timestamp].freeze
+        end
+      end
+    end
+  end
+end

data/lib/binance/api/margin/account.rb

@@ -0,0 +1,32 @@
+module Binance
+  module Api
+    module Margin
+      class Account
+        class << self
+          def transfer!(asset: nil, amount: nil, type: nil, recvWindow: nil)
+            timestamp = Configuration.timestamp
+            params = {
+              asset: asset, amount: amount, type: type, recvWindow: recvWindow, timestamp: timestamp,
+            }.delete_if { |_, value| value.nil? }
+            ensure_required_create_keys!(params: params)
+            path = "/sapi/v1/margin/transfer"
+            Request.send!(api_key_type: :trading, method: :post, path: path,
+                          params: params, security_type: :margin, tld: Configuration.tld)
+          end
+
+          private
+
+          def ensure_required_create_keys!(params:)
+            keys = required_create_keys.dup
+            missing_keys = keys.select { |key| params[key].nil? }
+            raise Error.new(message: "required keys are missing: #{missing_keys.join(", ")}") unless missing_keys.empty?
+          end
+
+          def required_create_keys
+            [:asset, :amount, :type, :timestamp].freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/binance/api/margin/order.rb

@@ -0,0 +1,77 @@
+module Binance
+  module Api
+    module Margin
+      class Order
+        class << self
+          def cancel!(symbol: nil, isIsolated: false, orderId: nil, origClientOrderId: nil,
+                      newClientOrderId: nil, recvWindow: nil)
+            timestamp = Configuration.timestamp
+            params = {
+              symbol: symbol, isIsolated: isIsolated, orderId: orderId, origClientOrderId: origClientOrderId,
+              newClientOrderId: newClientOrderId, recvWindow: recvWindow, timestamp: timestamp,
+            }.delete_if { |_, value| value.nil? }
+            ensure_required_cancel_keys!(params: params)
+            path = "/sapi/v1/margin/order"
+            Request.send!(api_key_type: :trading, method: :delete, path: path,
+                          params: params, security_type: :margin, tld: Configuration.tld)
+          end
+
+          def create!(symbol: nil, isIsolated: false, side: nil, type: nil, quantity: nil,
+                      quoteOrderQty: nil, price: nil, stopPrice: nil, newClientOrderId: nil,
+                      icebergQty: nil, newOrderRespType: nil, sideEffectType: nil, timeInForce: nil,
+                      recvWindow: nil)
+            timestamp = Configuration.timestamp
+            params = {
+              symbol: symbol, isIsolated: isIsolated, side: side, type: type,
+              quantity: quantity, quoteOrderQty: quoteOrderQty, price: price,
+              stopPrice: stopPrice, newClientOrderId: newClientOrderId, icebergQty: icebergQty,
+              newOrderRespType: newOrderRespType, sideEffectType: sideEffectType,
+              timeInForce: timeInForce, recvWindow: recvWindow, timestamp: timestamp,
+            }.delete_if { |_, value| value.nil? }
+            ensure_required_create_keys!(params: params)
+            path = "/sapi/v1/margin/order"
+            Request.send!(api_key_type: :trading, method: :post, path: path,
+                          params: params, security_type: :margin, tld: Configuration.tld)
+          end
+
+          private
+
+          def additional_required_create_keys(type:)
+            case type
+            when :limit
+              [:price, :timeInForce].freeze
+            when :stop_loss, :take_profit
+              [:stopPrice].freeze
+            when :stop_loss_limit, :take_profit_limit
+              [:price, :stopPrice, :timeInForce].freeze
+            when :limit_maker
+              [:price].freeze
+            else
+              [].freeze
+            end
+          end
+
+          def ensure_required_create_keys!(params:)
+            keys = required_create_keys.dup.concat(additional_required_create_keys(type: params[:type]))
+            missing_keys = keys.select { |key| params[key].nil? }
+            raise Error.new(message: "required keys are missing: #{missing_keys.join(", ")}") unless missing_keys.empty?
+          end
+
+          def required_create_keys
+            [:symbol, :side, :type, :timestamp].freeze
+          end
+
+          def ensure_required_cancel_keys!(params:)
+            keys = required_cancel_keys.dup
+            missing_keys = keys.select { |key| params[key].nil? }
+            raise Error.new(message: "required keys are missing: #{missing_keys.join(", ")}") unless missing_keys.empty?
+          end
+
+          def required_cancel_keys
+            [:symbol, :timestamp].freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/binance/api/order.rb

@@ -9,56 +9,56 @@ module Binance
           params = { limit: limit, orderId: orderId, recvWindow: recvWindow, symbol: symbol, timestamp: timestamp }
           Request.send!(api_key_type: :read_info, path: "/api/v3/allOrders",
                         params: params.delete_if { |key, value| value.nil? },
-                        security_type: :user_data)
+                        security_type: :user_data, tld: Configuration.tld)
         end
 
         # Be careful when accessing without a symbol!
         def all_open!(recvWindow: 5000, symbol: nil)
           timestamp = Configuration.timestamp
           params = { recvWindow: recvWindow, symbol: symbol, timestamp: timestamp }
-          Request.send!(api_key_type: :read_info, path: '/api/v3/openOrders',
-                        params: params, security_type: :user_data)
+          Request.send!(api_key_type: :read_info, path: "/api/v3/openOrders",
+                        params: params, security_type: :user_data, tld: Configuration.tld)
         end
 
         def cancel!(orderId: nil, originalClientOrderId: nil, newClientOrderId: nil, recvWindow: nil, symbol: nil)
           raise Error.new(message: "symbol is required") if symbol.nil?
           raise Error.new(message: "either orderid or originalclientorderid " \
-            "is required") if orderId.nil? && originalClientOrderId.nil?
+                          "is required") if orderId.nil? && originalClientOrderId.nil?
           timestamp = Configuration.timestamp
           params = { orderId: orderId, origClientOrderId: originalClientOrderId,
                      newClientOrderId: newClientOrderId, recvWindow: recvWindow,
                      symbol: symbol, timestamp: timestamp }.delete_if { |key, value| value.nil? }
           Request.send!(api_key_type: :trading, method: :delete, path: "/api/v3/order",
-                        params: params, security_type: :trade)
+                        params: params, security_type: :trade, tld: Configuration.tld)
         end
 
         def create!(icebergQuantity: nil, newClientOrderId: nil, newOrderResponseType: nil,
                     price: nil, quantity: nil, recvWindow: nil, stopPrice: nil, symbol: nil,
                     side: nil, type: nil, timeInForce: nil, test: false)
           timestamp = Configuration.timestamp
-          params = { 
+          params = {
             icebergQty: icebergQuantity, newClientOrderId: newClientOrderId,
             newOrderRespType: newOrderResponseType, price: price, quantity: quantity,
             recvWindow: recvWindow, stopPrice: stopPrice, symbol: symbol, side: side,
-            type: type, timeInForce: timeInForce, timestamp: timestamp
+            type: type, timeInForce: timeInForce, timestamp: timestamp,
           }.delete_if { |key, value| value.nil? }
           ensure_required_create_keys!(params: params)
-          path = "/api/v3/order#{'/test' if test}"
+          path = "/api/v3/order#{"/test" if test}"
           Request.send!(api_key_type: :trading, method: :post, path: path,
-                        params: params, security_type: :trade)
+                        params: params, security_type: :trade, tld: Configuration.tld)
         end
 
         def status!(orderId: nil, originalClientOrderId: nil, recvWindow: nil, symbol: nil)
           raise Error.new(message: "symbol is required") if symbol.nil?
           raise Error.new(message: "either orderid or originalclientorderid " \
-            "is required") if orderId.nil? && originalClientOrderId.nil?
+                          "is required") if orderId.nil? && originalClientOrderId.nil?
           timestamp = Configuration.timestamp
           params = {
             orderId: orderId, origClientOrderId: originalClientOrderId, recvWindow: recvWindow,
-            symbol: symbol, timestamp: timestamp
+            symbol: symbol, timestamp: timestamp,
           }.delete_if { |key, value| value.nil? }
           Request.send!(api_key_type: :trading, path: "/api/v3/order",
-                        params: params, security_type: :user_data)
+                        params: params, security_type: :user_data, tld: Configuration.tld)
         end
 
         private
@@ -81,7 +81,7 @@ module Binance
         def ensure_required_create_keys!(params:)
           keys = required_create_keys.dup.concat(additional_required_create_keys(type: params[:type]))
           missing_keys = keys.select { |key| params[key].nil? }
-          raise Error.new(message: "required keys are missing: #{missing_keys.join(', ')}") unless missing_keys.empty?
+          raise Error.new(message: "required keys are missing: #{missing_keys.join(", ")}") unless missing_keys.empty?
         end
 
         def required_create_keys

data/lib/binance/api/request.rb

@@ -2,16 +2,15 @@ module Binance
   module Api
     class Request
       include HTTParty
-
-      base_uri 'https://api.binance.com'
-
       class << self
-        def send!(api_key_type: :none, headers: {}, method: :get, path: '/', params: {}, security_type: :none)
+        def send!(api_key_type: :none, headers: {}, method: :get, path: "/", params: {}, security_type: :none, tld: :com)
+          Configuration.validate_tld!(tld)
+          self.base_uri "https://api.binance.#{tld}"
+
           raise Error.new(message: "invalid security type #{security_type}") unless security_types.include?(security_type)
           all_headers = default_headers(api_key_type: api_key_type, security_type: security_type)
           params.delete_if { |k, v| v.nil? }
-          params.merge!(signature: signed_request_signature(params: params)) \
-            if [:trade, :user_data].include?(security_type)
+          params.merge!(signature: signed_request_signature(params: params)) if [:trade, :user_data].include?(security_type)
           # send() is insecure so don't use it.
           case method
           when :get
@@ -25,15 +24,15 @@ module Binance
           else
             raise Error.new(message: "invalid http method used: #{method}")
           end
-          process!(response: response || '{}')
+          process!(response: response || "{}")
         end
 
         private
 
         def default_headers(api_key_type:, security_type:)
           headers = {}
-          headers['Content-Type'] = 'application/json; charset=utf-8'
-          headers['X-MBX-APIKEY'] = Configuration.api_key(type: api_key_type) unless security_type == :none
+          headers["Content-Type"] = "application/json; charset=utf-8"
+          headers["X-MBX-APIKEY"] = Configuration.api_key(type: api_key_type) unless security_type == :none
           headers
         end
 
@@ -44,11 +43,11 @@ module Binance
         end
 
         def security_types
-          [:none, :trade, :user_data, :user_stream, :market_data].freeze
+          [:none, :trade, :user_data, :user_stream, :market_data, :margin].freeze
         end
 
         def signed_request_signature(params:)
-          payload = params.map { |key, value| "#{key}=#{value}" }.join('&')
+          payload = params.map { |key, value| "#{key}=#{value}" }.join("&")
           Configuration.signed_request_signature(payload: payload)
         end
       end

data/lib/binance/api/version.rb

@@ -1,5 +1,5 @@
 module Binance
   module Api
-    VERSION = "0.4"
+    VERSION = "0.6.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: binance-ruby
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: 0.6.3
 platform: ruby
 authors:
 - Jake Peterson
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-12-30 00:00:00.000000000 Z
+date: 2021-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
@@ -109,19 +109,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.11.3
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
-  type: :runtime
+        version: 0.20.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: 0.20.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
 - !ruby/object:Gem::Dependency
   name: awrence
   requirement: !ruby/object:Gem::Requirement
@@ -163,6 +177,9 @@ files:
 - lib/binance/api/configuration.rb
 - lib/binance/api/data_stream.rb
 - lib/binance/api/error.rb
+- lib/binance/api/margin.rb
+- lib/binance/api/margin/account.rb
+- lib/binance/api/margin/order.rb
 - lib/binance/api/order.rb
 - lib/binance/api/request.rb
 - lib/binance/api/version.rb
@@ -171,7 +188,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -186,8 +203,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
-summary: binance-ruby-0.4
+summary: binance-ruby-0.6.3
 test_files: []