binance-sdk 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d6b6fa1ee177c935d5342d2767c82c0c80d3c1befdebf4aaf4bf947fb5f01fbb
+  data.tar.gz: 3ea7bcadb01ef35b7d6c74b0849644efc4b5ea77f837a28150cdbbb3bbf0bbb4
+SHA512:
+  metadata.gz: 9194ed2de6be9c11529b762588d940d3ba88774c0ff05661b6332cdab111f831cd73c8835717baaeda7165f1bdb5868019a95ab6f8fb9d44e0658d98f2a3aaf9
+  data.tar.gz: 62ed6aed957dad77dfd65f734221c79c6fc80713a0142657ffbbad4e2da296e24e1a25ae3f36992c3f3c96b938083355c395d7bf3f5e5b7417a1d974a0e7a068

data/lib/binance/sdk/account.rb

@@ -0,0 +1,58 @@
+module Binance
+  module SDK
+    class Account
+      class << self
+        def info!(recvWindow: 5000)
+          timestamp = Configuration.timestamp
+
+          params = { recvWindow: recvWindow, timestamp: timestamp }
+
+          response = Request.send!(
+            api_key_type: :read_info, path: "/sapi/v1/account/status",
+            params: params.delete_if { |key, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+
+          puts response
+        end
+
+        def balance!(recvWindow: 5000, currency: 'USDT')
+          timestamp = Configuration.timestamp
+
+          params = { recvWindow: recvWindow, timestamp: timestamp }
+
+          balance = Request.send!(
+            api_key_type: :read_info, path: Endpoints.fetch(:account_balance),
+            params: params.delete_if { |key, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+
+          if futures?
+            balance.find { |i| i[:asset] == currency }[:balance].to_f
+          else
+            balance[:balances].find { |i| i[:asset] == currency }[:free]
+          end
+        end
+
+        def positions
+          params = {
+            recvWindow: 60000,
+            timestamp: Configuration.timestamp
+          }
+
+          Request.send!(
+            api_key_type: :read_info, path: Endpoints.fetch(:account_position_risk),
+            params: params.delete_if { |key, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+
+        private
+
+        def futures?
+          Configuration.futures?
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/asset.rb

@@ -0,0 +1,24 @@
+module Binance
+  module SDK
+    class Asset
+      class << self
+        def change_margin_type(symbol:, type: 'ISOLATED')
+           params = {
+              recvWindow: 60000,
+              timestamp: Configuration.timestamp.to_i - 1000,
+              symbol: symbol,
+              marginType: type
+           }
+
+           Request.send!(
+            method: :post,
+            api_key_type: :read_info, path: Endpoints.fetch(:margin_type),
+            params: params.delete_if { |_, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        rescue Binance::SDK::Error::NoNeedToChangeMarginType
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/configuration.rb

@@ -0,0 +1,66 @@
+module Binance
+  module SDK
+    class Configuration
+      class << self
+        attr_writer :api_key, :locale, :read_info_api_key, :secret_key, :trading_api_key, :withdrawals_api_key, :futures, :testnet
+
+        def api_key(type: nil)
+          raise Error.new(message: "Invalid api_key type: #{type}.") unless type.nil? || API_KEY_TYPES.include?(type)
+
+          instance_api_key(type: type)
+        end
+
+        def secret_key
+          instance_variable_get("@secret_key") ||  ENV["BINANCE_SECRET_KEY"]
+        end
+
+        def futures?
+          (instance_variable_get("@futures") || ENV["BINANCE_FUTURES"]) == true
+        end
+
+        def spot?
+          !futures?
+        end
+
+        def testnet?
+          (instance_variable_get("@testnet") || ENV["BINANCE_TESTNET"]) == true
+        end
+
+        def signed_request_signature(payload:, api_secret_key: nil)
+          raise Error.new(message: "Environment variable 'BINANCE_SECRET_KEY' is required for signed requests.") unless api_secret_key || secret_key
+
+          digest = OpenSSL::Digest::SHA256.new
+          OpenSSL::HMAC.hexdigest(digest, api_secret_key || secret_key, payload)
+        end
+
+        def tld
+          tld = ENV["BINANCE_TLD"]&.downcase&.to_sym || :com
+          validate_tld!(tld)
+
+          tld
+        end
+
+        def timestamp
+          Time.now.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
+
+        API_KEY_TYPES = [:none, :read_info, :trading, :withdrawals].freeze
+        ALLOWED_TLDS = [:com, :us].freeze
+
+        def instance_api_key(type: nil)
+          var = "#{type.to_s.downcase}_api_key".sub(/^\_/, "")
+
+          instance_variable_get("@#{var}")
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/endpoints.rb

@@ -0,0 +1,43 @@
+module Binance
+  module SDK
+    class Endpoints
+      class << self
+        def fetch(identifier)
+          Configuration.futures? ? future_endpoints[identifier] : spot_endpoints[identifier]
+        end
+
+        private
+
+        def future_endpoints
+          {
+            server_time: '/fapi/v1/time',
+            account_balance: '/fapi/v2/balance',
+            account_position_risk: '/fapi/v2/positionRisk',
+            exchange_info: '/fapi/v1/exchangeInfo',
+            klines: '/fapi/v1/klines',
+            put_order: '/fapi/v1/order',
+            cancel_orders: '/fapi/v1/allOpenOrders',
+            ticker_price: '/fapi/v1/ticker/price',
+            change_leverage: '/fapi/v1/leverage',
+            long_short_ratio: '/futures/data/globalLongShortAccountRatio',
+            taker_buy_sell_volume: '/futures/data/takerlongshortRatio',
+            margin_type: '/fapi/v1/marginType'
+          }
+        end
+
+        def spot_endpoints
+          {
+            server_time: '/sapi/v1/time',
+            account_balance: '/sapi/v2/balance',
+            account_position_risk: '/sapi/v2/positionRisk',
+            exchange_info: '/sapi/v1/exchangeInfo',
+            klines: '/sapi/v1/klines',
+            put_order: '/sapi/v1/order',
+            cancel_orders: '/sapi/v1/allOpenOrders',
+            ticker_price: '/sapi/v1/ticker/price',
+          }
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/error.rb

@@ -0,0 +1,138 @@
+module Binance
+  module SDK
+    class Error < StandardError
+      attr_reader :code, :msg, :symbol
+
+      class << self
+        def is_error_response?(response:)
+          response.code >= 400
+        end
+
+        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 1013 then InvalidQuantity
+          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 2007 then InvalidCallbackRate
+          when 2010 then NewOrderRejected
+          when 2011 then CancelOrderRejected
+          when 2013 then NoSuchOrder
+          when 2014 then BadAPIKeyFormat
+          when 2015 then RejectedAPIKey
+          when 2016 then NoTradingWindow
+          when -1021 then TimestampOutsideRecvWindow
+          when -4131 then CounterPartyBestPrice
+          when -4005 then QuantityGreaterThanMaxQuantity
+          when -1117 then InvalidSide
+          when -4046 then NoNeedToChangeMarginType
+          when -4061 then IncorrectOrderPositionSide
+          when -1120 then InvalidInterval
+          else Binance::SDK::Error
+          end
+        end
+      end
+
+      def initialize(code: nil, json: {}, message: nil, symbol: nil)
+        @code   = code || json[:code]
+        @msg    = message || json[:message]
+        @symbol = message || json[:symbol]
+      end
+
+      def inspect
+        message = ""
+
+        message += "(#{code}) "  unless code.nil?
+        message += "@#{symbol} " unless symbol.nil?
+        message += "#{msg}"      unless msg.nil?
+      end
+
+      def message
+        inspect
+      end
+
+      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 InvalidQuantity < 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
+      class CounterPartyBestPrice < Error; end
+      class InvalidCallbackRate < Error; end
+      class QuantityGreaterThanMaxQuantity < Error; end
+      class TimestampOutsideRecvWindow < Error; end
+      class NoNeedToChangeMarginType < Error; end
+      class IncorrectOrderPositionSide < Error; end
+      class InvalidInterval < Error; end
+    end
+  end
+end

data/lib/binance/sdk/exchange.rb

@@ -0,0 +1,39 @@
+module Binance
+  module SDK
+    class Exchange
+      class << self
+        def info!
+          timestamp = Configuration.timestamp
+
+          params = { recvWindow: 5000, timestamp: timestamp }
+
+          Request.send!(
+            api_key_type: :read_info, path: Endpoints.fetch(:exchange_info),
+            params: params.delete_if { |key, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+
+        def long_short_ratio(symbol:, period:, limit: 30)
+          params = { recvWindow: 5000, timestamp: Configuration.timestamp, symbol: symbol, period: period, limit: limit }
+
+          Request.send!(
+            api_key_type: :read_info, path: Endpoints.fetch(:long_short_ratio),
+            params: params.delete_if { |_, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+
+        def taker_buy_sell_volume(symbol:, period:, limit: 30)
+          params = { recvWindow: 5000, timestamp: Configuration.timestamp, symbol: symbol, period: period, limit: limit }
+
+          Request.send!(
+            api_key_type: :read_info, path: Endpoints.fetch(:taker_buy_sell_volume),
+            params: params.delete_if { |_, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/klines.rb

@@ -0,0 +1,45 @@
+module Binance
+  module SDK
+    class Klines
+      class << self
+        # [
+        #   [
+        #     1499040000000,      // Open time
+        #     "0.01634790",       // Open
+        #     "0.80000000",       // High
+        #     "0.01575800",       // Low
+        #     "0.01577100",       // Close
+        #     "148976.11427815",  // Volume
+        #     1499644799999,      // Close time
+        #     "2434.19055334",    // Quote asset volume
+        #     308,                // Number of trades
+        #     "1756.87402397",    // Taker buy base asset volume
+        #     "28.46694368",      // Taker buy quote asset volume
+        #     "17928899.62484339" // Ignore.
+        #   ]
+        # ]
+        def data(symbol, interval = '5m', start_time = nil, end_time = nil, limit = nil, recvWindow: 5000, force_float: false)
+          timestamp = Configuration.timestamp
+
+          params = {
+            recvWindow: recvWindow,
+            timestamp: timestamp,
+            symbol: symbol,
+            interval: interval,
+            startTime: start_time,
+            endTime: end_time,
+            limit: limit
+          }
+
+          response = Request.send!(
+            api_key_type: :read_info, path: Endpoints.fetch(:klines),
+            params: params.delete_if { |key, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+
+          force_float ? response.map! { |i| i.map(&:to_f) } : response
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/orders.rb

@@ -0,0 +1,111 @@
+module Binance
+  module SDK
+    class Orders
+      class << self
+        def put_order!(symbol:, type: 'TRAILING_STOP_MARKET', side: 'BUY', callback_rate: 4, quantity: 1.0, working_type: nil, position_side: 'BOTH')
+          params = {
+            recvWindow: 60000,
+            timestamp: Configuration.timestamp.to_i - 1000,
+            symbol: symbol,
+            side: side,
+            type: type,
+            quantity: quantity,
+            callbackRate: callback_rate,
+            workingType: working_type,
+            positionSide: position_side,
+          }
+
+          Request.send!(
+            method: :post,
+            api_key_type: :read_info, path: Endpoints.fetch(:put_order),
+            params: params.delete_if { |_, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+
+        def close_position!(symbol:, side:, quantity:)
+          params = {
+            recvWindow: 60000,
+            timestamp: Configuration.timestamp.to_i - 1000,
+            symbol: symbol,
+            side: side,
+            type: 'MARKET',
+            quantity: quantity,
+            positionSide: side,
+          }
+
+          Request.send!(
+            method: :post,
+            api_key_type: :read_info, path: Endpoints.fetch(:put_order),
+            params: params.delete_if { |_, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+
+        def stop_loss(symbol:, side:, stop_price:)
+          params = {
+            recvWindow: 60000,
+            timestamp: Configuration.timestamp.to_i - 1000,
+            symbol: symbol,
+            type: 'STOP',
+            side: side,
+            stopPrice: stop_price
+          }
+
+          Request.send!(
+            method: :post,
+            api_key_type: :read_info, path: Endpoints.fetch(:put_order),
+            params: params.delete_if { |_, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+
+        def cancel_order!(symbol:)
+          params = {
+            recvWindow: 60000,
+            timestamp: Configuration.timestamp.to_i - 1000,
+            symbol: symbol,
+            type: 'MARKET'
+          }
+
+          Request.send!(
+            method: :delete,
+            api_key_type: :read_info, path: Endpoints.fetch(:put_order),
+            params: params.delete_if { |_, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+
+        def cancel_orders!(symbol:)
+          params = {
+            recvWindow: 60000,
+            timestamp: Configuration.timestamp.to_i - 1000,
+            symbol: symbol
+          }
+
+          Request.send!(
+            method: :delete,
+            api_key_type: :read_info, path: Endpoints.fetch(:cancel_orders),
+            params: params.delete_if { |_, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+
+        def change_leverage(symbol:, leverage:)
+          params = {
+            symbol: symbol,
+            leverage: leverage.to_i,
+            timestamp: Configuration.timestamp
+          }
+
+          Request.send!(
+            method: :post,
+            api_key_type: :read_info, path: Endpoints.fetch(:change_leverage),
+            params: params,
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/request.rb

@@ -0,0 +1,81 @@
+module Binance
+  module SDK
+    class Request
+      include HTTParty
+
+      class << self
+        SECURITY_TYPES = [:none, :trade, :user_data, :user_stream, :market_data, :margin].freeze
+
+        def send!(api_key_type: :none, headers: {}, method: :get, path: "/", params: {}, security_type: :none, tld: Configuration.tld, api_key: nil, api_secret_key: nil, testnet: false, futures: false)
+          Configuration.validate_tld!(tld)
+
+          if Configuration.testnet?
+            self.base_uri 'https://testnet.binancefuture.com'
+          else
+            if Configuration.futures?
+              self.base_uri 'https://fapi.binance.com'
+            else
+              self.base_uri 'https://api.binance.com'
+            end
+          end
+
+          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, api_key: api_key)
+          params.delete_if { |k, v| v.nil? }
+
+          if %w(trade user_data).include?(security_type&.to_s)
+            signature = signed_request_signature(params: params, api_secret_key: api_secret_key)
+            params.merge!(signature: signature)
+          end
+
+          case method
+          when :get
+            response = get(path, headers: all_headers, query: params)
+          when :post
+            response = post(path, query: params, headers: all_headers)
+          when :put
+            response = put(path, query: params, headers: all_headers)
+          when :delete
+            response = delete(path, query: params, headers: all_headers)
+          else
+            raise Error.new(message: "invalid http method used: #{method}")
+          end
+
+          process!(response: response || "{}")
+        end
+
+        private
+
+        def default_headers(api_key_type:, security_type:, api_key: nil)
+          headers = {}
+          headers["Content-Type"] = "application/json; charset=utf-8"
+          headers["X-MBX-APIKEY"] = (api_key || Configuration.api_key(type: api_key_type)) unless security_type == :none
+          headers
+        end
+
+        def process!(response:)
+          json = begin
+              JSON.parse(response.body, symbolize_names: true)
+            rescue JSON::ParserError => error
+              # binance 500 errors are html format
+
+              raise Error.new(message: "Error: #{error}")
+            end
+          raise Error.localized(json[:code]).new(json: json) if Error.is_error_response?(response: response)
+          json
+        end
+
+        def signed_request_signature(params:, api_secret_key: nil)
+          payload = params.map { |key, value| "#{key}=#{value}" }.join("&")
+          Configuration.signed_request_signature(payload: payload, api_secret_key: api_secret_key)
+        end
+
+        def base_url
+          return 'https://testnet.binancefuture.com' if testnet?
+
+          'https://api.binance.com'
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/server.rb

@@ -0,0 +1,15 @@
+module Binance
+  module SDK
+    class Server
+      class << self
+        def time
+          Request.send!(
+            api_key_type: :read_info, path: Endpoints.fetch(:server_time),
+            params: {},
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/ticker.rb

@@ -0,0 +1,19 @@
+module Binance
+  module SDK
+    class Ticker
+      class << self
+        def price(symbol)
+          timestamp = Configuration.timestamp
+
+          params = { recvWindow: 5000, timestamp: timestamp, symbol: symbol }
+
+          Request.send!(
+            api_key_type: :read_info, path: Endpoints.fetch(:ticker_price),
+            params: params.delete_if { |_, value| value.nil? },
+            security_type: :user_data, api_key: Configuration.api_key, api_secret_key: Configuration.secret_key
+          )
+        end
+      end
+    end
+  end
+end

data/lib/binance/sdk/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Binance
+  module SDK
+    VERSION = "1.0.4"
+  end
+end

data/lib/binance/sdk/websocket.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Binance
+  class WebSocket < Faye::WebSocket::Client
+    class Error < StandardError; end
+
+    def initialize(on_open: nil, on_close: nil)
+      websocket_api_url = if SDK::Configuration.futures?
+              'wss://fstream.binance.com/stream'
+            else
+              'wss://stream.binance.com:9443/stream'
+            end
+      super websocket_api_url, nil, ping: 180
+
+      @request_id_inc = 0
+      @user_stream_handlers = {}
+
+      on :open do |event|
+        on_open&.call(event)
+      end
+
+      on :message do |event|
+        process_data(event.data)
+      end
+
+      on :close do |event|
+        on_close&.call(event)
+      end
+    end
+
+    # stream name: <symbol>@kline_<interval>
+    #
+    # {
+    #   "e": "kline",     // Event type
+    #   "E": 123456789,   // Event time
+    #   "s": "BTCUSDT",    // Symbol
+    #   "k": {
+    #     "t": 123400000, // Kline start time
+    #     "T": 123460000, // Kline close time
+    #     "s": "BTCUSDT",  // Symbol
+    #     "i": "1m",      // Interval
+    #     "f": 100,       // First trade ID
+    #     "L": 200,       // Last trade ID
+    #     "o": "0.0010",  // Open price
+    #     "c": "0.0020",  // Close price
+    #     "h": "0.0025",  // High price
+    #     "l": "0.0015",  // Low price
+    #     "v": "1000",    // Base asset volume
+    #     "n": 100,       // Number of trades
+    #     "x": false,     // Is this kline closed?
+    #     "q": "1.0000",  // Quote asset volume
+    #     "V": "500",     // Taker buy base asset volume
+    #     "Q": "0.500",   // Taker buy quote asset volume
+    #     "B": "123456"   // Ignore
+    #   }
+    # }
+
+    def candlesticks!(symbols, interval, &on_receive)
+      symbols_fmt = symbols.is_a?(String) ? [symbols] : symbols
+      @candlesticks_handler = on_receive
+      subscribe(symbols_fmt.map { |s| "#{s.downcase}@kline_#{interval}" })
+    end
+
+    def user_data_stream!(listen_key, &on_receive)
+      @user_stream_handlers[listen_key] = on_receive
+      subscribe([listen_key])
+    end
+
+    private
+
+    def process_data(data)
+      json = JSON.parse(data, symbolize_names: true)
+      if json[:error]
+        raise Error.new("(#{json[:code]}) #{json[:msg]}")
+      elsif json.key?(:result)
+        # Binance stream connected successfully
+      else
+        case json[:data][:e]&.to_sym
+        when :kline
+          @candlesticks_handler&.call(json[:stream], json[:data])
+        when :outboundAccountPosition
+        when :balanceUpdate
+        when :executionReport
+          listen_key = json[:stream]
+          @user_stream_handlers[listen_key]&.call(listen_key, json[:data])
+        end
+      end
+    end
+
+    def request_id
+      @request_id_inc += 1
+    end
+
+    def subscribe(streams)
+      send(
+        {
+          method: 'SUBSCRIBE',
+          params: streams,
+          id: request_id
+        }.to_json
+      )
+    end
+  end
+end

data/lib/binance-sdk.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'pry'
+require 'active_support/core_ext/string'
+require 'awrence'
+require 'httparty'
+require 'faye/websocket'
+require 'dry/inflector'
+
+Dry::Inflector.new do |inflections|
+  inflections.acronym 'SDK'
+end
+
+require_relative 'binance/sdk/version'
+require_relative 'binance/sdk/error'
+require_relative 'binance/sdk/configuration'
+require_relative 'binance/sdk/request'
+require_relative 'binance/sdk/endpoints'
+require_relative 'binance/sdk/account'
+require_relative 'binance/sdk/klines'
+require_relative 'binance/sdk/ticker'
+require_relative 'binance/sdk/exchange'
+require_relative 'binance/sdk/orders'
+require_relative 'binance/sdk/websocket'
+require_relative 'binance/sdk/asset'

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: binance-sdk
+version: !ruby/object:Gem::Version
+  version: 1.0.4
+platform: ruby
+authors:
+- Andrei Merfu
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awrence
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.4
+description: Ruby SDK for Binance API
+email:
+- andrei@amgital.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/binance-sdk.rb
+- lib/binance/sdk/account.rb
+- lib/binance/sdk/asset.rb
+- lib/binance/sdk/configuration.rb
+- lib/binance/sdk/endpoints.rb
+- lib/binance/sdk/error.rb
+- lib/binance/sdk/exchange.rb
+- lib/binance/sdk/klines.rb
+- lib/binance/sdk/orders.rb
+- lib/binance/sdk/request.rb
+- lib/binance/sdk/server.rb
+- lib/binance/sdk/ticker.rb
+- lib/binance/sdk/version.rb
+- lib/binance/sdk/websocket.rb
+homepage: https://github.com/andreimerfu/binance-sdk
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/andreimerfu/binance-sdk
+  source_code_uri: https://github.com/andreimerfu/binance-sdk
+  changelog_uri: https://github.com/andreimerfu/binance-sdk/changelog.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: binance-sdk-1.0.4
+test_files: []