bibox 0.1.0

data/lib/bibox.rb

@@ -0,0 +1,74 @@
+# Rest API
+require "faraday"
+require "faraday_middleware"
+require "openssl"
+
+# Websockets
+require "faye/websocket"
+require "eventmachine"
+
+# Shared
+require "json"
+require "date"
+require "bigdecimal"
+
+# Library
+require "bibox/version"
+
+require "bibox/configuration"
+require "bibox/errors"
+require "bibox/constants"
+require "bibox/utilities"
+
+require "bibox/models/base"
+require "bibox/models/ticker"
+require "bibox/models/pair"
+require "bibox/models/trade"
+require "bibox/models/order_book"
+require "bibox/models/ohlcv"
+require "bibox/models/order"
+require "bibox/models/asset"
+require "bibox/models/user_assets"
+require "bibox/models/transfer"
+require "bibox/models/bill"
+
+require "bibox/rest/public/ticker"
+require "bibox/rest/public/pairs"
+require "bibox/rest/public/trades"
+require "bibox/rest/public/order_book"
+require "bibox/rest/public/klines"
+
+require "bibox/rest/private/orders"
+require "bibox/rest/private/order_book"
+require "bibox/rest/private/assets"
+require "bibox/rest/private/transfers"
+require "bibox/rest/private/bills"
+
+require "bibox/rest/errors"
+require "bibox/rest/client"
+
+require "bibox/websocket/client"
+
+if !String.instance_methods(false).include?(:underscore)
+  require "bibox/extensions/string"
+end
+
+module Bibox
+  
+  class << self
+    attr_writer :configuration
+  end
+  
+  def self.configuration
+    @configuration ||= ::Bibox::Configuration.new
+  end
+
+  def self.reset
+    @configuration = ::Bibox::Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+end

data/lib/bibox/configuration.rb

@@ -0,0 +1,21 @@
+module Bibox
+  class Configuration
+    attr_accessor :key, :secret, :faraday
+    
+    def initialize
+      self.key              =   nil
+      self.secret           =   nil
+      
+      self.faraday          =   {
+        adapter:    :net_http,
+        user_agent: 'Bibox Ruby',
+        verbose:    false
+      }
+    end
+    
+    def verbose_faraday?
+      self.faraday.fetch(:verbose, false)
+    end
+    
+  end
+end

data/lib/bibox/constants.rb

@@ -0,0 +1,6 @@
+module Bibox
+  module Constants
+    BUY_ORDER   =   1
+    SELL_ORDER  =   2
+  end
+end

data/lib/bibox/errors.rb

@@ -0,0 +1,17 @@
+module Bibox
+  module Errors
+    class Error < StandardError; end;
+    class MissingConfigError < Bibox::Errors::Error; end;
+    class ParameterError < Bibox::Errors::Error; end;
+    class InvalidOrderError < Bibox::Errors::Error; end;
+    class ApiNotSupportedError < Bibox::Errors::Error; end;
+    class WebsocketError < Bibox::Errors::Error; end;
+    
+    MAPPING = {
+      "2033" => -> { raise ::Bibox::Errors::InvalidOrderError.new("Order operation failed! Order has already completed or has already been revoked (code 2033)") },
+      "3000" => -> { raise ::Bibox::Errors::ParameterError.new("Invalid parameters specified (code 3000)") },
+      "3011" => -> { raise ::Bibox::Errors::ApiNotSupportedError.new("This method isn't available via the API (code 3011)") },
+    }
+    
+  end
+end

data/lib/bibox/extensions/string.rb

@@ -0,0 +1,13 @@
+class String
+  
+  def underscore
+    word = self.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+  
+end

data/lib/bibox/models/asset.rb

@@ -0,0 +1,29 @@
+module Bibox
+  module Models
+    class Asset < Base      
+      MAPPING     =   {
+        id:                 :string,
+        symbol:             :string,
+        icon_url:           :string,
+        describe_url:       :string,
+        name:               :string,
+        enable_withdraw:    :boolean,
+        enable_deposit:     :boolean,
+        confirm_count:      :integer,
+        total_balance:      :float,
+        balance:            :float,
+        freeze:             :float,
+        btc_value:          :float,
+        cny_value:          :float,
+        usd_value:          :float
+      }
+      
+      def initialize(hash)
+        super(hash)
+        
+        self.symbol   =   hash.fetch("coin_symbol", nil) if self.symbol.to_s.empty? && hash.has_key?("coin_symbol")
+      end
+      
+    end
+  end
+end

data/lib/bibox/models/base.rb

@@ -0,0 +1,26 @@
+module Bibox
+  module Models
+    class Base
+      
+      def initialize(hash)
+        self.class::MAPPING.keys.each { |key| self.class.send(:attr_accessor, key) }
+        
+        hash.each do |key, value|
+          key             =     key.underscore.to_sym
+          type            =     self.class::MAPPING.fetch(key, nil)
+          value           =     value && type ? ::Bibox::Utilities::convert_value(value, type, use_ms_for_time: true) : value
+          self.send("#{key}=", value) if self.respond_to?(key)
+        end
+      end
+      
+      def attributes
+        Hash[instance_variables.map { |name| [name.to_s.gsub(/^@/, "").to_sym, instance_variable_get(name)] }]
+      end
+      
+      def self.parse(data)
+        data&.collect { |item| self.new(item) }
+      end
+      
+    end
+  end
+end

data/lib/bibox/models/bill.rb

@@ -0,0 +1,26 @@
+module Bibox
+  module Models
+    class Bill < Base
+      MAPPING  =   {
+        created_at:    :datetime,
+        symbol:        :string,
+        change_amount: :float,
+        result_amount: :float,
+        fee:           :float,
+        fee_symbol:    :string,
+        comment:       :string,
+        bill_type:     {enum: {-1 => :all, 0 => :deposit, 2 => :withdrawal, 3 => :sell, 5 => :buy, 31 => :transfer_in, 32 => :transfer_out}},
+      }
+      
+      BILL_TYPES     =   {
+        all:          -1,
+        deposit:      0,
+        withdrawal:   2,
+        sell:         3,
+        buy:          5,
+        transfer_in:  31,
+        transfer_out: 32
+      }
+    end
+  end
+end

data/lib/bibox/models/ohlcv.rb

@@ -0,0 +1,16 @@
+module Bibox
+  module Models
+    class OHLCV < Base
+      
+      MAPPING   =   {
+        time:   :time,
+        open:   :float,
+        high:   :float,
+        low:    :float,
+        close:  :float,
+        vol:    :float
+      }
+
+    end
+  end
+end

data/lib/bibox/models/order.rb

@@ -0,0 +1,38 @@
+module Bibox
+  module Models
+    class Order < Base      
+      MAPPING   =   {
+        id:                :string,
+        created_at:        :time,
+        account_type:      :integer,
+        coin_symbol:       :string,
+        currency_symbol:   :string,
+        fee_symbol:        :string,
+        order_side:        {enum: {1 => :buy, 2 => :sell}},
+        order_type:        :integer,
+        price:             :float,
+        amount:            :float,
+        money:             :float,
+        fee:               :float,
+        pay_bix:           :boolean,
+        deal_price:        :float,
+        deal_amount:       :float,
+        deal_money:        :float,
+        deal_percent:      :string,
+        status:            :integer,
+        unexecuted:        :float
+      }
+      
+      ORDER_SIDES     =   {
+        buy:  1,
+        sell: 2
+      }
+      
+      ORDER_TYPES     =   {
+        market: 1, # NOT VERIFIED! There's no API documentation so it's just a guess for now.
+        limit: 2
+      }
+      
+    end
+  end
+end

data/lib/bibox/models/order_book.rb

@@ -0,0 +1,29 @@
+module Bibox
+  module Models
+    class OrderBook
+      attr_accessor :pair, :update_time, :asks, :bids
+    
+      def initialize(hash)
+        self.pair           =   hash.fetch("pair", nil)
+        self.update_time    =   ::Bibox::Utilities.epoch_to_time(hash.fetch("update_time", nil), ms: true) if hash.has_key?("update_time") && !hash.fetch("update_time", nil).to_s.empty?
+        
+        self.bids           =   []
+        self.asks           =   []
+
+        process(hash)
+      end
+      
+      def process(hash)
+        [:bids, :asks].each do |type|
+          hash.fetch(type.to_s, []).each do |item|
+            price     =   ::Bibox::Utilities.convert_value(item.fetch("price", nil), :float)
+            volume    =   ::Bibox::Utilities.convert_value(item.fetch("volume", nil), :float)
+            value     =   !price.nil? && !volume.nil? ? price * volume : nil
+            self.send(type).send(:<<, {price: price, volume: volume, value: value})
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/bibox/models/pair.rb

@@ -0,0 +1,24 @@
+module Bibox
+  module Models
+    class Pair < Base      
+      MAPPING     =   {
+        id:                :string,
+        coin_symbol:       :string,
+        currency_symbol:   :string,
+        high:              :float,
+        low:               :float,
+        last:              :float,
+        vol24h:            :float,
+        amount:            :float,
+        change:            :string,
+        percent:           :string,
+        low_cny:           :float,
+        high_cny:          :float,
+        last_cny:          :float,
+        low_usd:           :float,
+        high_usd:          :float,
+        last_usd:          :float
+      }
+    end
+  end
+end

data/lib/bibox/models/ticker.rb

@@ -0,0 +1,18 @@
+module Bibox
+  module Models
+    class Ticker < Base
+      MAPPING  =   {
+        buy:         :float,
+        sell:        :float,
+        high:        :float,
+        low:         :float,
+        last:        :float,
+        vol:         :float,
+        timestamp:   :time,
+        last_cny:    :float,
+        last_usd:    :float,
+        percent:     :string,
+      }
+    end
+  end
+end

data/lib/bibox/models/trade.rb

@@ -0,0 +1,13 @@
+module Bibox
+  module Models
+    class Trade < Base
+      MAPPING   =   {
+        pair:      :string,
+        price:     :float,
+        amount:    :float,
+        time:      :time,
+        side:      {enum: {1 => :buy, 2 => :sell}}
+      }
+    end
+  end
+end

data/lib/bibox/models/transfer.rb

@@ -0,0 +1,26 @@
+module Bibox
+  module Models
+    class Transfer < Base
+      MAPPING  =   {
+        user_id:        :string,
+        coin_id:        :string,
+        to:             :string,
+        coin_symbol:    :string,
+        confirm_count:  :string,
+        amount:         :float,
+        updated_at:     :datetime,
+        created_at:     :datetime,
+        url:            :string,
+        icon_url:       :string,
+        status:         {enum: {1 => :pending, 2 => :success, 3 => :failed}},
+      }
+      
+      STATUSES     =   {
+        all:      0,
+        pending:  1,
+        success:  2,
+        failed:   3
+      }
+    end
+  end
+end

data/lib/bibox/models/user_assets.rb

@@ -0,0 +1,23 @@
+module Bibox
+  module Models
+    class UserAssets < Base      
+      attr_accessor :assets
+      
+      MAPPING     =   {
+        total_btc:      :float,
+        total_cny:      :float,
+        total_usd:      :float,
+      }
+      
+      def initialize(hash)
+        super(hash)
+        process(hash.fetch("assets_list", []))
+      end
+      
+      def process(assets)
+        self.assets   =   ::Bibox::Models::Asset.parse(assets)
+      end
+      
+    end
+  end
+end

data/lib/bibox/rest/client.rb

@@ -0,0 +1,97 @@
+module Bibox
+  module Rest
+    class Client
+      attr_accessor :url, :configuration
+      
+      def initialize(configuration: ::Bibox.configuration)
+        self.url              =   "https://api.bibox.com/v1"
+        self.configuration    =   configuration
+      end
+      
+      include ::Bibox::Rest::Errors
+      
+      include ::Bibox::Rest::Public::Ticker
+      include ::Bibox::Rest::Public::Pairs
+      include ::Bibox::Rest::Public::Trades
+      include ::Bibox::Rest::Public::OrderBook
+      include ::Bibox::Rest::Public::Klines
+      
+      include ::Bibox::Rest::Private::Orders
+      include ::Bibox::Rest::Private::OrderBook
+      include ::Bibox::Rest::Private::Assets
+      include ::Bibox::Rest::Private::Transfers
+      include ::Bibox::Rest::Private::Bills
+            
+      def configured?
+        !self.configuration.key.to_s.empty? && !self.configuration.secret.to_s.empty?
+      end
+
+      def check_credentials!
+        unless configured?
+          raise ::Bibox::Errors::MissingConfigError.new("Bibox gem hasn't been properly configured.")
+        end
+      end
+      
+      def to_uri(path)
+        "#{self.url}#{path}"
+      end
+      
+      def parse(response)
+        error?(response)
+        response
+      end
+
+      def get(path, params: {}, options: {})
+        request path, method: :get, params: params, options: options
+      end
+
+      def post(path, params: {}, data: {}, options: {})
+        request path, method: :post, params: params, data: auth(data), options: options
+      end
+
+      def auth(payload = {})
+        data              =   {}
+        data[:cmds]       =   payload.to_json
+        
+        if configured?
+          data[:apikey]   =   self.configuration.key
+          data[:sign]     =   ::OpenSSL::HMAC.hexdigest('md5', self.configuration.secret, payload.to_json)
+        end
+        
+        return data
+      end
+
+      def request(path, method: :get, params: {}, data: {}, options: {})
+        user_agent    =   options.fetch(:user_agent, self.configuration.faraday.fetch(:user_agent, nil))
+        proxy         =   options.fetch(:proxy, nil)
+    
+        connection    =   Faraday.new(url: to_uri(path)) do |builder|
+          builder.headers[:user_agent] = user_agent if !user_agent.to_s.empty?
+          builder.request  :url_encoded if method.eql?(:post)
+          builder.response :logger      if self.configuration.verbose_faraday?
+          builder.response :json
+      
+          if proxy
+            puts "[Bibox::Rest::Client] - Will connect to Bibox using proxy: #{proxy.inspect}" if self.configuration.verbose_faraday?
+            builder.proxy = proxy
+          end
+      
+          builder.adapter self.configuration.faraday.fetch(:adapter, :net_http)
+        end
+    
+        case method
+          when :get
+            connection.get do |request|
+              request.params  =   params if params && !params.empty?
+            end&.body
+          when :post
+            connection.post do |request|
+              request.body    =   data
+              request.params  =   params if params && !params.empty?
+            end&.body
+        end
+      end
+            
+    end
+  end  
+end