kraken_client 0.2.0

data/lib/kraken_client/requests/content/body.rb

@@ -0,0 +1,18 @@
+module KrakenClient
+  module Requests
+    module Content
+      class Body
+
+        attr_reader :post_data
+
+        def initialize(post_data)
+          @post_data = post_data
+        end
+
+        def call
+          post_data
+        end
+      end
+    end
+  end
+end

data/lib/kraken_client/requests/content/header.rb

@@ -0,0 +1,61 @@
+module KrakenClient
+  module Requests
+    module Content
+      class Header
+
+        attr_accessor :config, :endpoint_name, :options, :url
+
+        def initialize(config, endpoint_name, options, url)
+          @config          = config
+          @endpoint_name   = endpoint_name
+          @url             = url
+
+          @options         = options
+          @options[:nonce] = nonce
+        end
+
+        def call
+          {
+            'API-Key' => config.api_key,
+            'API-Sign' => generate_signature,
+          }
+        end
+
+        private
+
+        ## Security
+
+        # Generate a 64-bit nonce where the 48 high bits come directly from the current
+        # timestamp and the low 16 bits are pseudorandom. We can't use a pure [P]RNG here
+        # because the Kraken API requires every request within a given session to use a
+        # monotonically increasing nonce value. This approach splits the difference.
+        def nonce
+          high_bits = (Time.now.to_f * 10000).to_i << 16
+          low_bits  = SecureRandom.random_number(2 ** 16) & 0xffff
+          (high_bits | low_bits).to_s
+        end
+
+        def encoded_options
+          uri = Addressable::URI.new
+          uri.query_values = options
+          uri.query
+        end
+
+        def generate_signature
+          key = Base64.decode64(config.api_secret)
+          message = generate_message
+          generate_hmac(key, message)
+        end
+
+        def generate_message
+          digest = OpenSSL::Digest.new('sha256', options[:nonce] + encoded_options).digest
+          url.split('.com').last + digest
+        end
+
+        def generate_hmac(key, message)
+          Base64.strict_encode64(OpenSSL::HMAC.digest('sha512', key, message))
+        end
+      end
+    end
+  end
+end

data/lib/kraken_client/requests/get.rb

@@ -0,0 +1,13 @@
+module KrakenClient
+  module Requests
+    class Get < Base
+
+      def call(url, params, *)
+        super
+
+        HTTParty.get(url, query: params)
+      end
+
+    end
+  end
+end

data/lib/kraken_client/requests/limiter.rb

@@ -0,0 +1,78 @@
+module KrakenClient
+  module Requests
+    class Limiter
+
+      attr_reader :config, :previous_timestamps, :endpoint_name, :current_count
+
+      def initialize(config)
+        @config              = config
+        @previous_timestamps = Time.now
+        @current_count       = counter_total
+      end
+
+      def update(endpoint_name)
+        return unless config.limiter
+        @endpoint_name = endpoint_name
+
+        decrement_current_count
+      end
+
+      private
+
+      # Adds the number of seconds depending of the current tier value
+      def refresh_current_count
+        @current_count += ((Time.now - previous_timestamps) / seconds_to_decrement).to_int
+        @current_count = counter_total if current_count > counter_total
+
+        current_count
+      end
+
+      def decrement_current_count
+        @current_count -= value_to_decrement
+
+        if current_count < 0
+          sleep value_to_decrement
+
+          @current_count = value_to_decrement
+
+          update(endpoint_name)
+        else
+          refresh_current_count
+
+          @previous_timestamps = Time.now
+        end
+      end
+
+      def value_to_decrement
+
+        case endpoint_name
+          when 'Ledger'        then 2
+          when 'TradeHistory'  then 2
+          when 'AddOrder'      then 0
+          when 'CancelOrder'   then 0
+          else                      1
+        end          
+      end
+
+      def counter_total
+        @counter ||= case config.tier
+          when 0 then 10
+          when 1 then 10
+          when 2 then 10
+          when 3 then 20
+          when 4 then 20
+        end
+      end
+
+      def seconds_to_decrement
+        @decrement ||= case config.tier
+          when 0 then 5
+          when 1 then 5
+          when 2 then 5
+          when 3 then 2
+          when 4 then 1
+        end
+      end
+    end
+  end
+end

data/lib/kraken_client/requests/post.rb

@@ -0,0 +1,38 @@
+module KrakenClient
+  module Requests
+    class Post < Base
+
+      def call(url, endpoint_name, options)
+        super
+
+        @url           = url
+        @endpoint_name = endpoint_name
+
+        response       = HTTParty.post(url, params(options)).parsed_response
+        response['error'].empty? ? response['result'] : response['error']
+      end
+
+      private
+
+      def params(options = {})
+        params           = {}
+
+        header_content   = content_manager::Header.new(config, endpoint_name, options, url)
+
+        params[:headers] = header_content.call
+        params[:body]    = body_content(header_content).call
+
+        params
+      end
+
+      def content_manager
+        KrakenClient::Requests::Content
+      end
+
+      def body_content(header_content)
+        content_manager::Body.new(header_content.send(:encoded_options))
+      end
+
+    end
+  end
+end

data/lib/kraken_client.rb

@@ -0,0 +1,15 @@
+require 'find'
+require 'active_support/inflector'
+
+Find.find('./lib').select { |p| /.*\.rb$/ =~ p }.each do |path|
+  require_relative("../" + path)
+end
+
+module KrakenClient
+  extend KrakenClient::Configurable
+
+  def self.load(params = {})
+    KrakenClient::Application.new(params)
+  end
+
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module KrakenClient
+  VERSION = "0.2.0"
+end

data/readme.md

@@ -0,0 +1,280 @@
+
+# **KrakenClient**
+
+`KrakenClient` is a **Ruby** wrapper of the Kraken API. Kraken is a market exchange site serving those trading with Crypto-Currencies, such as **Bitcoin**.
+
+This gem tends to be a replacement for [kraken_ruby](https://github.com/leishman/kraken_ruby), another wrapper, from which it is originally forked from.
+
+It has every features of the latter gem, with improved readability, usability, maintenability, and speced using the Awesome [Spectus gem](https://github.com/fixrb/spectus).
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kraken_client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kraken_ruby
+
+And require it in your application:
+
+    irb(main):001:0> require 'kraken_client'
+    => true
+
+
+## Usage
+
+### Configuration ###
+You can pass multiple variables that will be used in the gem.
+
+```ruby
+KrakenClient.configure do |config|
+      config.api_key     = ENV['KRAKEN_API_KEY']
+      config.api_secret  = ENV['KRAKEN_API_SECRET']
+      config.base_uri    = 'https://api.kraken.com'
+      config.api_version = 0
+      config.limiter     = true
+      config.tier        = 2
+end
+```
+
+By default, the default values are the ones described in the above example.
+
+You can also pass any of those options inline when loading an instance of KrakenClient.
+
+```ruby
+KrakenClient.load({base_uri: 'https://api.kraken.com', tier: 3}).config.tier
+```
+
+
+**/!\\ Important Note /!\\** If you wish to use the Private Endpoints, you need to specify an API Key, or an exception will be raised. 
+
+### Call Rate Limiter ###
+
+Kraken has implemented a security which limit API users to make too much requests to the server. Each user has a counter (which is bigger depending on your tier). Each call increments your counter, and if your counter reaches its limit, you are blocked for 15 minutes.
+
+To prevent this, `KrakenClient` has a safeguard, which queue the request which should in theory be blocked and is executed two second later.
+
+If you want to disable this option, pass the `limiter` variable in the configuration to false.
+
+```ruby
+KrakenClient.load({limiter: false}).config.tier
+```
+
+Also, this limiter is activated by default. You would like to specify your tier, and `KrakenClient` will automatically make the required adjustments. The default `tier` is 2.
+
+```ruby
+KrakenClient.load({tier: 3}).config.tier
+```
+
+For more information, please consult the [Kraken official documentation](https://support.kraken.com/hc/en-us/articles/206548367-What-is-the-API-call-rate-limit-).
+
+### Requests ###
+
+In all our examples henceforward, we consider this variable to be a loaded instance of `KrakenClient`
+
+```ruby
+client = KrakenClient.load
+```
+
+If you ever need to see the full documentation for the possible parameters, please take a look at the official [Kraken API docs](https://www.kraken.com/help/api).
+
+A `KrakenClient::MissingParameter` exception will be raised along with the missing parameters if a required parameter is not passed.
+
+### *Public Endpoints* ###
+
+
+##### Server Time
+
+This functionality is provided by Kraken to to aid in approximating the skew time between the server and client.
+
+```ruby
+time = client.public.server_time
+
+time.unixtime #=> 1393056191
+time.rfc1123 #=> "Sat, 22 Feb 2014 08:28:04 GMT"
+```
+
+##### Asset Info
+
+Returns the assets that can be traded on the exchange. This method can be passed ```info```, ```aclass``` (asset class), and ```asset``` options. An example below is given for each:
+
+```ruby
+assets = client.public.assets
+```
+
+##### Asset Pairs
+
+```ruby
+pairs = client.public.asset_pairs
+```
+
+##### Ticker Information
+
+```ruby
+ticker_data = client.public.ticker('XLTCXXDG, ZUSDXXVN')
+```
+
+##### Order Book
+
+Get market depth information for given asset pairs
+
+```ruby
+depth_data = client.public.order_book('LTCXRP')
+```
+
+##### Trades
+
+Get recent trades
+
+```ruby
+trades = client.public.trades('LTCXRP')
+```
+
+##### Spread
+
+Get spread data for a given asset pair
+
+```ruby
+spread = client.public.spread('LTCXRP')
+```
+
+
+#### Private Endpoints ####
+
+##### Balance
+
+Get account balance for each asset
+Note: Rates used for the floating valuation is the midpoint of the best bid and ask prices
+
+```ruby
+balance = client.private.balance
+```
+
+##### Trade Balance
+
+Get account trade balance
+
+```ruby
+trade_balance = client.private.trade_balance
+```
+
+##### Open Orders
+
+```ruby
+open_orders = client.private.open_orders
+```
+
+##### Closed Orders
+
+```ruby
+closed_orders = client.private.closed_orders
+```
+
+##### Query Orders
+
+**Input:** Comma delimited list of transaction ids (txid)
+
+See all orders
+
+```ruby
+orders = client.private.query_orders(txid: ids)
+```
+
+##### Trades History
+
+Get array of all trades
+
+```ruby
+trades = client.private.trade_history
+```
+
+##### Query Trades
+
+**Input:** Comma delimited list of transaction ids (txid)
+
+See all orders
+
+```ruby
+orders = client.private.query_orders(txid: ids)
+```
+
+##### Open Positions
+
+**Input:** Comma delimited list of transaction (txid) ids
+
+```ruby
+positions = client.private.open_positions(txid)
+```
+
+##### Ledgers Info
+
+```ruby
+ledgers = client.private.ledgers
+```
+
+##### Query Ledgers
+
+**Input:** Comma delimited list of ledger ids
+
+```ruby
+ledgers = client.private.query_ledgers(id: ledger_ids)
+```
+
+##### Trade Volume
+
+```ruby
+ledgers = client.private.trade_volume
+```
+
+##### Add Order
+
+There are 4 required parameters for buying an order. The example below illustrates the most basic order. Please see the [Kraken documentation](https://www.kraken.com/help/api#add-standard-order) for the parameters required for more advanced order types.
+
+```ruby
+# buying 0.01 XBT (bitcoin) for XRP (ripple) at market price
+opts = {
+  pair: 'XBTXRP',
+  type: 'buy',
+  ordertype: 'market',
+  volume: 0.01
+}
+
+client.private.add_order(opts)
+```
+
+##### Cancel Order
+
+```ruby
+client.private.cancel_order("UKIYSP-9VN27-AJWWYC")
+```
+
+
+## Credits
+
+This gem has been made by [Sidney SISSAOUI (shideneyu)](https://github.com/shideneyu). 
+
+Special credits goes to [Alexander LEISHMAN](http://alexleishman.com/) and other  [kraken_ruby](https://github.com/leishman/kraken_ruby)  contributors for their gem, which helped me to have a nice base to begin **KrakenClient**. It would have been difficult for me to sign the requests if it wasn't thanks to their work.
+If you want to be part of those credits, do not hesitate to contribute by doing some pull requests ;) !
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/swiffer/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+
+## License
+
+See `LICENSE.md` file.

data/spec/requests/private_spec.rb

@@ -0,0 +1,104 @@
+require_relative File.join '..', '..', 'lib', 'kraken_client'
+require 'spectus'
+require 'vcr'
+require 'webmock'
+
+include WebMock::API
+
+VCR.configure do |config|
+  config.cassette_library_dir = "fixtures/vcr_cassettes"
+  config.hook_into :webmock # or :fakeweb
+end
+
+# Testing Private Endpoints
+KrakenClient.configure do |config|
+  config.api_key    = ENV['KRAKEN_API_KEY']    || 'COMPUTED'
+  config.api_secret = ENV['KRAKEN_API_SECRET'] ||'COMPUTED'
+end
+
+kraken = KrakenClient.load
+client = kraken.private
+
+# User Balance
+VCR.use_cassette("balance") do
+  Spectus.this { client.balance.class }.MUST Equal: Hashie::Mash 
+end
+
+# Trade Balance
+VCR.use_cassette("trade_balance") do
+  Spectus.this { client.trade_balance.c }.MUST Eql: '0.0000' 
+end
+
+# Open Orders
+VCR.use_cassette("open_orders") do
+  Spectus.this { client.open_orders.open.class }.MUST Equal: Hashie::Mash
+end
+
+# Closed Orders
+VCR.use_cassette("closed_orders") do
+  Spectus.this { client.closed_orders.closed.class }.MUST Equal: Hashie::Mash
+end
+
+# Query Orders
+VCR.use_cassette("query_orders") do
+  Spectus.this do
+    order = client.query_orders({txid: 'OKRRJ6-MH3UH-DV6IKT'})
+    order['OKRRJ6-MH3UH-DV6IKT'].status
+  end.MUST Eql: 'canceled'
+end
+
+# Trades History
+VCR.use_cassette("trades_history") do
+  Spectus.this { client.trades_history.trades.class }.MUST Equal: Hashie::Mash
+end
+
+# Query Trades
+VCR.use_cassette("query_trades") do
+  Spectus.this do
+    order = client.query_trades({txid: 'THZPTW-BMF6X-VWMN5P'})
+    order['THZPTW-BMF6X-VWMN5P'].pair
+  end.MUST Eql: 'XETHZEUR'
+end
+
+# Open Positions
+#CANT TEST, PARAMS DO NOT WORK
+
+# Ledgers Info
+VCR.use_cassette("ledgers") do
+  Spectus.this { client.ledgers.ledger.class }.MUST Equal: Hashie::Mash
+end
+
+# Query Ledgers
+VCR.use_cassette("query_ledgers") do
+  Spectus.this do
+    ledger = client.query_ledgers(id: 'LRSNYS-DICDD-3QM34P')
+    ledger['LRSNYS-DICDD-3QM34P'].class
+   end.MUST Equal: Hashie::Mash
+end
+
+# Trade Volume
+VCR.use_cassette("trade_volume") do
+  Spectus.this { client.trade_volume(pair: 'XETHZEUR').count }.MUST Equal: 4
+end
+
+# Add Order
+VCR.use_cassette("add_order") do
+  Spectus.this do
+
+    opts = {
+      pair: 'ETHEUR',
+      type: 'buy',
+      ordertype: 'market',
+      volume: 0.01
+    }
+
+    client.add_order(opts).txid
+  end.MUST Eql: ['OEDIZV-VDAW3-RHLJVB']
+end
+
+# Cancel Order
+VCR.use_cassette("cancel_order") do
+  Spectus.this do
+    client.cancel_order(txid: 'ODEC3J-QAMVD-NSF7XD').count
+  end.MUST Eql: 1
+end

data/spec/requests/public_spec.rb

@@ -0,0 +1,57 @@
+require_relative File.join '..', '..', 'lib', 'kraken_client'
+require 'spectus'
+require 'vcr'
+require 'webmock'
+
+include WebMock::API
+
+VCR.configure do |config|
+  config.cassette_library_dir = "fixtures/vcr_cassettes"
+  config.hook_into :webmock # or :fakeweb
+end
+
+# Testing Public Endpoints
+kraken = KrakenClient.load
+client = kraken.public
+
+# Server Time
+VCR.use_cassette("server_time") do
+  kraken_time = DateTime.parse(client.server_time.rfc1123)
+  utc_time = Time.now.getutc
+  Spectus.this { kraken_time.day.class }.MUST Equal: Fixnum
+  Spectus.this { kraken_time.hour.class }.MUST Equal: Fixnum
+end
+
+# Assets
+VCR.use_cassette("assets") do
+  Spectus.this { client.assets.XETH.aclass }.MUST Eql: 'currency'
+end
+
+# Assets Pairs
+VCR.use_cassette("assets_pairs") do
+  Spectus.this { client.asset_pairs.XETHXXBT.altname }.MUST Eql: 'ETHXBT'
+end
+
+# Ticker
+VCR.use_cassette("ticker") do
+  result = client.ticker(pair: 'XXBTZEUR, XXBTZGBP')
+  Spectus.this { result.XXBTZGBP.a.class }.MUST Equal: Array
+end
+
+# Order Book
+VCR.use_cassette("order_book") do
+  order_book = client.order_book(pair: 'XXBTZEUR')
+  Spectus.this { order_book.XXBTZEUR.asks.class }.MUST Equal: Array
+end
+
+# Trades
+VCR.use_cassette("trades") do
+  trades = client.trades(pair: 'XXBTZEUR')
+  Spectus.this { trades.XXBTZEUR.class }.MUST Equal: Array
+end
+
+# Spread
+VCR.use_cassette("spread") do
+  spread = client.spread(pair: 'XXBTZEUR')
+  Spectus.this { spread.XXBTZEUR.class }.MUST Equal: Array
+end