binance 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e8027ac747e3eb75ffc8a423995838465231899
-  data.tar.gz: 7ef223ce562fe69837f2ee6538f00af35a4358cf
+  metadata.gz: a44f0ee9e6501f2e0cd830429766dc93e53d24e3
+  data.tar.gz: d71bb3d006b04582e8b3bbe0c63ae1b2e178781b
 SHA512:
-  metadata.gz: cf06724334d5d49f968c2f9658ea506689f390e89fc175fae7bf074271ada8b09c328d92c8588c0c5cba02e05000bf15d032efa2d94780675f076e2c7bdf27df
-  data.tar.gz: 6678caae06e9e9ebd40c162c003deacf313a99d52d493db2bf49f5d861f106795a1f56fff2a66fa28c2ce0e9ce3b32ff586fd9e4ac8460321b50989800172327
+  metadata.gz: 953a41c328bb44d5af13b0b21bacd246409285e77e2d5da345cc2d786c4abe3bceaa197eecd91e1821944e75bc9023301669e40763869fe5f51ccf58181d429d
+  data.tar.gz: 6caf04faa96a0d4b20d12d6ef0135b7ef93c6ad6ba70be0bd88bd3a459e6e0c3193fbf3ae1872af5a0f07193848168abda9edae3f52d8505065584ff446fb9ea

data/lib/binance.rb

@@ -1,3 +1,4 @@
 
 require 'binance/version'
 require 'binance/client/rest'
+require 'binance/client/websocket'

data/lib/binance/client/rest.rb

@@ -1,49 +1,78 @@
-
-require 'faraday'
-require_relative 'rest/api_endpoints'
-require_relative 'rest/public_api'
-require_relative 'rest/account_api'
-require_relative 'rest/withdraw_api'
-
-module Binance
-  module Client
-    # Provides low level methods for Binance APIs via their REST interface
-    class REST
-      BASE_URL = 'https://www.binance.com'.freeze
-
-      # Gets populated by the different APIs that get extended by the instances
-      @api = {}
-
-      class << self
-        attr_accessor :api
-      end
-
-      attr_reader :api_key, :secret_key
-
-      def initialize(api_key: '', secret_key: '')
-        @api_key = api_key
-        @secret_key = secret_key
-
-        extend Public_API
-        extend Account_API
-        extend Withdraw_API
-      end
-
-      def request(api, method, endpoint, options = {})
-        conn = REST.api[api].call
-        response = conn.send(method) do |req|
-          req.url API_ENDPOINTS[endpoint]
-          req.params.merge! options
-        end
-
-        response.body
-      end
-
-      def self.add_query_param(query, key, value)
-        query = query.to_s
-        query << '&' unless query.empty?
-        query << "#{Faraday::Utils.escape key}=#{Faraday::Utils.escape value}"
-      end
-    end
-  end
-end
+
+require 'faraday'
+require_relative 'rest/api_endpoints'
+require_relative 'rest/public_api'
+require_relative 'rest/account_api'
+require_relative 'rest/withdraw_api'
+
+module Binance
+  module Client
+    # Public: Client with methods mirroring the Binance REST APIs
+    class REST
+      # Public: String base url for REST client to use
+      BASE_URL = 'https://www.binance.com'.freeze
+
+      # Gets populated by the different APIs that get extended by the instances
+      @api = {}
+
+      class << self
+        attr_accessor :api
+      end
+
+      attr_reader :api_key, :secret_key, :adapter
+
+      # Public: Initialize a REST Client
+      #
+      # :api_key    - The String API key to authenticate (Default = '')
+      #
+      # :secret_key - The String secret key to authenticate (Default = '')
+      #
+      # :adapter    - The Faraday::Adapter to be used for the client
+      def initialize(api_key: '', secret_key: '',
+                     adapter: Faraday.default_adapter)
+        @api_key = api_key
+        @secret_key = secret_key
+        @adapter = adapter
+
+        extend Public_API
+        extend Account_API
+        extend Withdraw_API
+      end
+
+      private
+
+      # Internal: Create a request that hits one of the REST APIs
+      #
+      # qpi - The Symbol that represents which API to use
+      #
+      # method - The Symbol that represents which HTTP method to use
+      #
+      # endpoint - The String that represents which API endpoint to request from
+      #
+      # options - The Hash which hosts various REST query params. (Default = {})
+      #   Each endpoint will have their own required and optional params.
+      def request(api, method, endpoint, options = {})
+        conn = REST.api[api].call
+        response = conn.send(method) do |req|
+          req.url API_ENDPOINTS[endpoint]
+          req.params.merge! options
+        end
+
+        response.body
+      end
+
+      # Internal: Append key-value pair to REST query string
+      #
+      # query - The String of the existing request query url
+      #
+      # key   - The String that represents the param type
+      #
+      # value - The String that represents the param value
+      def self.add_query_param(query, key, value)
+        query = query.to_s
+        query << '&' unless query.empty?
+        query << "#{Faraday::Utils.escape key}=#{Faraday::Utils.escape value}"
+      end
+    end
+  end
+end

data/lib/binance/client/rest/account_api.rb

@@ -1,59 +1,161 @@
-
-require 'faraday'
-require 'faraday_middleware'
-require_relative 'sign_request_middleware'
-require_relative 'timestamp_request_middleware'
-
-module Binance
-  module Client
-    class REST
-      # API endpoints that require a timestamp and signature
-      module Account_API
-        def self.extended(base)
-          REST.api[:account] = lambda do
-            Faraday.new(url: "#{BASE_URL}/api") do |conn|
-              conn.request :json
-              conn.response :json, content_type: /\bjson$/
-              conn.headers['X-MBX-APIKEY'] = base.api_key
-              conn.use TimestampRequestMiddleware
-              conn.use SignRequestMiddleware, base.secret_key
-              conn.adapter Faraday.default_adapter
-            end
-          end
-        end
-
-        def create_order(options)
-          request :account, :post, 'order', options
-        end
-
-        def create_test_order(options)
-          request :account, :post, 'order/test', options
-        end
-
-        def query_order(options)
-          request :account, :get, 'order', options
-        end
-
-        def cancel_order(options)
-          request :account, :delete, 'order', options
-        end
-
-        def open_orders(options)
-          request :account, :get, 'openOrders', options
-        end
-
-        def all_orders(options)
-          request :account, :get, 'allOrders', options
-        end
-
-        def account_info(options = {})
-          request :account, :get, 'account', options
-        end
-
-        def account_trade_list(options)
-          request :account, :get, 'myTrades', options
-        end
-      end
-    end
-  end
+
+require 'faraday'
+require 'faraday_middleware'
+require_relative 'sign_request_middleware'
+require_relative 'timestamp_request_middleware'
+
+module Binance
+  module Client
+    class REST
+      # Public: A module containing all of the Account API endpoints
+      module Account_API
+        # Internal: Create Lambda that returns a new Faraday client instance
+        #   and add it to the REST class instance variable @api. This is called
+        #   while a new instance of the REST class is created.
+        #
+        # base - The base class that is being extended into
+        def self.extended(base)
+          REST.api[:account] = lambda do
+            Faraday.new(url: "#{BASE_URL}/api") do |conn|
+              conn.request :json
+              conn.response :json, content_type: /\bjson$/
+              conn.headers['X-MBX-APIKEY'] = base.api_key
+              conn.use TimestampRequestMiddleware
+              conn.use SignRequestMiddleware, base.secret_key
+              conn.adapter base.adapter
+            end
+          end
+        end
+
+        # Public: Create a new order on the specified symbol for the
+        #   authenticated account
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol           - The String of which trading pair to create the
+        #     order on.
+        #   :side             - The String determining which side to create the
+        #     order on.
+        #   :type             - The String determining what type of order it is.
+        #   :timeInForce      - The String determining what the time in force is
+        #     (optional).
+        #   :quantity         - The String determining the amount of assets to
+        #     purchase.
+        #   :price            - The String determining what price to purchase at
+        #     (optional).
+        #   :newClientOrderId - The String which uniquely identifies this order
+        #     (optional).
+        #   :stopPrice        - The String determining which price to stop at
+        #     (optional).
+        #   :icebergQty       - The String determining the amount of assets to
+        #     show on the order book (optional).
+        #   :newOrderRespType - The String which sets the type of response to
+        #     receive (optional).
+        #   :recvWindow       - The Number of how long a request is valid for
+        #     in milliseconds (optional).
+        #
+        # Returns a Hash of the request response
+        def create_order(options)
+          request :account, :post, 'order', options
+        end
+
+        def create_test_order(options)
+          request :account, :post, 'order/test', options
+        end
+
+        # Public: Query an orders status on the specified symbol for the
+        #   authenticated account. One must send either an :orderId or
+        #   :origOrderId, but not both.
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol            - The String of which trading pair to query from
+        #     (optional).
+        #   :orderId           - The String determining which order to query
+        #     (optional).
+        #   :origClientOrderId - The String determining which order to cancel
+        #     (optional).
+        #   :recvWindow        - The Number of how long a request is valid for
+        #     in milliseconds (optional).
+        #
+        # Returns a Hash of the request response
+        def query_order(options)
+          request :account, :get, 'order', options
+        end
+
+        # Public: Cancel the order specified for the authenticated account.
+        #   One must send either an :orderId or :origOrderId, but not both.
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol            - The String of which trading pair to delete from
+        #     (optional).
+        #   :orderId           - The String determining which order to cancel
+        #     (optional).
+        #   :origClientOrderId - The String determining which order to cancel
+        #     (optional).
+        #   :newClientOrderId  - The String used in uniquely identifying the
+        #     cancel order (optional).
+        #   :recvWindow        - The Number of how long a request is valid for
+        #     in milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def cancel_order(options)
+          request :account, :delete, 'order', options
+        end
+
+        # Public: Retrieve open orders for the authenticated account
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol     - The String of which trading pair to retrieve
+        #     (optional).
+        #   :recvWindow - The Number of how long a request is valid for in
+        #     milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def open_orders(options)
+          request :account, :get, 'openOrders', options
+        end
+
+        # Public: Retrieve all orders of the specified symbol for the
+        #   authenticated account
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol     - The String of which trading pair to retrieve.
+        #   :orderId    - The String determining which order to start the data
+        #     from (optional).
+        #   :limit      - The Number of how many trades to request (optional).
+        #   :recvWindow - The Number of how long a request is valid for in
+        #     milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def all_orders(options)
+          request :account, :get, 'allOrders', options
+        end
+
+        # Public: Retrieve account information for the authenticated account
+        #
+        # options - The Hash which hosts various REST query params
+        #   :recvWindow - The Number of how long a request is valid for in
+        #     milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def account_info(options = {})
+          request :account, :get, 'account', options
+        end
+
+        # Public: Retrieve trade data of the specified symbol for the
+        #   authenticated account
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol - The String of which trading pair to retrieve.
+        #   :limit  - The Number of how many trades to request (optional).
+        #   :fromId - The String of which trade ID to fetch from (optional).
+        #   :recvWindow - The Number of how long a request is valid for in
+        #     milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def account_trade_list(options)
+          request :account, :get, 'myTrades', options
+        end
+      end
+    end
+  end
 end

data/lib/binance/client/rest/api_endpoints.rb

@@ -1,36 +1,37 @@
-
-module Binance
-  module Client
-    class REST
-      API_ENDPOINTS = {
-        # Public API Endpoints
-        'ping'              => 'v1/ping',
-        'time'              => 'v1/time',
-        'exchangeInfo'      => 'v1/exchangeInfo',
-        'products'          => '/exchange/public/products',
-        'depth'             => 'v1/depth',
-        'trades'            => 'v1/trades',
-        'historicalTrades'  => 'v1/historicalTrades',
-        'aggTrades'         => 'v1/aggTrades',
-        'klines'            => 'v1/klines',
-        '24hr'              => 'v1/ticker/24hr',
-        'price'             => 'v3/ticker/price',
-        'bookTicker'        => 'v3/ticker/bookTicker',
-
-        # Account API Endpoints
-        'order'       => 'v3/order',
-        'order/test'  => 'v3/order/test',
-        'openOrders'  => 'v3/openOrders',
-        'allOrders'   => 'v3/allOrders',
-        'account'     => 'v3/account',
-        'myTrades'    => 'v3/myTrades',
-
-        # Withdraw API Endpoints
-        'withdraw'        => 'v3/withdraw.html',
-        'depositHistory'  => 'v3/depositHistory.html',
-        'withdrawHistory' => 'v3/withdrawHistory.html',
-        'depositAddress'  => 'v3/depositAddress.html'
-      }.freeze
-    end
-  end
-end
+
+module Binance
+  module Client
+    class REST
+      API_ENDPOINTS = {
+        # Public API Endpoints
+        'ping'              => 'v1/ping',
+        'time'              => 'v1/time',
+        'exchangeInfo'      => 'v1/exchangeInfo',
+        'products'          => '/exchange/public/products',
+        'depth'             => 'v1/depth',
+        'trades'            => 'v1/trades',
+        'historicalTrades'  => 'v1/historicalTrades',
+        'aggTrades'         => 'v1/aggTrades',
+        'klines'            => 'v1/klines',
+        '24hr'              => 'v1/ticker/24hr',
+        'price'             => 'v3/ticker/price',
+        'bookTicker'        => 'v3/ticker/bookTicker',
+
+        # Account API Endpoints
+        'order'       => 'v3/order',
+        'order/test'  => 'v3/order/test',
+        'openOrders'  => 'v3/openOrders',
+        'allOrders'   => 'v3/allOrders',
+        'account'     => 'v3/account',
+        'myTrades'    => 'v3/myTrades',
+
+        # Withdraw API Endpoints
+        'withdraw'        => 'v3/withdraw.html',
+        'depositHistory'  => 'v3/depositHistory.html',
+        'withdrawHistory' => 'v3/withdrawHistory.html',
+        'depositAddress'  => 'v3/depositAddress.html',
+        'accountStatus'   => 'v3/accountStatus.html'
+      }.freeze
+    end
+  end
+end

data/lib/binance/client/rest/public_api.rb

@@ -1,80 +1,167 @@
-
-require 'faraday'
-require 'faraday_middleware'
-
-module Binance
-  module Client
-    class REST
-      # API endpoints that don't require any type of authentication
-      module Public_API
-        def self.extended(_base)
-          REST.api[:public] = lambda do
-            Faraday.new(url: "#{BASE_URL}/api") do |conn|
-              conn.request :json
-              conn.response :json, content_type: /\bjson$/
-              conn.adapter Faraday.default_adapter
-            end
-          end
-        end
-
-        def ping
-          request :public, :get, 'ping'
-        end
-
-        def time
-          request :public, :get, 'time'
-        end
-
-        def exchange_info
-          request :public, :get, 'exchangeInfo'
-        end
-
-        def products
-          request :public, :get, 'products'
-        end
-
-        def depth(options)
-          request :public, :get, 'depth', options
-        end
-
-        def trades(options)
-          request :public, :get, 'trades', options
-        end
-
-        def historical_trades(options)
-          request :public, :get, 'historicalTrades', options
-        end
-
-        def agg_trades(options)
-          request :public, :get, 'aggTrades', options
-        end
-
-        def klines(options)
-          request :public, :get, 'klines', options
-        end
-
-        def twenty_four_hour(options)
-          request :public, :get, '24hr', options
-        end
-
-        def price(options)
-          request :public, :get, 'price', options
-        end
-
-        # Ensure backwards compatibility
-        def all_prices
-          request :public, :get, 'price'
-        end
-
-        def book_ticker(options)
-          request :public, :get, 'bookTicker', options
-        end
-
-        # Ensure backwards compatibility
-        def all_book_tickers
-          request :public, :get, 'bookTicker'
-        end
-      end
-    end
-  end
-end
+
+require 'faraday'
+require 'faraday_middleware'
+
+module Binance
+  module Client
+    class REST
+      # Public: A Module containing all of the Public API endpoints
+      module Public_API
+        # Internal: Create Lambda that returns a new Faraday client instance
+        #   and add it to the REST class instance variable @api. This is called
+        #   while a new instance of the REST class is created.
+        #
+        # base - The base class that is being extended into
+        def self.extended(base)
+          REST.api[:public] = lambda do
+            Faraday.new(url: "#{BASE_URL}/api") do |conn|
+              conn.request :json
+              conn.response :json, content_type: /\bjson$/
+              conn.adapter base.adapter
+            end
+          end
+        end
+
+        # Public: Ping the server to test connectivity
+        #
+        # Returns a Hash with the request response
+        def ping
+          request :public, :get, 'ping'
+        end
+
+        # Public: Retrieve the server time in milliseconds
+        #
+        # Returns a Hash with the request response
+        def time
+          request :public, :get, 'time'
+        end
+
+        # Public: Retrieve current exchange trading rules and symbol information
+        #
+        # Returns a Hash with the request response
+        def exchange_info
+          request :public, :get, 'exchangeInfo'
+        end
+
+        # Public: Retrieve current exchange asset information. This is an
+        #   undocumented endpoint.
+        #
+        # Returns a Hash with the request response
+        def products
+          request :public, :get, 'products'
+        end
+
+        # Public: Retrieve depth information for the specified symbol
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol - The String of which trading pair to retrieve.
+        #   :limit  - The Number of how many updates to request (optional).
+        #
+        # Returns a Hash with the request response
+        def depth(options)
+          request :public, :get, 'depth', options
+        end
+
+        # Public: Retrieve recent trades for the specified symbol
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol - The String of which trading pair to retrieve.
+        #   :limit  - The Number of how many trades to request (optional).
+        #
+        # Returns a Hash with the request response
+        def trades(options)
+          request :public, :get, 'trades', options
+        end
+
+        # Public: Retrieve old trade data for the specified symbol
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol - The String of which trading pair to retrieve.
+        #   :limit  - The Number of how many trades to request (optional).
+        #   :fromId - The String of which trade ID to fetch from.
+        #
+        # Returns a Hash with the request response
+        def historical_trades(options)
+          request :public, :get, 'historicalTrades', options
+        end
+
+        # Public: Retrieve aggregate trade data for the specified symbol
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol     - The String of which trading pair to retrieve.
+        #   :fromId     - The String of which trade ID to fetch from (optional).
+        #   :startTime  - The Timestamp of when to get trades from in
+        #     milliseconds (optional).
+        #   :endTime    - The Timestamp of when to get trades until in
+        #     milliseconds (optional).
+        #   :limit      - The Number of how many trades to request (optional).
+        #
+        # Returns a Hash with the request response
+        def agg_trades(options)
+          request :public, :get, 'aggTrades', options
+        end
+
+        # Public: Retrieve kline data for the specified symbol
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol     - The String of which trading pair to retrieve.
+        #   :interval   -
+        #   :fromId - The String of which trade ID to fetch from (optional).
+        #   :startTime  - The Timestamp of when to get trades from in
+        #     milliseconds (optional).
+        #   :endTime    - The Timestamp of when to get trades until in
+        #     milliseconds (optional).
+        #   :limit      - The Number of how many trades to request (optional).
+        #
+        # Returns a Hash with the request response
+        def klines(options)
+          request :public, :get, 'klines', options
+        end
+
+        # Public: Retrieve 24 hour ticker price data
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol - The String of which trading pair to retrieve (optional).
+        #
+        # Returns a Hash with the request response
+        def twenty_four_hour(options)
+          request :public, :get, '24hr', options
+        end
+
+        # Public: Retrieve price ticker data for the specified symbol
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol - The String of which trading pair to retrieve (optional).
+        #
+        # Returns a Hash with the request response
+        def price(options)
+          request :public, :get, 'price', options
+        end
+
+        # Public: Retrieve all price ticker data
+        #
+        # Returns a Hash with the request response
+        def all_prices
+          request :public, :get, 'price'
+        end
+
+        # Public: Retrieve best price per quantity on the order book
+        #
+        # options - The Hash which hosts various REST query params
+        #   :symbol - The String of which trading pair to retrieve (optional).
+        #
+        # Returns a Hash with the request response
+        def book_ticker(options)
+          request :public, :get, 'bookTicker', options
+        end
+
+        # Public: Retrieve all book ticker data  for all symbols
+        #
+        # Returns a Hash with the request response
+        def all_book_tickers
+          request :public, :get, 'bookTicker'
+        end
+      end
+    end
+  end
+end

data/lib/binance/client/rest/sign_request_middleware.rb

@@ -1,18 +1,18 @@
-
-module Binance
-  module Client
-    class REST
-      # Sign the query string using HMAC(sha-256) and appends to query string
-      SignRequestMiddleware = Struct.new(:app, :secret_key) do
-        def call(env)
-          value = OpenSSL::HMAC.hexdigest(
-            OpenSSL::Digest.new('sha256'), secret_key, env.url.query
-          )
-          env.url.query = REST.add_query_param(env.url.query, 'signature', value)
-
-          app.call env
-        end
-      end
-    end
-  end
-end
+
+module Binance
+  module Client
+    class REST
+      # Sign the query string using HMAC(sha-256) and appends to query string
+      SignRequestMiddleware = Struct.new(:app, :secret_key) do
+        def call(env)
+          value = OpenSSL::HMAC.hexdigest(
+            OpenSSL::Digest.new('sha256'), secret_key, env.url.query
+          )
+          env.url.query = REST.add_query_param(env.url.query, 'signature', value)
+
+          app.call env
+        end
+      end
+    end
+  end
+end

data/lib/binance/client/rest/timestamp_request_middleware.rb

@@ -1,19 +1,19 @@
-
-require 'date'
-
-module Binance
-  module Client
-    class REST
-      # Generate a timestamp in milliseconds and append to query string
-      TimestampRequestMiddleware = Struct.new(:app) do
-        def call(env)
-          env.url.query = REST.add_query_param(
-            env.url.query, 'timestamp', DateTime.now.strftime('%Q')
-          )
-
-          app.call env
-        end
-      end
-    end
-  end
-end
+
+require 'date'
+
+module Binance
+  module Client
+    class REST
+      # Generate a timestamp in milliseconds and append to query string
+      TimestampRequestMiddleware = Struct.new(:app) do
+        def call(env)
+          env.url.query = REST.add_query_param(
+            env.url.query, 'timestamp', DateTime.now.strftime('%Q')
+          )
+
+          app.call env
+        end
+      end
+    end
+  end
+end

data/lib/binance/client/rest/withdraw_api.rb

@@ -1,44 +1,106 @@
-
-require 'faraday'
-require 'faraday_middleware'
-require_relative 'sign_request_middleware'
-require_relative 'timestamp_request_middleware'
-
-module Binance
-  module Client
-    class REST
-      # API endpoints with require a timestamp and signature,
-      # as well as requiring url_encoded parameters
-      module Withdraw_API
-        def self.extended(base)
-          REST.api[:withdraw] = lambda do
-            Faraday.new(url: "#{BASE_URL}/wapi") do |conn|
-              conn.request :url_encoded
-              conn.response :json, content_type: /\bjson$/
-              conn.headers['X-MBX-APIKEY'] = base.api_key
-              conn.use TimestampRequestMiddleware
-              conn.use SignRequestMiddleware, base.secret_key
-              conn.adapter Faraday.default_adapter
-            end
-          end
-        end
-
-        def withdraw(options)
-          request :withdraw, :post, 'withdraw', options
-        end
-
-        def deposit_history(options = {})
-          request :withdraw, :get, 'depositHistory', options
-        end
-
-        def withdraw_history(options = {})
-          request :withdraw, :get, 'withdrawHistory', options
-        end
-
-        def deposit_address(options)
-          request :withdraw, :get, 'depositAddress', options
-        end
-      end
-    end
-  end
+
+require 'faraday'
+require 'faraday_middleware'
+require_relative 'sign_request_middleware'
+require_relative 'timestamp_request_middleware'
+
+module Binance
+  module Client
+    class REST
+      # Public: A Module containing all of the Withdraw API endpoints
+      module Withdraw_API
+        # Internal: Create Lambda that returns a new Faraday client instance
+        #   and add it to the REST class instance variable @api. This is called
+        #   while a new instance of the REST class is created.
+        #
+        # base - The base class that is being extended into
+        def self.extended(base)
+          REST.api[:withdraw] = lambda do
+            Faraday.new(url: "#{BASE_URL}/wapi") do |conn|
+              conn.request :url_encoded
+              conn.response :json, content_type: /\bjson$/
+              conn.headers['X-MBX-APIKEY'] = base.api_key
+              conn.use TimestampRequestMiddleware
+              conn.use SignRequestMiddleware, base.secret_key
+              conn.adapter base.adapter
+            end
+          end
+        end
+
+        # Public: Withdraw the specified asset to the given address using
+        #   the authenticated account
+        #
+        # options - The Hash which hosts various REST query params
+        #   :asset      - The String of which asset to withdraw.
+        #   :address    - The String of where to send the asset to.
+        #   :addressTag - The String secondary address identifier (optional).
+        #   :amount     - The String decimal value of how much to withdraw.
+        #   :name       - The String description of the address
+        #   :recvWindow - The Number of how long a request is valid for in
+        #     milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def withdraw(options)
+          request :withdraw, :post, 'withdraw', options
+        end
+
+        # Public: Retrieve the deposit history for the authenticated account
+        #
+        # options - The Hash which hosts various REST query params
+        #   :asset      - The String of which asset to retrieve (optional).
+        #   :status     - The Number of which status to retrieve (optional).
+        #   :startTime  - The Timestamp of when to start the history in
+        #     milliseconds (optional).
+        #   :endTime    - The Timestamp of when to end the history in
+        #     milliseconds (optional).
+        #   :recvWindow - The Number of how long a request is valid for in
+        #     milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def deposit_history(options = {})
+          request :withdraw, :get, 'depositHistory', options
+        end
+
+        # Public: Retrieve the withdraw history for the authenticated account
+        #
+        # options - The Hash which hosts various REST query params
+        #   :asset      - The String of which asset to retrieve (optional).
+        #   :status     - The Number of which status to retrieve (optional).
+        #   :startTime  - The Timestamp of when to start the history in
+        #     milliseconds (optional).
+        #   :endTime    - The Timestamp of when to end the history in
+        #     milliseconds (optional).
+        #   :recvWindow - The Number of how long a request is valid for in
+        #     milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def withdraw_history(options = {})
+          request :withdraw, :get, 'withdrawHistory', options
+        end
+
+        # Public: Retrieve the deposit address for a specific asset
+        #
+        # options - The Hash which hosts various REST query params
+        #   :asset      - The String of which asset to retrieve (optional).
+        #   :recvWindow - The Number of how long a request is valid for in
+        #     milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def deposit_address(options)
+          request :withdraw, :get, 'depositAddress', options
+        end
+
+        # Public: Retrieve current account status
+        #
+        # options - The Hash which hosts various REST query params
+        #   :recvWindow - The Number of how long a request is valid for in
+        #     milliseconds (optional).
+        #
+        # Returns a Hash with the request response
+        def account_status(options)
+          request :withdraw, :get, 'accountStatus', options
+        end
+      end
+    end
+  end
 end

data/lib/binance/client/websocket.rb

@@ -0,0 +1,202 @@
+
+require 'faye/websocket'
+
+module Binance
+  module Client
+    # Public: Client with methods mirroring the Binance WebSocket API
+    class WebSocket
+      # Public: String base url for WebSocket client to use
+      BASE_URL = 'wss://stream.binance.com:9443'.freeze
+
+      # Public: Create a single WebSocket stream
+      #
+      # :stream - The Hash used to define the stream
+      #   :symbol   - The String symbol to listen to
+      #   :type     - The String type of stream to listen to
+      #   :level    - The String level to use for the depth stream (optional)
+      #   :interval - The String interval to use for the kline stream (optional)
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def single(stream:, methods:)
+        create_stream("#{BASE_URL}/ws/#{stream_url(stream)}",
+                      methods: methods)
+      end
+
+      # Public: Create multiple WebSocket streams
+      #
+      # :streams - The Array of Hashes used to define the stream.
+      #   Each Hash can have the following keys
+      #   :symbol   - The String symbol the stream will listen to
+      #   :type     - The String type of stream to listen to
+      #   :level    - The String level to use for the depth stream (optional)
+      #   :interval - The String interval to use for the kline stream (optional)
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def multi(streams:, methods:)
+        names = streams.map { |stream| stream_url(stream) }
+        create_stream("#{BASE_URL}/stream?streams=#{names.join('/')}",
+                      methods: methods)
+      end
+
+      # Public: Create an Aggregate Trade stream
+      #
+      # :symbol - The String symbol the stream will listen to
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def agg_trade(symbol:, methods:)
+        single stream: { symbol: symbol, type: 'aggTrade' }, methods: methods
+      end
+
+      # Public: Create a Trade stream
+      #
+      # :symbol - The String symbol the stream will listen to
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def trade(symbol:, methods:)
+        single stream: { symbol: symbol, type: 'trade' }, methods: methods
+      end
+
+      # Public: Create an Kline stream
+      #
+      # :symbol - The String symbol the stream will listen to
+      #
+      # :interval - The String interval the stream will update with.
+      #   The intervals that may be used can be found in the Binance API docs.
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def kline(symbol:, interval:, methods:)
+        single stream: { symbol: symbol, type: 'kline', interval: interval },
+               methods: methods
+      end
+
+      # Public: Create a Ticker stream
+      #
+      # :symbol - The String symbol the stream will listen to
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def ticker(symbol:, methods:)
+        single stream: { symbol: symbol, type: 'ticker' }, methods: methods
+      end
+
+      # Public: Create a Ticker stream for all symbols
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def all_market_ticker(methods:)
+        single stream: { symbol: '!ticker', type: 'arr' }, methods: methods
+      end
+
+      # Public: Create an Partial Book Depth stream
+      #
+      # :symbol - The String symbol the stream will listen to
+      #
+      # :level - The String interval the stream will update with.
+      #   The intervals that may be used can be found in the Binance API docs.
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def partial_book_depth(symbol:, level:, methods:)
+        single stream: { symbol: symbol, type: 'depth', level: level },
+               methods: methods
+      end
+
+      # Public: Create a Diff Depth stream
+      #
+      # :symbol - The String symbol the stream will listen to
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def diff_depth(symbol:, methods:)
+        single stream: { symbol: symbol, type: 'depth' }, methods: methods
+      end
+
+      private
+
+      # Internal: Create a valid URL for a WebSocket to use
+      #
+      # :symbol - The String symbol to listen to
+      # :type   - The String type the stream will listen to
+      # :level    - The String level to use for the depth stream (optional)
+      # :interval - The String interval to use for the kline stream (optional)
+      def stream_url(symbol:, type:, level: '', interval: '')
+        "#{symbol.downcase}@#{type}".tap do |url|
+          url << level
+          url << "_#{interval}" unless interval.empty?
+        end
+      end
+
+      # Internal: Initialize and return a Faye::WebSocket::Client
+      #
+      # url - The String url that the WebSocket should try to connect to
+      #
+      # :methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def create_stream(url, methods:)
+        Faye::WebSocket::Client.new(url)
+                               .tap { |ws| attach_methods(ws, methods) }
+      end
+
+      # Internal: Iterate through methods passed and add them to the WebSocket
+      #
+      # websocket - The Faye::WebSocket::Client to apply methods to
+      #
+      # methods - The Hash which contains the event handler methods to pass to
+      #   the WebSocket client
+      #   :open    - The Proc called when a stream is opened (optional)
+      #   :message - The Proc called when a stream receives a message
+      #   :error   - The Proc called when a stream receives an error (optional)
+      #   :close   - The Proc called when a stream is closed (optional)
+      def attach_methods(websocket, methods)
+        methods.each_pair do |key, method|
+          websocket.on(key) { |event| method.call(event) }
+        end
+      end
+    end
+  end
+end

data/lib/binance/version.rb

@@ -1,4 +1,4 @@
-
-module Binance
-  VERSION = '0.2.0'.freeze
-end
+
+module Binance
+  VERSION = '0.3.0'.freeze
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: binance
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Charles Ray Shisler III
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-13 00:00:00.000000000 Z
+date: 2017-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.7
 description: 
 email:
 - charles@cray.io
@@ -97,6 +111,7 @@ files:
 - lib/binance/client/rest/sign_request_middleware.rb
 - lib/binance/client/rest/timestamp_request_middleware.rb
 - lib/binance/client/rest/withdraw_api.rb
+- lib/binance/client/websocket.rb
 - lib/binance/version.rb
 homepage: https://github.com/craysiii/binance
 licenses:
@@ -118,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: API Wrapper for the Binance cryptocurrency exchange.