binance-ruby 0.1.9 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2fa97c211796ec21d0913bd6abdda560746f12ee
-  data.tar.gz: 5baaab69416897b39b2cf4a7f8fbb81a77aa243b
+SHA256:
+  metadata.gz: 9573431110b2ce6731230f3660f9023dbbea1064bff0c508072a4dc059c90d06
+  data.tar.gz: 0664dcff66ef95d5bdf96f8feb37d2f47fe00fc606d166df3c4846a63cee64b1
 SHA512:
-  metadata.gz: 27441435714dc55c72d1e5038721e7724a0fbda2bf1daf2bd866d8326ec0695cbc8ff11e5bab9774e34101e54fb9916d74202a5566ef7ddc6c6dd2045998b1eb
-  data.tar.gz: f0a0634dd09c3588b7ae52eac618a25bddf1be3b6d0506991a3d6e62f5ddeda259a16d17e0a503155e6dc3f68cb014bed4236e1f3426c00b8c795c7ddf0eb0eb
+  metadata.gz: 4da7aa59ff6987dff9690848fe48df6774370e194cc10ac1a33692b18dfe9a00c7e39ccda67d13c565c6fd5ae1f15b8f22e9c45e0c4e47be92e9a15740c98fce
+  data.tar.gz: a9ac599985d66f28656e11b609c50888ecaf93f9450f3cfddc33a6b6ba37913e650f9f98573db4b4e9bd9a50fae2c5c37155ad634c4d871ca62ab27fb7ed0af2

data/lib/binance-ruby.rb

@@ -1,12 +1,13 @@
-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/order"
+require "binance/api/order"
+require "binance/api/request"
 require "binance/api/version"

data/lib/binance/api.rb

@@ -2,50 +2,50 @@ module Binance
   module Api
     class << self
       # Valid limits:[5, 10, 20, 50, 100, 500, 1000]
-      def candlesticks!(end_time: nil, interval: nil, limit: 500, start_time: nil, symbol: nil)
-        raise Error.new(message: 'interval is required') unless interval
-        raise Error.new(message: 'symbol is required') unless symbol
-        params = { endTime: end_time, interval: interval, limit: limit, startTime: start_time, symbol: symbol }
-        Request.send!(api_key_type: :read_info, path: '/api/v1/klines', params: params)
+      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
+        params = { endTime: endTime, interval: interval, limit: limit, startTime: startTime, symbol: symbol }
+        Request.send!(api_key_type: :read_info, path: "/api/v1/klines", params: params)
       end
 
-      def compressed_aggregate_trades!(end_time: nil, from_id: nil, limit: 500, start_time: nil, symbol: nil)
+      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: end_time, fromId: from_id, limit: limit, startTime: start_time, 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, from_id: nil)
+      def historical_trades!(symbol: nil, limit: 500, fromId: nil)
         raise Error.new(message: "symbol is required") unless symbol
-        params = { fromId: from_id, limit: limit, symbol: symbol }
-        Request.send!(api_key_type: :read_info, path: '/api/v1/historicalTrades', params: params, security_type: :market_data)
+        params = { fromId: fromId, limit: limit, symbol: symbol }
+        Request.send!(api_key_type: :read_info, path: "/api/v1/historicalTrades", params: params, security_type: :market_data)
       end
 
-      def info!(recv_window: nil)
+      def info!(recvWindow: nil)
         timestamp = Configuration.timestamp
-        params = { recvWindow: recv_window, 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)
+        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)
       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,14 +67,14 @@ module Binance
       def ticker_path(type:)
         case type
         when :daily
-          '/api/v1/ticker/24hr'
-        when :price, :book_ticker
+          "/api/v1/ticker/24hr"
+        when :price, :bookTicker, :avgPrice
           "/api/v3/ticker/#{type.to_s.camelize(:lower)}"
         end
       end
 
       def ticker_types
-        [:daily, :price, :book_ticker].freeze
+        [:daily, :price, :bookTicker].freeze
       end
     end
   end

data/lib/binance/api/account.rb

@@ -2,19 +2,27 @@ module Binance
   module Api
     class Account
       class << self
-        def info!(recv_window: 5000)
+        def fees!(recvWindow: 5000)
           timestamp = Configuration.timestamp
-          params = { recvWindow: recv_window, timestamp: timestamp } 
+          params = { recvWindow: recvWindow, timestamp: timestamp }
+          Request.send!(api_key_type: :read_info, path: "/wapi/v3/assetDetail.html",
+                        params: params.delete_if { |key, value| value.nil? },
+            security_type: :user_data)
+        end
+
+        def info!(recvWindow: 5000)
+          timestamp = Configuration.timestamp
+          params = { recvWindow: recvWindow, timestamp: timestamp }
           Request.send!(api_key_type: :read_info, path: "/api/v3/account",
                         params: params.delete_if { |key, value| value.nil? },
                         security_type: :user_data)
         end
 
-        def trades!(from_id: nil, limit: 500, recv_window: 5000, symbol: nil)
+        def trades!(fromId: nil, limit: 500, recvWindow: 5000, symbol: nil)
           raise Error.new(message: "max limit is 500") unless limit <= 500
           raise Error.new(message: "symbol is required") if symbol.nil?
           timestamp = Configuration.timestamp
-          params = { fromId: from_id, limit: limit, recvWindow: recv_window, symbol: symbol, timestamp: timestamp }
+          params = { fromId: fromId, limit: limit, recvWindow: recvWindow, symbol: symbol, timestamp: timestamp }
           Request.send!(api_key_type: :read_info, path: "/api/v3/myTrades",
                         params: params.delete_if { |key, value| value.nil? },
                         security_type: :user_data)

data/lib/binance/api/configuration.rb

@@ -1,45 +1,60 @@
-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
     end
   end
 end

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

@@ -0,0 +1,54 @@
+module Binance
+  module Api
+    module Margin
+      class Order
+        class << self
+          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: :trade, 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
+        end
+      end
+    end
+  end
+end

data/lib/binance/api/order.rb

@@ -2,69 +2,63 @@ module Binance
   module Api
     class Order
       class << self
-        def all!(limit: 500, order_id: nil, recv_window: 5000, symbol: nil)
+        def all!(limit: 500, orderId: nil, recvWindow: 5000, symbol: nil)
           raise Error.new(message: "max limit is 500") unless limit <= 500
           raise Error.new(message: "symbol is required") if symbol.nil?
           timestamp = Configuration.timestamp
-          params = { limit: limit, orderId: order_id, recvWindow: recv_window, symbol: symbol, timestamp: timestamp }
+          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!(recv_window: 5000, symbol: nil)
+        def all_open!(recvWindow: 5000, symbol: nil)
           timestamp = Configuration.timestamp
-          params = { recvWindow: recv_window, symbol: symbol, timestamp: timestamp }
-          Request.send!(api_key_type: :read_info, path: '/api/v3/openOrders',
-                        params: params, security_type: :user_data)
+          params = { recvWindow: recvWindow, symbol: symbol, timestamp: timestamp }
+          Request.send!(api_key_type: :read_info, path: "/api/v3/openOrders",
+                        params: params, security_type: :user_data, tld: Configuration.tld)
         end
 
-        def cancel!(order_id: nil, original_client_order_id: nil, new_client_order_id: nil, recv_window: nil, symbol: nil)
+        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 order_id or original_client_order_id " \
-            "is required") if order_id.nil? && original_client_order_id.nil?
+          raise Error.new(message: "either orderid or originalclientorderid " \
+                          "is required") if orderId.nil? && originalClientOrderId.nil?
           timestamp = Configuration.timestamp
-          params = { orderId: order_id, origClientOrderId: original_client_order_id,
-                     newClientOrderId: new_client_order_id, recvWindow: recv_window,
+          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!(iceberg_quantity: nil, new_client_order_id: nil, new_order_response_type: nil,
-                    price: nil, quantity: nil, recv_window: nil, stop_price: nil, symbol: nil,
-                    side: nil, type: nil, time_in_force: nil, test: false)
+        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
-          ensure_required_create_keys!(params: {
-            iceberg_quantity: iceberg_quantity, new_client_order_id: new_client_order_id,
-            new_order_response_type: new_order_response_type, price: price,
-            quantity: quantity, recv_window: recv_window, stop_price: stop_price,
-            symbol: symbol, side: side, type: type, time_in_force: time_in_force,
-            timestamp: timestamp
-          })
-          params = { 
-            icebergQty: iceberg_quantity, newClientOrderId: new_client_order_id,
-            newOrderRespType: new_order_response_type, price: price, quantity: quantity,
-            recvWindow: recv_window, stopPrice: stop_price, symbol: symbol, side: side,
-            type: type, timeInForce: time_in_force, timestamp: timestamp
+          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,
           }.delete_if { |key, value| value.nil? }
-          path = "/api/v3/order#{'/test' if test}"
+          ensure_required_create_keys!(params: params)
+          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!(order_id: nil, original_client_order_id: nil, recv_window: nil, symbol: nil)
+        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 order_id or original_client_order_id " \
-            "is required") if order_id.nil? && original_client_order_id.nil?
+          raise Error.new(message: "either orderid or originalclientorderid " \
+                          "is required") if orderId.nil? && originalClientOrderId.nil?
           timestamp = Configuration.timestamp
           params = {
-            orderId: order_id, origClientOrderId: original_client_order_id, recvWindow: recv_window,
-            symbol: symbol, timestamp: timestamp
+            orderId: orderId, origClientOrderId: originalClientOrderId, recvWindow: recvWindow,
+            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
@@ -72,11 +66,11 @@ module Binance
         def additional_required_create_keys(type:)
           case type
           when :limit
-            [:price, :time_in_force].freeze
+            [:price, :timeInForce].freeze
           when :stop_loss, :take_profit
-            [:stop_price].freeze
+            [:stopPrice].freeze
           when :stop_loss_limit, :take_profit_limit
-            [:price, :stop_price, :time_in_force].freeze
+            [:price, :stopPrice, :timeInForce].freeze
           when :limit_maker
             [:price].freeze
           else
@@ -87,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
 
@@ -48,7 +47,7 @@ module Binance
         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.1.9"
+    VERSION = "0.6"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: binance-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: '0.6'
 platform: ruby
 authors:
 - Jake Peterson
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-02-05 00:00:00.000000000 Z
+date: 2021-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
@@ -95,19 +95,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '12.0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
-  type: :runtime
+        version: 0.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        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
@@ -149,6 +177,7 @@ files:
 - lib/binance/api/configuration.rb
 - lib/binance/api/data_stream.rb
 - lib/binance/api/error.rb
+- lib/binance/api/margin/order.rb
 - lib/binance/api/order.rb
 - lib/binance/api/request.rb
 - lib/binance/api/version.rb
@@ -157,7 +186,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -172,9 +201,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
-summary: binance-ruby-0.1.9
+summary: binance-ruby-0.6
 test_files: []