binance-ruby 0.6 → 0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9573431110b2ce6731230f3660f9023dbbea1064bff0c508072a4dc059c90d06
-  data.tar.gz: 0664dcff66ef95d5bdf96f8feb37d2f47fe00fc606d166df3c4846a63cee64b1
+  metadata.gz: e38e2e3ef1f8051d6ddda7a07dfee0e35de604ba8985861ef6041d0841e127b6
+  data.tar.gz: 9f147f98929be3d56108cc258c5533e9469ae153c0659faa0319358e63e0636d
 SHA512:
-  metadata.gz: 4da7aa59ff6987dff9690848fe48df6774370e194cc10ac1a33692b18dfe9a00c7e39ccda67d13c565c6fd5ae1f15b8f22e9c45e0c4e47be92e9a15740c98fce
-  data.tar.gz: a9ac599985d66f28656e11b609c50888ecaf93f9450f3cfddc33a6b6ba37913e650f9f98573db4b4e9bd9a50fae2c5c37155ad634c4d871ca62ab27fb7ed0af2
+  metadata.gz: 0c40157c4619143f0d83ab5fcfab5b63f1db7a561bbb2b5fa50dd6f2c572c7762be9bc5b81bad9824bdfb345e9ad52e9c0bad8edcb7e27474c52ff4cde473604
+  data.tar.gz: ef136e619f4042998197c29dc99a6072036b6169ec27843a97aeade71b7db2006ac287e9fe19d08b135bde867bd045aa788c2127683aaee8e36c039e60021067

data/lib/binance-ruby.rb

@@ -7,6 +7,8 @@ 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"

data/lib/binance/api.rb

@@ -2,64 +2,72 @@ module Binance
   module Api
     class << self
       # Valid limits:[5, 10, 20, 50, 100, 500, 1000]
-      def candlesticks!(endTime: nil, interval: nil, limit: 500, startTime: nil, symbol: nil)
+      def candlesticks!(endTime: nil, interval: nil, limit: 500, startTime: nil, symbol: nil, api_key: nil, api_secret_key: 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)
+        Request.send!(api_key_type: :read_info, path: "/api/v1/klines", params: params,
+                      api_key: api_key, api_secret_key: api_secret_key)
       end
 
-      def compressed_aggregate_trades!(endTime: nil, fromId: nil, limit: 500, startTime: nil, symbol: nil)
+      def compressed_aggregate_trades!(endTime: nil, fromId: nil, limit: 500, startTime: nil, symbol: nil, api_key: nil, api_secret_key: nil)
         raise Error.new(message: "symbol is required") unless symbol
         params = {
           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,
+                      api_key: api_key, api_secret_key: api_secret_key)
       end
 
-      def depth!(symbol: nil, limit: 100)
+      def depth!(symbol: nil, limit: 100, api_key: nil, api_secret_key: nil)
         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,
+                      api_key: api_key, api_secret_key: api_secret_key)
       end
 
-      def exchange_info!
-        Request.send!(api_key_type: :read_info, path: "/api/v1/exchangeInfo")
+      def exchange_info!(api_key: nil, api_secret_key: nil)
+        Request.send!(api_key_type: :read_info, path: "/api/v1/exchangeInfo",
+                      api_key: api_key, api_secret_key: api_secret_key)
       end
 
-      def historical_trades!(symbol: nil, limit: 500, fromId: nil)
+      def historical_trades!(symbol: nil, limit: 500, fromId: nil, api_key: nil, api_secret_key: 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, api_key: api_key, api_secret_key: api_secret_key)
       end
 
-      def info!(recvWindow: nil)
+      def info!(recvWindow: nil, api_key: nil, api_secret_key: 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,
+                      api_key: api_key, api_secret_key: api_secret_key)
       end
 
       def ping!
         Request.send!(path: "/api/v1/ping")
       end
 
-      def ticker!(symbol: nil, type: nil)
+      def ticker!(symbol: nil, type: nil, api_key: nil, api_secret_key: nil)
         ticker_type = type&.to_sym
         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 } : {}
-        Request.send!(api_key_type: :read_info, path: path, params: params)
+        Request.send!(api_key_type: :read_info, path: path, params: params,
+                      api_key: api_key, api_secret_key: api_secret_key)
       end
 
       def time!
         Request.send!(path: "/api/v1/time")
       end
 
-      def trades!(symbol: nil, limit: 500)
+      def trades!(symbol: nil, limit: 500, api_key: nil, api_secret_key: nil)
         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,
+                      api_key: api_key, api_secret_key: api_secret_key)
       end
 
       private

data/lib/binance/api/account.rb

@@ -2,30 +2,30 @@ module Binance
   module Api
     class Account
       class << self
-        def fees!(recvWindow: 5000)
+        def fees!(recvWindow: 5000, api_key: nil, api_secret_key: nil)
           timestamp = Configuration.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)
+                        security_type: :user_data, api_key: api_key, api_secret_key: api_secret_key)
         end
 
-        def info!(recvWindow: 5000)
+        def info!(recvWindow: 5000, api_key: nil, api_secret_key: nil)
           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)
+                        security_type: :user_data, api_key: api_key, api_secret_key: api_secret_key)
         end
 
-        def trades!(fromId: nil, limit: 500, recvWindow: 5000, symbol: nil)
+        def trades!(fromId: nil, limit: 500, recvWindow: 5000, symbol: nil, api_key: nil, api_secret_key: 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: 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)
+                        security_type: :user_data, api_key: api_key, api_secret_key: api_secret_key)
         end
       end
     end

data/lib/binance/api/configuration.rb

@@ -24,11 +24,11 @@ module Binance
           instance_variable_get("@secret_key") || ENV["BINANCE_SECRET_KEY"]
         end
 
-        def signed_request_signature(payload:)
+        def signed_request_signature(payload:, api_secret_key: nil)
           raise Error.new(message: "environment variable 'BINANCE_SECRET_KEY' is required " \
-                          "for signed requests.") unless secret_key
+                          "for signed requests.") unless api_secret_key || secret_key
           digest = OpenSSL::Digest::SHA256.new
-          OpenSSL::HMAC.hexdigest(digest, secret_key, payload)
+          OpenSSL::HMAC.hexdigest(digest, api_secret_key || secret_key, payload)
         end
 
         def timestamp

data/lib/binance/api/data_stream.rb

@@ -3,21 +3,22 @@ module Binance
     class DataStream
       class << self
         # It's recommended to send a ping about every 30 minutes.
-        def keepalive!(listen_key: nil)
+        def keepalive!(listen_key: nil, api_key: nil, api_secret_key: nil)
           raise Error.new(message: "listen_key is required") if listen_key.nil?
           Request.send!(api_key_type: :none, method: :put, path: "/api/v1/userDataStream",
                         params: { listenKey: listen_key }, security_type: :user_stream)
         end
 
-        def start!
+        def start!(api_key: nil, api_secret_key: nil)
           Request.send!(api_key_type: :none, method: :post, path: "/api/v1/userDataStream",
-                        security_type: :user_stream)
+                        security_type: :user_stream, api_key: api_key, api_secret_key: api_secret_key)
         end
 
-        def stop!(listen_key: nil)
+        def stop!(listen_key: nil, api_key: nil, api_secret_key: nil)
           raise Error.new(message: "listen_key is required") if listen_key.nil?
           Request.send!(api_key_type: :none, method: :delete, path: "/api/v1/userDataStream",
-                        params: { listenKey: listen_key }, security_type: :user_stream)
+                        params: { listenKey: listen_key }, security_type: :user_stream,
+                        api_key: api_key, api_secret_key: api_secret_key)
         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,45 @@
+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, api_key: nil, api_secret_key: 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,
+                        api_key: api_key, api_secret_key: api_secret_key)
+        end
+
+        def repay!(asset: nil, isIsolated: nil, amount: nil, recvWindow: nil, api_key: nil, api_secret_key: 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,
+                        api_key: api_key, api_secret_key: api_secret_key)
+        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,33 @@
+module Binance
+  module Api
+    module Margin
+      class Account
+        class << self
+          def transfer!(asset: nil, amount: nil, type: nil, recvWindow: nil, api_key: nil, api_secret_key: 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,
+                          api_key: api_key, api_secret_key: api_secret_key)
+          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

@@ -3,10 +3,24 @@ module Binance
     module Margin
       class Order
         class << self
+          def cancel!(symbol: nil, isIsolated: false, orderId: nil, origClientOrderId: nil,
+                      newClientOrderId: nil, recvWindow: nil, api_key: nil, api_secret_key: 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,
+                          api_key: api_key, api_secret_key: api_secret_key)
+          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)
+                      recvWindow: nil, api_key: nil, api_secret_key: nil)
             timestamp = Configuration.timestamp
             params = {
               symbol: symbol, isIsolated: isIsolated, side: side, type: type,
@@ -18,7 +32,8 @@ module Binance
             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)
+                          params: params, security_type: :margin, tld: Configuration.tld,
+                          api_key: api_key, api_secret_key: api_secret_key)
           end
 
           private
@@ -47,6 +62,16 @@ module Binance
           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

data/lib/binance/api/order.rb

@@ -2,25 +2,28 @@ module Binance
   module Api
     class Order
       class << self
-        def all!(limit: 500, orderId: nil, recvWindow: 5000, symbol: nil)
+        def all!(limit: 500, orderId: nil, recvWindow: 5000, symbol: nil, api_key: nil, api_secret_key: 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: 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, tld: Configuration.tld)
+                        security_type: :user_data, tld: Configuration.tld, api_key: api_key,
+                        api_secret_key: api_secret_key)
         end
 
         # Be careful when accessing without a symbol!
-        def all_open!(recvWindow: 5000, symbol: nil)
+        def all_open!(recvWindow: 5000, symbol: nil, api_key: nil, api_secret_key: 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, tld: Configuration.tld)
+                        params: params, security_type: :user_data, tld: Configuration.tld, api_key: api_key,
+                        api_secret_key: api_secret_key)
         end
 
-        def cancel!(orderId: nil, originalClientOrderId: nil, newClientOrderId: nil, recvWindow: nil, symbol: nil)
+        def cancel!(orderId: nil, originalClientOrderId: nil, newClientOrderId: nil, recvWindow: nil, symbol: nil,
+                    api_key: nil, api_secret_key: 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?
@@ -29,12 +32,13 @@ module Binance
                      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, tld: Configuration.tld)
+                        params: params, security_type: :trade, tld: Configuration.tld, api_key: api_key,
+                        api_secret_key: api_secret_key)
         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)
+                    side: nil, type: nil, timeInForce: nil, test: false, api_key: nil, api_secret_key: nil)
           timestamp = Configuration.timestamp
           params = {
             icebergQty: icebergQuantity, newClientOrderId: newClientOrderId,
@@ -45,10 +49,12 @@ module Binance
           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, tld: Configuration.tld)
+                        params: params, security_type: :trade, tld: Configuration.tld, api_key: api_key,
+                        api_secret_key: api_secret_key)
         end
 
-        def status!(orderId: nil, originalClientOrderId: nil, recvWindow: nil, symbol: nil)
+        def status!(orderId: nil, originalClientOrderId: nil, recvWindow: nil, symbol: nil,
+                    api_key: nil, api_secret_key: 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?
@@ -58,7 +64,8 @@ module Binance
             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, tld: Configuration.tld)
+                        params: params, security_type: :user_data, tld: Configuration.tld, api_key: api_key,
+                        api_secret_key: api_secret_key)
         end
 
         private

data/lib/binance/api/request.rb

@@ -3,14 +3,15 @@ module Binance
     class Request
       include HTTParty
       class << self
-        def send!(api_key_type: :none, headers: {}, method: :get, path: "/", params: {}, security_type: :none, tld: :com)
+        def send!(api_key_type: :none, headers: {}, method: :get, path: "/", params: {}, security_type: :none, tld: :com, api_key: nil, api_secret_key: nil)
           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)
+          all_headers = default_headers(api_key_type: api_key_type, security_type: security_type, api_key: api_key)
           params.delete_if { |k, v| v.nil? }
-          params.merge!(signature: signed_request_signature(params: params)) if [:trade, :user_data].include?(security_type)
+          signature = signed_request_signature(params: params, api_secret_key: api_secret_key)
+          params.merge!(signature: signature) if [:trade, :user_data].include?(security_type)
           # send() is insecure so don't use it.
           case method
           when :get
@@ -29,26 +30,31 @@ module Binance
 
         private
 
-        def default_headers(api_key_type:, security_type:)
+        def default_headers(api_key_type:, security_type:, api_key: nil)
           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["X-MBX-APIKEY"] = (api_key || Configuration.api_key(type: api_key_type)) unless security_type == :none
           headers
         end
 
         def process!(response:)
-          json = JSON.parse(response.body, symbolize_names: true)
+          json = begin
+              JSON.parse(response.body, symbolize_names: true)
+            rescue JSON::ParserError => error
+              # binance 500 errors are html format
+              raise Error.new(message: error)
+            end
           raise Error.new(json: json) if Error.is_error_response?(response: response)
           json
         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:)
+        def signed_request_signature(params:, api_secret_key: nil)
           payload = params.map { |key, value| "#{key}=#{value}" }.join("&")
-          Configuration.signed_request_signature(payload: payload)
+          Configuration.signed_request_signature(payload: payload, api_secret_key: api_secret_key)
         end
       end
     end

data/lib/binance/api/version.rb

@@ -1,5 +1,5 @@
 module Binance
   module Api
-    VERSION = "0.6"
+    VERSION = "0.7"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: binance-ruby
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: '0.7'
 platform: ruby
 authors:
 - Jake Peterson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-04 00:00:00.000000000 Z
+date: 2021-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
@@ -177,6 +177,8 @@ 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
@@ -204,5 +206,5 @@ requirements: []
 rubygems_version: 3.0.8
 signing_key:
 specification_version: 4
-summary: binance-ruby-0.6
+summary: binance-ruby-0.7
 test_files: []