bibox 0.1.0

data/lib/bibox/rest/errors.rb

@@ -0,0 +1,16 @@
+module Bibox
+  module Rest
+    module Errors
+      
+      def error?(response)
+        if response.is_a?(Hash) && response.has_key?("error")
+          error     =   response.fetch("error", {})
+          code      =   error.fetch("code", nil)
+          message   =   error.fetch("msg", nil)
+          ::Bibox::Errors::MAPPING.fetch(code, nil)&.call
+        end
+      end
+            
+    end
+  end  
+end

data/lib/bibox/rest/private/assets.rb

@@ -0,0 +1,33 @@
+module Bibox
+  module Rest
+    module Private
+      module Assets
+                
+        def coin_list(options: {})
+          payload     =   [
+            {
+              cmd:  "transfer/coinList",
+              body: {}
+            }
+          ]
+          
+          response    =   parse(post("/transfer", data: payload, options: options))&.fetch("result", [])&.first&.fetch("result", [])
+          ::Bibox::Models::Asset.parse(response) if response&.any?
+        end
+        
+        def assets(options: {})
+          payload     =   [
+            {
+              cmd:  "transfer/assets",
+              body: {select: 1}
+            }
+          ]
+          
+          response    =   parse(post("/transfer", data: payload, options: options))&.fetch("result", [])&.first&.fetch("result", {})
+          ::Bibox::Models::UserAssets.new(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/rest/private/bills.rb

@@ -0,0 +1,31 @@
+module Bibox
+  module Rest
+    module Private
+      module Bills
+                
+        def bills(coin_id: 0, type: :all, days: 30, page: 1, size: 50, options: {})
+          params      =   {
+            coin_id:  coin_id,
+            type:     ::Bibox::Models::Bill::BILL_TYPES[type],
+            days:     days,  
+            page:     page,
+            size:     size
+          }
+          
+          params.delete_if { |key, value| value.nil? }
+          
+          payload     =   [
+            {
+              cmd:  "transfer/bills",
+              body: params
+            }
+          ]
+          
+          response    =   parse(post("/transfer", data: payload, options: options))&.fetch("result", [])&.first&.fetch("result", {})&.fetch("items", [])
+          ::Bibox::Models::Bill.parse(response) if response&.any?
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/rest/private/order_book.rb

@@ -0,0 +1,21 @@
+module Bibox
+  module Rest
+    module Private
+      module OrderBook
+      
+        def extended_order_book(pair: "BIX_ETH", size: 200, options: {})
+          payload     =   [
+            {
+              cmd:  "api/depth",
+              body: {pair: pair, size: size}
+            }
+          ]
+          
+          response    =   parse(post("/mdata", data: payload, options: options))&.fetch("result", [])&.first&.fetch("result", {})
+          ::Bibox::Models::OrderBook.new(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/rest/private/orders.rb

@@ -0,0 +1,131 @@
+module Bibox
+  module Rest
+    module Private
+      module Orders
+        
+        def buy(pair:, price:, amount:, order_type: :limit, pay_fees_with_bix: true, options: {})
+          perform_order(
+            pair:               pair,
+            price:              price,
+            amount:             amount,
+            order_side:         :buy,
+            order_type:         order_type,
+            pay_fees_with_bix:  pay_fees_with_bix,
+            options:            options
+          )
+        end
+        
+        def sell(pair:, price:, amount:, order_type: :limit, pay_fees_with_bix: true, options: {})
+          perform_order(
+            pair:               pair,
+            price:              price,
+            amount:             amount,
+            order_side:         :sell,
+            order_type:         order_type,
+            pay_fees_with_bix:  pay_fees_with_bix,
+            options:            options
+          )
+        end
+        
+        def perform_order(pair:, price:, amount:, order_side: :buy, order_type: :limit, account_type: 0, pay_fees_with_bix: true, options: {})
+          params      =   {
+            pair:           pair,
+            account_type:   account_type,
+            order_type:     Bibox::Models::Order::ORDER_TYPES[order_type],
+            order_side:     Bibox::Models::Order::ORDER_SIDES[order_side],
+            pay_bix:        pay_fees_with_bix.eql?(true) ? 1 : 0,
+            price:          price,
+            amount:         amount,
+            money:          (price * amount),
+          }
+          
+          payload     =   [
+            {
+              cmd:  "orderpending/trade",
+              body: params
+            }
+          ]
+          
+          response    =   parse(post("/orderpending", data: payload, options: options))&.fetch("result", [])&.first&.fetch("result", {})&.to_s
+        end
+        
+        def cancel_order(order_id, options: {})
+          payload     =   [
+            {
+              cmd:  "orderpending/cancelTrade",
+              body: {orders_id: order_id}
+            }
+          ]
+          
+          response    =   parse(post("/orderpending", data: payload, options: options))
+          
+          return true
+        end
+        
+        # A currency pair can be specified using its code, e.g. BIX_ETH
+        # Or separately using coin_symbol and currency_symbol (which the Bibox UI seems to use)
+        
+        def pending_orders(pair: nil, page: 1, size: 10, coin_symbol: nil, currency_symbol: nil, order_side: nil, account_type: nil, options: {})          
+          params      =   {
+            pair:             pair,
+            page:             page,
+            size:             size,
+            coin_symbol:      coin_symbol,
+            currency_symbol:  currency_symbol,
+            order_side:       order_side,
+            account_type:     account_type,
+          }
+          
+          return list_orders(type: :pending, params: params, options: options)
+        end
+        
+        def order_history(pair: nil, page: 1, size: 10, hide_cancel: nil, coin_symbol: nil, currency_symbol: nil, order_side: nil, account_type: nil, options: {})
+          params      =   {
+            pair:             pair,
+            page:             page,
+            size:             size,
+            hide_cancel:      hide_cancel,
+            coin_symbol:      coin_symbol,
+            currency_symbol:  currency_symbol,
+            order_side:       order_side,
+            account_type:     account_type,
+          }
+          
+          return list_orders(type: :history, params: params, options: options)
+        end
+        
+        def list_orders(type: :pending, params: {}, options: {})          
+          params[:page]            ||=   1
+          params[:size]            ||=   10
+          
+          command   =   case type
+            when :pending
+              "orderpending/orderPendingList"
+            when :history
+              "orderpending/orderHistoryList"
+          end
+          
+          params.delete_if { |key, value| value.nil? }
+          
+          case params[:order_side]
+            when 1, :buy
+              params[:order_side] = ::Bibox::Constants::BUY_ORDER
+            when 2, :sell
+              params[:order_side] = ::Bibox::Constants::SELL_ORDER
+          end
+          
+          payload     =   [
+            {
+              cmd:  command,
+              body: params
+            }
+          ]
+          
+          response    =   parse(post("/orderpending", data: payload, options: options))&.fetch("result", [])&.first&.fetch("result", {})&.fetch("items", [])
+          ::Bibox::Models::Order.parse(response) if response&.any?
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/rest/private/transfers.rb

@@ -0,0 +1,49 @@
+module Bibox
+  module Rest
+    module Private
+      module Transfers
+        
+        def deposit_address(symbol = "BTC", options: {})
+          payload     =   [
+            {
+              cmd:  "transfer/transferIn",
+              body: {coin_symbol: symbol}
+            }
+          ]
+          
+          response    =   parse(post("/transfer", data: payload, options: options))&.fetch("result", [])&.first&.fetch("result", {})
+        end
+        
+        def deposits(page: 1, size: 10, filter_type: :all, search: nil, options: {})
+          transfers(command: "transfer/transferInList", page: page, size: size, filter_type: filter_type, search: search, options: options)
+        end
+        
+        def withdrawals(page: 1, size: 10, filter_type: :all, search: nil, options: {})
+          transfers(command: "transfer/transferOutList", page: page, size: size, filter_type: filter_type, search: search, options: options)
+        end
+        
+        def transfers(command:, page: 1, size: 10, filter_type: :all, search: nil, options: {})
+          params      =   {
+            page:         page,
+            size:         size,
+            filter_type:  ::Bibox::Models::Transfer::STATUSES[filter_type],
+            search:       search,
+          }
+          
+          params.delete_if { |key, value| value.nil? }
+          
+          payload     =   [
+            {
+              cmd:  command,
+              body: params
+            }
+          ]
+          
+          response    =   parse(post("/transfer", data: payload, options: options))&.fetch("result", [])&.first&.fetch("result", {})&.fetch("items", [])
+          ::Bibox::Models::Transfer.parse(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/rest/public/klines.rb

@@ -0,0 +1,22 @@
+module Bibox
+  module Rest
+    module Public
+      module Klines
+        
+        # Pair: pair to lookup data OHLCV data for
+        # Period: specific interval/period to group data for
+          # Minutes: '1min', '5min', '10min', '15min' etc.
+          # Hours: '1hour' etc.
+          # Days: 'day'
+        # Size: number of data points to return (1000 is maximum)
+        def klines(pair: "BIX_ETH", period: '1min', size: 1_000, options: {})
+          path        =   "/mdata"
+          params      =   {cmd: "kline", pair: pair, period: period, size: size}
+          response    =   parse(get(path, params: params, options: options))&.fetch("result", {})
+          ::Bibox::Models::OHLCV.parse(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/rest/public/order_book.rb

@@ -0,0 +1,16 @@
+module Bibox
+  module Rest
+    module Public
+      module OrderBook
+      
+        def order_book(pair: "BIX_ETH", size: 200, options: {})
+          path        =   "/mdata"
+          params      =   {cmd: "depth", pair: pair, size: size}
+          response    =   parse(get(path, params: params, options: options))&.fetch("result", {})
+          ::Bibox::Models::OrderBook.new(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/rest/public/pairs.rb

@@ -0,0 +1,23 @@
+module Bibox
+  module Rest
+    module Public
+      module Pairs
+        
+        def pair(pair: "BIX_ETH", options: {})
+          path        =   "/mdata"
+          params      =   {cmd: "market", pair: pair}
+          response    =   parse(get(path, params: params, options: options))&.fetch("result", {})
+          ::Bibox::Models::Pair.new(response) if response
+        end
+        
+        def pairs(options: {})
+          path        =   "/mdata"
+          params      =   {cmd: "marketAll"}
+          response    =   parse(get(path, params: params, options: options))&.fetch("result", {})
+          ::Bibox::Models::Pair.parse(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/rest/public/ticker.rb

@@ -0,0 +1,16 @@
+module Bibox
+  module Rest
+    module Public
+      module Ticker
+      
+        def ticker(pair: "BIX_ETH", options: {})
+          path        =   "/mdata"
+          params      =   {cmd: "ticker", pair: pair}
+          response    =   parse(get(path, params: params, options: options))&.fetch("result", {})
+          ::Bibox::Models::Ticker.new(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/rest/public/trades.rb

@@ -0,0 +1,16 @@
+module Bibox
+  module Rest
+    module Public
+      module Trades
+      
+        def trades(pair: "BIX_ETH", size: 200, options: {})
+          path        =   "/mdata"
+          params      =   {cmd: "deals", pair: pair, size: size}
+          response    =   parse(get(path, params: params, options: options))&.fetch("result", {})
+          ::Bibox::Models::Trade.parse(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bibox/utilities.rb

@@ -0,0 +1,68 @@
+module Bibox
+  class Utilities
+    
+    class << self      
+      def convert_value(value, type, use_ms_for_time: true)
+        if type.is_a?(Symbol)
+          return case type
+            when :string
+              value.to_s
+            when :integer
+              value.to_i
+            when :float
+              value.to_f
+            when :decimal
+              to_decimal(value)
+            when :boolean
+              ["true", "1"].include?(value.to_s.downcase)
+            when :datetime
+              DateTime.parse(value)
+            when :time
+              epoch_to_time(value, ms: use_ms_for_time)
+            when :hash
+              value.symbolize_keys
+            else
+              value
+          end
+        elsif type.is_a?(Hash)
+          return case type.keys.first
+            when :enum
+              type[:enum][value.to_i]
+            else
+              value
+          end
+        end
+      end
+      
+      def time_to_epoch(time, ms: false)
+        ms ? (time.to_i * 1_000) : time.to_i
+      end
+      
+      def epoch_to_time(epoch, ms: false)
+        ms ? ::Time.at(epoch.to_i / 1_000).utc : ::Time.at(epoch.to_i).utc
+      end
+      
+      def numeric?(string)
+        !!Kernel.Float(string) 
+      rescue TypeError, ArgumentError
+        false
+      end
+      
+      def to_decimal(number)
+        if number
+          num = number.to_s
+          num.empty? ? nil : BigDecimal.new(num)
+        else
+          nil
+        end
+      end
+
+      def divide(number, divisor)
+        result = number / divisor
+        result.nan? || result.infinite? ? 0 : result
+      end
+          
+    end
+    
+  end
+end