bitsor 0.1.0

data/lib/bitsor/client/trades.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Bitsor
+  class Client
+    module Trades
+      def trades(book:, marker: nil, sort: :desc, limit: 25)
+        normalize_response.with(:trade) do
+          get('/v3/trades/', book: book, marker: marker, sort: sort, limit: limit)
+        end
+      end
+    end
+  end
+end
+

data/lib/bitsor/client/user_trades.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Bitsor
+  class Client
+    module UserTrades
+      def user_trades(book:, marker: nil, sort: :desc, limit: 25)
+        normalize_response.with(:user_trade) do
+          get('/v3/user_trades/', book: book, marker: marker, sort: sort, limit: limit)
+        end
+      end
+    end
+  end
+end
+

data/lib/bitsor/client/withdrawals.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Bitsor
+  class Client
+    module Withdrawals
+      def withdrawals(limit: 25)
+        get('/v3/withdrawals/', limit: limit)
+      end
+    end
+  end
+end
+

data/lib/bitsor/client.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'bitsor/error'
+require 'bitsor/normalizer'
+
+require 'bitsor/concerns/configurable'
+require 'bitsor/concerns/rate_limit'
+require 'bitsor/concerns/connection'
+require 'bitsor/concerns/authorizable'
+
+require 'bitsor/client/account_status'
+require 'bitsor/client/available_books'
+require 'bitsor/client/balance'
+require 'bitsor/client/bitcoin_withdrawal'
+require 'bitsor/client/debit_card_withdrawal'
+require 'bitsor/client/ether_withdrawal'
+require 'bitsor/client/fees'
+require 'bitsor/client/funding'
+require 'bitsor/client/funding_destination'
+require 'bitsor/client/kyc_documents'
+require 'bitsor/client/ledger'
+require 'bitsor/client/mx_bank_codes'
+require 'bitsor/client/open_orders'
+require 'bitsor/client/order_book'
+require 'bitsor/client/order_trades'
+require 'bitsor/client/orders'
+require 'bitsor/client/phone_number'
+require 'bitsor/client/phone_number_withdrawal'
+require 'bitsor/client/phone_verification'
+require 'bitsor/client/spei_withdrawal'
+require 'bitsor/client/ticker'
+require 'bitsor/client/trades'
+require 'bitsor/client/user_trades'
+require 'bitsor/client/withdrawals'
+
+module Bitsor
+  class Client
+    include Bitsor::Configurable
+    include Bitsor::Connection
+    include Bitsor::Authorizable
+
+    include Bitsor::Client::AccountStatus
+    include Bitsor::Client::AvailableBooks
+    include Bitsor::Client::Balance
+    include Bitsor::Client::BitcoinWithdrawal
+    include Bitsor::Client::DebitCardWithdrawal
+    include Bitsor::Client::EtherWithdrawal
+    include Bitsor::Client::Fees
+    include Bitsor::Client::Funding
+    include Bitsor::Client::FundingDestination
+    include Bitsor::Client::KycDocuments
+    include Bitsor::Client::Ledger
+    include Bitsor::Client::MxBankCodes
+    include Bitsor::Client::OpenOrders
+    include Bitsor::Client::OrderBook
+    include Bitsor::Client::OrderTrades
+    include Bitsor::Client::Orders
+    include Bitsor::Client::PhoneNumber
+    include Bitsor::Client::PhoneNumberWithdrawal
+    include Bitsor::Client::PhoneVerification
+    include Bitsor::Client::SpeiWithdrawal
+    include Bitsor::Client::Ticker
+    include Bitsor::Client::Trades
+    include Bitsor::Client::UserTrades
+    include Bitsor::Client::Withdrawals
+
+    attr_writer :client_id
+    attr_writer :api_key
+    attr_writer :api_secret
+
+    def initialize(options = {})
+      Bitsor::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || Bitsor.instance_variable_get(:"@#{key}"))
+      end
+    end
+
+    def inspect
+      "Bitsor::Client(client_id: ****#{@client_id[4..-1]} api_key: ******#{@api_key[6..-1]}, object_id: #{format('0x00%x', (object_id << 1))})"
+    end
+
+    def normalize_response
+      @normalizer ||= Normalizer.new
+    end
+  end
+end
+

data/lib/bitsor/concerns/authorizable.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Bitsor
+  module Authorizable
+    def authenticated?
+      !!(@client_id && @api_key && @api_secret)
+    end
+  end
+end
+

data/lib/bitsor/concerns/configurable.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Bitsor
+  module Configurable
+    attr_accessor :client_id, :api_key, :api_secret
+
+    class << self
+      def keys
+        @keys ||= [
+          :client_id,
+          :api_key,
+          :api_secret,
+        ]
+      end
+    end
+
+    def configure
+      yield self
+    end
+
+    def reset!
+      Bitsor::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Bitsor::Default.options[key])
+      end
+      @last_response = nil
+      self
+    end
+    alias setup reset!
+
+    def api_endpoint
+      File.join(@api_endpoint, '')
+    end
+
+    private
+
+    def options
+      Hash[Bitsor::Configurable.keys.map { |key| [key, instance_variable_get(:"@#{key}")] }]
+    end
+  end
+end
+

data/lib/bitsor/concerns/connection.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'json'
+require 'openssl'
+require 'typhoeus'
+
+require 'bitsor/error'
+
+module Bitsor
+  module Connection
+    def get(url, options = {})
+      request :get, url, nil, parse_query(options)
+    end
+
+    def post(url, options = {})
+      request :post, url, parse_body(options)
+    end
+
+    def put(url, options = {})
+      request :put, url, parse_body(options)
+    end
+
+    def patch(url, options = {})
+      request :patch, url, parse_body(options)
+    end
+
+    def delete(url, options = {})
+      request :delete, url, parse_body(options)
+    end
+
+    def last_response
+      @last_response if defined? @last_response
+    end
+
+    protected
+
+    def endpoint
+      Bitsor::Default.api_endpoint
+    end
+
+    private
+
+    def request(method, path, body = nil, params = nil)
+      nonce = DateTime.now.strftime('%Q')
+      message = nonce + method.to_s.upcase + path + params.to_s + body.to_s
+      signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), api_secret, message)
+
+      url = "#{endpoint}#{path}#{params}"
+      request_options = {
+        method: method,
+        headers: {
+          Authorization: "Bitso #{api_key}:#{nonce}:#{signature}",
+          'Content-Type': 'application/json',
+        },
+      }
+      request_options[:body] = body
+      response = Typhoeus::Request.new(url, request_options).run
+      @last_response = response
+
+      complete_request(response)
+    end
+
+    def complete_request(response)
+      if error = Bitsor::Error.from_response(response)
+        raise error
+      end
+
+      JSON.parse(response.body, symbolize_names: true)[:payload]
+    end
+
+    def parse_query(options)
+      return nil if options.empty? || !options
+
+      options = options.select { |_key, value| !value.nil? || (value && !value.empty?) }
+      "?#{URI.encode_www_form(options)}"
+    end
+
+    def parse_body(options)
+      return '' if options.nil? || options.empty?
+      options = (options || {}).delete_if { |_k, v| v.nil? }
+      options.to_json
+    end
+  end
+end
+

data/lib/bitsor/concerns/rate_limit.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Bitsor
+  class RateLimit < Struct.new(:limit, :remaining, :resets_at, :resets_in)
+    def self.from_response(response)
+      info = new
+      unless response&.headers.nil?
+        info.limit = (response.headers['X-RateLimit-Limit'] || 1).to_i
+        info.remaining = (response.headers['X-RateLimit-Remaining'] || 1).to_i
+        info.resets_at = Time.at((response.headers['X-RateLimit-Reset'] || Time.now).to_i)
+        info.resets_in = [(info.resets_at - Time.now).to_i, 0].max
+      end
+
+      info
+    end
+  end
+end
+

data/lib/bitsor/default.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'bitsor/version'
+
+module Bitsor
+  module Default
+    API_ENDPOINT = 'https://api.bitso.com'
+
+    class << self
+      def options
+        Hash[Bitsor::Configurable.keys.map { |key| [key, send(key)] }]
+      end
+
+      def client_id
+        ENV['CLIENT_ID']
+      end
+
+      def api_key
+        ENV['API_KEY']
+      end
+
+      def api_secret
+        ENV['API_SECRET']
+      end
+
+      def api_endpoint
+        ENV['API_ENDPOINT'] || API_ENDPOINT
+      end
+    end
+  end
+end
+

data/lib/bitsor/error.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Bitsor
+  class Error < StandardError
+    def self.from_response(response)
+      status = response.response_code
+
+      if klass =  case status
+                  when 400      then Bitsor::BadRequest
+                  when 401      then Bitsor::Forbidden
+                  when 403      then Bitsor::Forbidden
+                  when 404      then Bitsor::NotFound
+                  when 405      then Bitsor::MethodNotAllowed
+                  when 406      then Bitsor::NotAcceptable
+                  when 422      then Bitsor::UnprocessableEntity
+                  when 400..499 then Bitsor::ClientError
+                  when 500      then Bitsor::InternalServerError
+                  when 501      then Bitsor::NotImplemented
+                  when 502      then Bitsor::BadGateway
+                  when 503      then Bitsor::ServiceUnavailable
+                  when 500..599 then Bitsor::ServerError
+                  end
+        klass.new(response)
+      end
+    end
+
+    def initialize(response = nil)
+      @response = response
+      @request = response.request
+      @body = { error: {} }
+
+      begin
+        if response.body && !response.body.empty?
+          @body = JSON.parse(response.body, symbolize_names: true)
+        end
+      rescue JSON::ParserError => e
+        @body = { error: { code: response.response_code, message: 'Internal Server Error: An Error Was Encountered' } }
+      end
+
+      super(build_error_message)
+    end
+
+    def build_error_message
+      return nil if @response.nil?
+      message =  ["#{@request.options[:method].to_s.upcase} "]
+      message << @response.options[:effective_url].to_s + "\n"
+      message << "Code #{@body[:error][:code]}: #{@body[:error][:message]} \n"
+      message.join
+    end
+
+    attr_accessor :response, :request, :body
+  end
+
+  # Raised on errors in the 400-499 range
+  class ClientError < Error; end
+
+  # Raised when 400 HTTP status code
+  class BadRequest < ClientError; end
+
+  # Raised when 401 HTTP status code
+  class Unauthorized < ClientError; end
+
+  # Raised when 403 HTTP status code
+  class Forbidden < ClientError; end
+
+  # Raised when 403 HTTP status code
+  class TooManyRequests < Forbidden; end
+
+  # Raised when 404 HTTP status code
+  class NotFound < ClientError; end
+
+  # Raised when 405 HTTP status code
+  class MethodNotAllowed < ClientError; end
+
+  # Raised when 406 HTTP status code
+  class NotAcceptable < ClientError; end
+
+  # Raised when 422 HTTP status code
+  class UnprocessableEntity < ClientError; end
+
+  # Raised on errors in the 500-599 range
+  class ServerError < Error; end
+
+  # Raised when 500 HTTP status code
+  class InternalServerError < ServerError; end
+
+  # Raised when 501 HTTP status code
+  class NotImplemented < ServerError; end
+
+  # Raised when 502 HTTP status code
+  class BadGateway < ServerError; end
+
+  # Raised when 503 HTTP status code
+  class ServiceUnavailable < ServerError; end
+end
+

data/lib/bitsor/normalizer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Bitsor
+  class Normalizer
+    SCHEMAS = {
+      account_balances: 'normalize_account_balances',
+      account_fees: 'normalize_account_fees',
+      account_status: 'normalize_account',
+      book: 'normalize_book',
+      funding: 'normalize_funding',
+      ledger: 'normalize_ledger',
+      order: 'normalize_order',
+      ticker: 'normalize_ticker',
+      trade: 'normalize_trade',
+      user_trade: 'normalize_user_trade',
+    }.freeze
+
+    def with(type)
+      method = SCHEMAS[type.to_sym] || :null_normalizer
+
+      response = yield
+
+      if response.class == Array
+        return response.map do |response_element|
+          send method, response_element
+        end
+      end
+
+      send method, response
+    end
+
+    private
+
+    def null_normalizer(response)
+      response
+    end
+
+    def normalize_account(response_object)
+      response_object[:client_id] = response_object[:client_id].to_i
+      response_object[:daily_limit] = response_object[:daily_limit].to_i
+      response_object[:monthly_limit] = response_object[:monthly_limit].to_i
+      response_object[:daily_remaining] = response_object[:daily_remaining].to_f
+      response_object[:monthly_remaining] = response_object[:monthly_remaining].to_f
+      response_object
+    end
+
+    def normalize_account_balances(response_object)
+      response_object[:balances] = response_object[:balances].map do |balance|
+        balance[:available] = balance[:available].to_f
+        balance[:locked] = balance[:locked].to_f
+        balance[:total] = balance[:total].to_f
+        balance[:pending_deposit] = balance[:pending_deposit].to_f
+        balance[:pending_withdrawal] = balance[:pending_withdrawal].to_f
+        balance
+      end
+      response_object
+    end
+
+    def normalize_book(response_object)
+      response_object[:minimum_price] = response_object[:minimum_price].to_f
+      response_object[:maximum_price] = response_object[:maximum_price].to_f
+      response_object[:minimum_amount] = response_object[:minimum_amount].to_f
+      response_object[:maximum_amount] = response_object[:maximum_amount].to_f
+      response_object[:minimum_value] = response_object[:minimum_value].to_f
+      response_object[:maximum_value] = response_object[:maximum_value].to_f
+      response_object
+    end
+
+    def normalize_account_fees(response_object)
+      response_object[:fees] = response_object[:fees].map do |fee|
+        fee[:fee_percent] = fee[:fee_percent].to_f
+        fee[:fee_decimal] = fee[:fee_decimal].to_f
+        fee
+      end
+      response_object[:withdrawal_fees][:btc] = response_object[:withdrawal_fees][:btc].to_f
+      response_object[:withdrawal_fees][:eth] = response_object[:withdrawal_fees][:eth].to_f
+      response_object
+    end
+
+    def normalize_funding(response_object)
+      response_object[:created_at] = DateTime.parse(response_object[:created_at])
+      response_object[:amount] = response_object[:amount].to_f
+      response_object
+    end
+
+    def normalize_order(response_object)
+      response_object[:original_amount] = response_object[:original_amount].to_f
+      response_object[:unfilled_amount] = response_object[:unfilled_amount].to_f
+      response_object[:original_value] = response_object[:original_value].to_f
+      response_object[:price] = response_object[:price].to_f
+      response_object[:created_at] = DateTime.parse(response_object[:created_at])
+      response_object[:updated_at] = DateTime.parse(response_object[:updated_at])
+      response_object
+    end
+
+    def normalize_ledger(response_object)
+      response_object[:created_at] = DateTime.parse(response_object[:created_at])
+      response_object[:balance_updates] = response_object[:balance_updates].map do |balance|
+        balance[:amount] = balance[:amount].to_f
+        balance
+      end
+      response_object
+    end
+
+    def normalize_ticker(response_object)
+      response_object[:volume] = response_object[:volume].to_f
+      response_object[:high] = response_object[:high].to_f
+      response_object[:last] = response_object[:last].to_f
+      response_object[:low] = response_object[:low].to_f
+      response_object[:vwap] = response_object[:vwap].to_f
+      response_object[:ask] = response_object[:ask].to_f
+      response_object[:bid] = response_object[:bid].to_f
+      response_object[:created_at] = DateTime.parse(response_object[:created_at])
+      response_object
+    end
+
+    def normalize_trade(response_object)
+      response_object[:amount] = response_object[:amount].to_f
+      response_object[:price] = response_object[:price].to_f
+      response_object[:created_at] = DateTime.parse(response_object[:created_at])
+      response_object
+    end
+
+    def normalize_user_trade(response_object)
+      response_object[:major] = response_object[:major].to_f
+      response_object[:minor] = response_object[:minor].to_f
+      response_object[:amount] = response_object[:amount].to_f
+      response_object[:fees_amount] = response_object[:fees_amount].to_f
+      response_object[:price] = response_object[:price].to_f
+      response_object[:tid] = response_object[:tid].to_i
+      response_object[:created_at] = DateTime.parse(response_object[:created_at])
+      response_object
+    end
+  end
+end
+

data/lib/bitsor/version.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Bitsor
+  # Current major release.
+  # @return [Integer]
+  MAJOR = 0
+
+  # Current minor release.
+  # @return [Integer]
+  MINOR = 1
+
+  # Current patch level.
+  # @return [Integer]
+  PATCH = 0
+
+  # Full release version.
+  # @return [String]
+  VERSION = [MAJOR, MINOR, PATCH].join('.').freeze
+end
+

data/lib/bitsor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bitsor/client'
+require 'bitsor/default'
+require 'bitsor/error'
+
+module Bitsor
+  class << self
+    include Bitsor::Configurable
+
+    def client
+      return @client if defined?(@client)
+      @client = Bitsor::Client.new(options)
+    end
+
+    private
+
+    def respond_to_missing?(method_name, include_private = false)
+      client.respond_to?(method_name, include_private)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if client.respond_to?(method_name)
+        return client.send(method_name, *args, &block)
+      end
+
+      super
+    end
+  end
+end
+
+Bitsor.setup
+