binance-ruby 0.6.4 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e74c503800c58d470ef98deb95f32629f9954938dd64945dff998b50651d2733
-  data.tar.gz: 5a7977d1840a0a710bdbd825934b4fbb7ed991dba686f7c8aa4aa8251a0722aa
+  metadata.gz: 6fb6c0237f378f2045f7db5cc48929886a39445e0ecf54afe0bb864df84792c3
+  data.tar.gz: 05db158fd488361b4b735b79201265e43b693eeb5d1c723e16cd9f8b0533ef1c
 SHA512:
-  metadata.gz: ea8fe1a34c96744a54e1e67aa589e336fb63ca843ce7e7b6c6d65e14e8a3142f9fdf523ff3df311c5ad1bd483ec26bb0dbb874abd5a2054af0dbafc970fce112
-  data.tar.gz: e39a5fe7430cd9055400eb4886a07e3ce679327af63ba2f03739c100fb9e00b29a344a2a06c7e7aaf357d84480c669072f923c30eb3c5d6c66d9aaa9d3856305
+  metadata.gz: 4e18e6e9058a1c885c255eea4e64dd0eb099ecc28b2ef92666e666cad7504d81b12557e9115b27d9232bd68e798511dcf447a6b8dc680d9a6d920b2ba36131cd
+  data.tar.gz: e73a00ff633073200642377ddb9555b20864b45ed46e9245501d8e010c50351785344922b9a0c9e7d32fbcac8bb00ded7ce552a43ec8c64984511457b00b2eae

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

@@ -9,9 +9,8 @@ module Binance
           :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"]
+          raise Error.new(message: "invalid api_key type: #{type}.") unless type.nil? || api_key_types.include?(type)
+          instance_api_key(type: type) || ENV["BINANCE_#{type.to_s.humanize.upcase}_API_KEY"] || ENV["BINANCE_API_KEY"]
         end
 
         def tld
@@ -24,11 +23,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

@@ -8,6 +8,53 @@ module Binance
         def is_error_response?(response:)
           response.code >= 400
         end
+
+        # https://github.com/binance/binance-spot-api-docs/blob/master/errors.md
+        def localized(message)
+          code = message.to_s.match(/\d+/).to_s.to_i
+          case code
+          when 1000 then Unknown
+          when 1001 then Disconnected
+          when 1002 then Unauthorized
+          when 1003 then TooManyRequests
+          when 1006 then UnexpectedResponse
+          when 1007 then Timeout
+          when 1014 then UnknownOrderComposition
+          when 1015 then TooManyOrders
+          when 1016 then ServiceShuttingDown
+          when 1020 then UnsupportedOperation
+          when 1021 then InvalidTimestamp
+          when 1022 then InvalidSignature
+          when 1100 then IllegalChars
+          when 1101 then TooManyParameters
+          when 1102 then MandatoryParamEmptyOrMalformed
+          when 1103 then UnknownParam
+          when 1104 then UnreadParameters
+          when 1105 then ParamEmpty
+          when 1106 then ParamNotRequired
+          when 1111 then BadPrecision
+          when 1112 then NoDepth
+          when 1114 then TIFNotRequired
+          when 1115 then InvalidTIF
+          when 1116 then InvalidOrderType
+          when 1117 then InvalidSide
+          when 1118 then EmptyNewCLOrderId
+          when 1119 then EmptyOrgCLOrderId
+          when 1120 then BadInterval
+          when 1121 then BadSymbol
+          when 1125 then InvalidListenKey
+          when 1127 then IntervalTooLarge
+          when 1128 then OptionalParamsBadCombo
+          when 1130 then InvalidParameter
+          when 2010 then NewOrderRejected
+          when 2011 then CancelOrderRejected
+          when 2013 then NoSuchOrder
+          when 2014 then BadAPIKeyFormat
+          when 2015 then RejectedAPIKey
+          when 2016 then NoTradingWindow
+          else Binance::Api::Error
+          end
+        end
       end
 
       def initialize(code: nil, json: {}, message: nil, symbol: nil)
@@ -19,6 +66,7 @@ module Binance
       def inspect
         message = ""
         message += "(#{code}) " unless code.nil?
+        message += "@#{symbol} " unless symbol.nil?
         message += "#{msg}" unless msg.nil?
       end
 
@@ -29,6 +77,46 @@ module Binance
       def to_s
         inspect
       end
+
+      class Unknown < Error; end
+      class Disconnected < Error; end
+      class Unauthorized < Error; end
+      class TooManyRequests < Error; end
+      class UnexpectedResponse < Error; end
+      class Timeout < Error; end
+      class UnknownOrderComposition < Error; end
+      class TooManyOrders < Error; end
+      class ServiceShuttingDown < Error; end
+      class UnsupportedOperation < Error; end
+      class InvalidTimestamp < Error; end
+      class InvalidSignature < Error; end
+      class IllegalChars < Error; end
+      class TooManyParameters < Error; end
+      class MandatoryParamEmptyOrMalformed < Error; end
+      class UnknownParam < Error; end
+      class UnreadParameters < Error; end
+      class ParamEmpty < Error; end
+      class ParamNotRequired < Error; end
+      class BadPrecision < Error; end
+      class NoDepth < Error; end
+      class TIFNotRequired < Error; end
+      class InvalidTIF < Error; end
+      class InvalidOrderType < Error; end
+      class InvalidSide < Error; end
+      class EmptyNewCLOrderId < Error; end
+      class EmptyOrgCLOrderId < Error; end
+      class BadInterval < Error; end
+      class BadSymbol < Error; end
+      class InvalidListenKey < Error; end
+      class IntervalTooLarge < Error; end
+      class OptionalParamsBadCombo < Error; end
+      class InvalidParameter < Error; end
+      class NewOrderRejected < Error; end
+      class CancelOrderRejected < Error; end
+      class NoSuchOrder < Error; end
+      class BadAPIKeyFormat < Error; end
+      class RejectedAPIKey < Error; end
+      class NoTradingWindow < Error; end
     end
   end
 end

data/lib/binance/api/margin.rb

@@ -4,7 +4,7 @@ module Binance
       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)
+        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,
@@ -12,10 +12,11 @@ module Binance
           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)
+                        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)
+        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,
@@ -23,7 +24,8 @@ module Binance
           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)
+                        params: params, security_type: :margin, tld: Configuration.tld,
+                        api_key: api_key, api_secret_key: api_secret_key)
         end
 
         private

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

@@ -3,7 +3,7 @@ module Binance
     module Margin
       class Account
         class << self
-          def transfer!(asset: nil, amount: nil, type: nil, recvWindow: nil)
+          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,
@@ -11,7 +11,8 @@ module Binance
             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)
+                          params: params, security_type: :margin, tld: Configuration.tld,
+                          api_key: api_key, api_secret_key: api_secret_key)
           end
 
           private

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

@@ -4,7 +4,7 @@ module Binance
       class Order
         class << self
           def cancel!(symbol: nil, isIsolated: false, orderId: nil, origClientOrderId: nil,
-                      newClientOrderId: nil, recvWindow: nil)
+                      newClientOrderId: nil, recvWindow: nil, api_key: nil, api_secret_key: nil)
             timestamp = Configuration.timestamp
             params = {
               symbol: symbol, isIsolated: isIsolated, orderId: orderId, origClientOrderId: origClientOrderId,
@@ -13,13 +13,14 @@ module Binance
             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)
+                          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,
@@ -31,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: :margin, tld: Configuration.tld)
+                          params: params, security_type: :margin, tld: Configuration.tld,
+                          api_key: api_key, api_secret_key: api_secret_key)
           end
 
           private

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,26 +32,29 @@ 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)
+                    price: nil, quantity: nil, quoteOrderQty: nil, recvWindow: nil, stopPrice: nil, symbol: nil,
+                    side: nil, type: nil, timeInForce: nil, test: false, api_key: nil, api_secret_key: nil)
           timestamp = Configuration.timestamp
           params = {
             icebergQty: icebergQuantity, newClientOrderId: newClientOrderId,
-            newOrderRespType: newOrderResponseType, price: price, quantity: quantity,
+            newOrderRespType: newOrderResponseType, price: price, quantity: quantity, quoteOrderQty: quoteOrderQty,
             recvWindow: recvWindow, stopPrice: stopPrice, symbol: symbol, side: side,
             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}"
           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
@@ -85,7 +92,7 @@ module Binance
         end
 
         def required_create_keys
-          [:symbol, :side, :type, :quantity, :timestamp].freeze
+          [:symbol, :side, :type, :timestamp].freeze
         end
       end
     end

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: Configuration.tld, 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,10 +30,10 @@ 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
 
@@ -43,7 +44,7 @@ module Binance
               # binance 500 errors are html format
               raise Error.new(message: error)
             end
-          raise Error.new(json: json) if Error.is_error_response?(response: response)
+          raise Error.localized(json[:code]).new(json: json) if Error.is_error_response?(response: response)
           json
         end
 
@@ -51,9 +52,9 @@ module Binance
           [: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.4"
+    VERSION = "1.1.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: binance-ruby
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 1.1.1
 platform: ruby
 authors:
 - Jake Peterson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-30 00:00:00.000000000 Z
+date: 2021-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
@@ -203,8 +203,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
-summary: binance-ruby-0.6.4
+summary: binance-ruby-1.1.1
 test_files: []