bitx 0.0.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13e2a9513a9793a95cc11fd1825af4c4ba821bf9
-  data.tar.gz: 7670ffa8ccc8785f061c4668a76705593eead385
+  metadata.gz: 8ac15c7b8200f1a0e442f57519cd1c4260f75ede
+  data.tar.gz: d10b5772fc1e4007d259dee8e90aa9deb6d23c50
 SHA512:
-  metadata.gz: d999d9f6c64075e20a20844f6a68af0fa5f590fef835d69972696af90884e3cf7da1369e35fd6d1d5f690333b9ab40d2caf0fd47318d2d733605cd951e2ac461
-  data.tar.gz: 21dc0f53de29a64685022567a7da2947f1d01b1d1244b0f8de6d408a6cd90b90fe3eefbc8d3436be9e6fbed56283dc9515baa7b92b7f5a1ff4de06cc346c92cf
+  metadata.gz: 0773b9dc8addb3b2e91cde75a5667570abdc323f7411e5f5fb719f4ecc23977cbc92413e3ef76129882f6a240e7826f4249a5c62dd8657a3b5a31d10efe7fc96
+  data.tar.gz: 8ddebbce2e27a8942e1dd9a45bd7ab26def4a9c40918d3b9b258c54fb2f772ebfeedcdcd8f786e1a05abd1d973779a4fdb1e240b026d84cbef4d62d71d414127

data/README.md

@@ -2,8 +2,9 @@
 
 Ruby wrapper for the BitX API.
 
-Currently the public API (ticker, orderbook, trades) is wrapped.
-TODO: Add the private API.
+## Rate limits
+
+If rate limits are exceeded BitX will return a 503 error. Make sure your code handles that appropriately.
 
 ## Installation
 
@@ -24,14 +25,75 @@ Or install it yourself as:
 ```
 require 'bitx'
 
+```
+Public API usage
+
+```
+
 # Fetch the ticker
-BitX.new.ticker('XBTZAR')
+BitX.ticker('XBTZAR')
 
 # Fetch the order book
-BitX.new.orderbook('XBTZAR')
+BitX.orderbook('XBTZAR')
 
 # Fetch the latest trades
-BitX.new.trades('XBTZAR')
+BitX.trades('XBTZAR')
+
+```
+
+Private API usage
+
+```
+# In a configure block somewhere in your app init:
+BitX.configure do |config|
+  config.api_key_secret = 'yoursecretkeyfrombitx'
+  config.api_key_id = 'yourapiidfrombitx'
+  config.api_key_pin = 'yourapikeypinfrombitx'
+end
+
+# Your Bitcoin balance
+BitX.balance_for 'XBT'
+
+# Your Rand balance
+BitX.balance_for 'ZAR'
+
+# List your orders trading Bitcoin for Rand
+BitX.list_orders 'XBTZAR'
+
+# Place a new order
+# BitX::ORDERTYPE_BID / BitX::ORDERTYPE_ASK
+volume = '0.01'
+price = '10000'
+BitX.post_order(BitX::ORDERTYPE_BID, volume, price, 'XBTZAR')
+
+
+#alternatively, if you need to change the api_key during the program you can pass options to the private methods specifying the :api_key_secret and :api_key_id
+BitX.balance_for('XBT', {api_key_secret: 'yoursecretkeyfrombitx', api_key_id: 'yourapiidfrombitx'})
+
+
+
+
+```
+
+
+Connection object
+
+```
+  # if you need to access the BitX api with different credentials in a concurrent system, you can use the BitX::Connection object
+
+  #if config changes:
+  bit_x = BitX::Connection.new() do |config|
+    config.api_key_secret = 'yoursecretkeyfrombitx'
+    config.api_key_id = 'yourapiidfrombitx'
+    config.api_key_pin = 'yourapikeypinfrombitx'
+  end
+  bit_x.balance
+
+  #if you want to use a mocked connection
+  bitx = BitX::Connection.new(stubbed_connection)
+  bitx.tickers
+
+
 ```
 
 ## Contributing
@@ -41,3 +103,28 @@ BitX.new.trades('XBTZAR')
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+
+## Changelog
+
+```
+# 0.2.1 - force place order to specify price in integers
+# 0.2.0 - adds a connection object to support concurrent systems where the connection or configuration objects may change
+# 0.1.0 - adds a number of methods. introduces some breaking changes to existing methods.
+  add support for public method *tickers* to get all bitx tickers
+  add volume to *ticker* response to be the 24_hour_rolling_volume
+  add timestamp to *orderbook* response
+  deprecate *balance_for*
+  add *balance* to return a list of accounts with balances
+  add *new_receive_address*
+  add *received_by_address*
+  modify *funding_address*
+  deprecate *funding_address*
+  add *send* method
+  add *api_key_pin* config option
+  add *create_quote*
+  add *exercise_quote*
+  add *discard_quote*
+  add *view_quote*
+  add basic tests
+```

data/Rakefile

@@ -1 +1,8 @@
 require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end

data/bitx.gemspec

@@ -2,14 +2,16 @@
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
+require_relative 'lib/version'
+
 Gem::Specification.new do |spec|
   spec.name          = "bitx"
-  spec.version       = '0.0.1'
-  spec.authors       = ["Timothy Stranex"]
-  spec.email         = ["timothy@switchless.com"]
+  spec.version       = BitX::VERSION::STRING.dup
+  spec.authors       = ["Timothy Stranex","Francois Paul"]
+  spec.email         = ["timothy@bitx.co","franc@bitx.co"]
   spec.description   = 'BitX API wrapper'
   spec.summary       = 'Ruby wrapper for the BitX API'
-  spec.homepage      = "https://mybitx.com/api"
+  spec.homepage      = "https://bitx.co/api"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -19,5 +21,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
   spec.add_runtime_dependency 'faraday'
 end

data/lib/bitx.rb

@@ -1,75 +1,63 @@
 require 'faraday'
 require 'json'
 require 'bigdecimal'
+require_relative 'public_api'
+require_relative 'private_api'
+require_relative 'version'
 
-class BitX
-
-  class Error < StandardError
+module BitX
+  class Configuration
+    attr_accessor :api_key_id, :api_key_secret, :api_key_pin
   end
 
-  def ticker(pair)
-    t = get('/api/1/ticker', {pair: pair})
-    {
-      pair: pair,
-      timestamp: Time.at(t["timestamp"].to_i/1000),
-      ask: BigDecimal(t["ask"]),
-      bid: BigDecimal(t["bid"]),
-      last: BigDecimal(t["last_trade"]),
-    }
+  def self.configuration
+    @configuration ||=  Configuration.new
   end
 
-  def orderbook(pair)
-    t = get('/api/1/orderbook', {pair: pair})
+  def self.configure
+    yield(configuration) if block_given?
+  end
 
-    bids = []
-    t['bids'].each do |o|
-      bids << {
-        price: BigDecimal(o['price']),
-        volume: BigDecimal(o['volume'])
-      }
-    end
+  class Error < StandardError
+  end
 
-    asks = []
-    t['asks'].each do |o|
-      asks << {
-        price: BigDecimal(o['price']),
-        volume: BigDecimal(o['volume'])
-      }
-    end
+  extend PublicApi
+  extend PrivateApi
 
-    return {bids: bids, asks: asks}
+  def self.set_conn(conn=nil)
+    @conn = conn || BitX.conn
   end
 
-  def trades(pair)
-    t = get('/api/1/trades', {pair: pair})
-    trades = []
-    t['trades'].each do |trade|
-      trades << {
-        timestamp: Time.at(trade['timestamp'].to_i/1000),
-        price: BigDecimal(trade['price']),
-        volume: BigDecimal(trade['volume'])
-      }
-    end
-    trades
+  def self.conn
+    return @conn if @conn
+    @conn = Faraday.new(url: 'https://api.mybitx.com')
+    @conn.headers[:user_agent] = "bitx-ruby/#{BitX::VERSION::STRING}"
+    @conn
   end
 
-private
 
-  def conn
-    conn = Faraday.new(url: 'https://bitx.co.za')
-    conn.headers[:user_agent] = "bitx-ruby/0.0.1"
-    conn
-  end
+  #connection object to be used in concurrent systems where connections and configurations might differ
+  class Connection
+    include PublicApi
+    include PrivateApi
+    attr_accessor :configuration, :conn
+
+    def initialize(connection=nil)
+      @conn = connection || BitX.conn
+      @configuration = BitX.configuration
+      yield(@configuration) if block_given?
+    end
 
-  def get(url, params)
-    r = conn.get(url, params)
-    if r.status != 200
-      raise BitX::Error.new("BitX error: #{r.status}")
+    def self.conn
+      @conn
     end
-    t = JSON.parse r.body
-    if t['error']
-      raise BitX::Error.new('BitX error: ' + t['error'])
+
+    def self.get(url, params=nil)
+      get(url, params)
+    end
+
+    def self.configuration
+      @configuration
     end
-    t
   end
 end

data/lib/private_api.rb

@@ -0,0 +1,289 @@
+module PrivateApi
+
+  class BitXError < StandardError
+  end
+
+  # <----- ORDERS .
+
+  #List Orders
+  def list_orders(pair, opt={})
+    opt.merge!({pair: pair})
+    path = '/api/1/listorders'
+    r = authed_request(path, {params: opt})
+    j = JSON.parse(r.body, {symbolize_names: true})
+
+    ol = []
+    if j[:orders]
+      j[:orders].each do |bo|
+        ol << format_order_hash(bo)
+      end
+    end
+    ol
+  end
+
+  #Post Order
+  #order_type 'BID'/'ASK'
+  def post_order(order_type, volume, price, pair, opt={})
+    params = {
+      pair: pair,
+      type: order_type,
+      volume: volume.to_d.round(6).to_f.to_s,
+      price: price.to_f.round.to_s
+    }
+    opt.merge!({params: params, method: :post})
+    path = '/api/1/postorder'
+    r = authed_request(path, opt)
+    j = JSON.parse(r.body, {symbolize_names: true})
+    raise BitXError.new("BitX postorder error: #{j['error']}") if j['error']
+    j
+  end
+
+  #Stop Order
+  def stop_order(order_id, opt={})
+    options = {params: opt.merge!({order_id: order_id}), method: :post}
+    path = '/api/1/stoporder'
+    r = authed_request(path, options)
+    JSON.parse(r.body, {symbolize_names: true})
+  end
+
+  #Get Order
+  def get_order(order_id, opt={})
+    path = "/api/1/orders/#{order_id}"
+    r = authed_request(path, {params: opt})
+    o = JSON.parse(r.body, {symbolize_names: true})
+
+    format_order_hash(o)
+  end
+
+  def format_order_hash(o)
+    {
+      completed:    o[:state] == 'COMPLETE',
+      state:        o[:state],
+      created_at:   Time.at(o[:creation_timestamp].to_i/1000),
+      expires_at:   Time.at(o[:expiration_timestamp].to_i/1000),
+      order_id:     o[:order_id],
+      limit_price:  BigDecimal(o[:limit_price]),
+      limit_volume: BigDecimal(o[:limit_volume]),
+      base:         BigDecimal(o[:base]),
+      fee_base:     BigDecimal(o[:fee_base]),
+      counter:      BigDecimal(o[:counter]),
+      fee_counter:  BigDecimal(o[:fee_counter]),
+      type:         o[:type].to_sym
+    }
+  end
+
+  # ORDERS -----/>
+
+
+
+
+  # <----- BALANCE .
+
+  #Balance
+  def balance_for(asset='XBT', opt={})
+    puts "BitX.balance_for will be deprecated. please use BitX.balance to get a list of account balances"
+    opt.merge!({asset: asset})
+    path = '/api/1/balance'
+    r = authed_request(path, {params: opt})
+    j = JSON.parse(r.body)
+    raise BitXError.new("BitX balance error: #{j['error']}") if j['error']
+    balance = BigDecimal(j['balance'][0]['balance'])
+    reserved = BigDecimal(j['balance'][0]['reserved'])
+    {
+      asset:      asset,
+      balance:    balance,
+      reserved:   reserved,
+      available:  balance - reserved
+    }
+  end
+
+  def balance(opt={})
+    path = '/api/1/balance'
+    r = authed_request(path, opt)
+    j = JSON.parse(r.body)
+
+    balances = []
+    if j['balance']
+      j['balance'].each do |b|
+        balance     = BigDecimal(b['balance'])
+        reserved    = BigDecimal(b['reserved'])
+        balances << {
+          account_id:  b['account_id'],
+          asset:       b['asset'],
+          balance:     balance,
+          reserved:    reserved,
+          available:   balance - reserved,
+          unconfirmed: BigDecimal(b['unconfirmed'])
+        }
+      end
+    end
+    balances
+  end
+
+  # BALANCE -----/>
+
+
+
+  # <----- receive addresses .
+  def new_receive_address(opt={})
+    receive_address_request(opt, :post)
+  end
+
+  # if you have multiple XBT accounts you can specify an `address` option with the funding address
+  def received_by_address(opt={})
+    receive_address_request(opt, :get)
+  end
+
+  def receive_address_request(opt, method)
+    opt.merge!({asset: 'XBT'})
+    path = '/api/1/funding_address'
+    r = authed_request(path, {params: opt, method: method})
+    JSON.parse(r.body, {symbolize_names: true})
+  end
+
+  #Bitcoin Funding Address
+  def funding_address(asset='XBT', opt={})
+    puts "BitX.funding_address will be deprecated. please use BitX.received_by_address with a specified :address option to get details for that address"
+    opt.merge!({asset: asset})
+    receive_address_request(opt, :get)
+  end
+  # receive addresses -----/>
+
+
+  # <----- withdrawal requests .
+  def withdrawals
+    path = '/api/1/withdrawals'
+    r = authed_request(path, {params: {}, method: :get})
+    j = JSON.parse(r.body, {symbolize_names: true})
+
+    return j[:withdrawals] if j[:withdrawals]
+    return j
+  end
+
+  def withdraw(type, amount)
+    # valid types
+    # ZAR_EFT,NAD_EFT,KES_MPESA,MYR_IBG,IDR_LLG
+
+    path = '/api/1/withdrawals'
+    r = authed_request(path, {params: {type: type, amount: amount}, method: :post})
+    JSON.parse(r.body, {symbolize_names: true})
+  end
+
+  def withdrawal(withdrawal_id)
+    path = "/api/1/withdrawals/#{withdrawal_id}"
+    r = authed_request(path, {params: {}, method: :get})
+    JSON.parse(r.body, {symbolize_names: true})
+  end
+
+  def cancel_withdrawal(withdrawal_id)
+    path = "/api/1/withdrawals/#{withdrawal_id}"
+    r = authed_request(path, {params: {}, method: :delete})
+    JSON.parse(r.body, {symbolize_names: true})
+  end
+  # withdrawal requests -----/>
+
+
+  # <------- send .
+
+  def send(amount, address, currency='XBT', description='', message='', pin=nil)
+    # valid types
+    # ZAR_EFT,NAD_EFT,KES_MPESA,MYR_IBG,IDR_LLG
+
+    pin ||= self.configuration.api_key_pin rescue nil
+
+    path = '/api/1/send'
+    r = authed_request(path, {
+      params: {
+        amount: amount.to_s,
+        address: address,
+        currency: currency,
+        description: description,
+        message: message,
+        pin: pin
+      },
+      method: :post
+    })
+    JSON.parse(r.body, {symbolize_names: true})
+  end
+
+  # send ------/>
+
+
+  # <------- quotes .
+
+  def create_quote(pair, base_amount, type)
+    #POST
+    path = '/api/1/quotes'
+    r = authed_request(path, {params: {type: type, pair: pair, base_amount: base_amount}, method: :post})
+    extract_quote_from_body(r.body)
+  end
+
+  def exercise_quote(quote_id, pin=nil)
+    #PUT
+    pin ||= self.configuration.api_key_pin rescue nil
+    path = "/api/1/quotes/#{quote_id}"
+    r = authed_request(path, {
+      params: {
+        pin: pin
+      },
+      method: :put})
+    extract_quote_from_body(r.body)
+  end
+
+  def discard_quote(quote_id)
+    #DELETE
+    path = "/api/1/quotes/#{quote_id}"
+    r = authed_request(path, {method: :delete})
+    extract_quote_from_body(r.body)
+  end
+
+  def view_quote(quote_id)
+    #GET
+    path = "/api/1/quotes/#{quote_id}"
+    r = authed_request(path, {method: :get})
+    extract_quote_from_body(r.body)
+  end
+
+  def extract_quote_from_body(body)
+    quote = JSON.parse(body, {symbolize_names: true})
+    return nil unless quote
+    quote[:created_at] = Time.at(quote[:created_at]/1000) if quote[:created_at]
+    quote[:expires_at] = Time.at(quote[:expires_at]/1000) if quote[:expires_at]
+    quote
+  end
+
+  # quotes ------/>
+
+
+
+  def api_auth(opt={})
+    api_key_id = opt[:api_key_id] || self.configuration.api_key_id
+    api_key_secret = opt[:api_key_secret] || self.configuration.api_key_secret
+    conn = self.conn
+    conn.basic_auth(api_key_id, api_key_secret)
+    conn
+  end
+
+  # opt can specify the method to be :post, :put, :delete
+  # opt can specify request params in :params
+  # opt could also include the api_key_id and api_key_secret
+  def authed_request(path, opt={})
+    method = opt[:method] || :get
+    conn = self.api_auth(opt)
+    r = case method
+    when :get
+      conn.get(path, opt[:params])
+    when :post
+      conn.post(path, opt[:params])
+    when :put
+      conn.put(path, opt[:params])
+    when :delete
+      conn.delete(path, opt[:params])
+    else
+      raise BitXError.new("Request must be :post or :get")
+    end
+    raise BitXError.new("BitX #{path} error: #{r.status}") unless r.status == 200
+    r
+  end
+
+end