coinbase-exchange 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 452c6b81858eaeb6b32e7369818b2c817431c106
+  data.tar.gz: dc3749525c0da9a50267c22af9056e8f3b29315a
+SHA512:
+  metadata.gz: c67ab3066726b7b256a054b818399f78ea3a99d9a818ad48c419ed1a3c688a6b77b9dff901e7ef80fc38c73dce231083416c22d689b28e11cfe7639488476c01
+  data.tar.gz: 33c151064d84f905d0290c6a697ddd0e87712662d7236819a6334b10acbe2a979bae8e6a9090c0df10e07bab0c5cc8c534735c4eeb1450cfbf7837baa443e441

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.rubocop.yml

@@ -0,0 +1,21 @@
+AllCops:
+  Exclude:
+    - '*.gemspec'
+
+Style/StringLiterals:
+  Enabled: false
+Style/SpaceInsideBrackets:
+  Enabled: false
+Style/TrivialAccessors:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 120
+Metrics/MethodLength:
+  Max: 50
+Metrics/ClassLength:
+  Enabled: false
+Metrics/AbcSize:
+  Max: 50
+Metrics/CyclomaticComplexity:
+  Max: 15

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in coinbase-exchange.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,72 @@
+PATH
+  remote: .
+  specs:
+    coinbase-exchange (0.1.1)
+      bigdecimal
+      em-http-request
+      faye-websocket
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.8)
+    bigdecimal (1.2.7)
+    coderay (1.1.0)
+    cookiejar (0.3.2)
+    crack (0.4.2)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.2.5)
+    em-http-request (1.1.2)
+      addressable (>= 2.3.4)
+      cookiejar
+      em-socksify (>= 0.3)
+      eventmachine (>= 1.0.3)
+      http_parser.rb (>= 0.6.0)
+    em-socksify (0.3.0)
+      eventmachine (>= 1.0.0.beta.4)
+    eventmachine (1.0.7)
+    faye-websocket (0.9.2)
+      eventmachine (>= 0.12.0)
+      websocket-driver (>= 0.5.1)
+    http_parser.rb (0.6.0)
+    method_source (0.8.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    safe_yaml (1.0.4)
+    slop (3.6.0)
+    webmock (1.21.0)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+    websocket-driver (0.5.4)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.8)
+  coinbase-exchange!
+  pry
+  rake (~> 10.0)
+  rspec
+  webmock
+
+BUNDLED WITH
+   1.10.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 John Duhamel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,446 @@
+# Coinbase Exchange Gem
+
+## REST Client
+
+We provide an exchange client that is a thin wrapper over the exchange API.  The purpose of this Readme is to provide context for using the gem effectively.  For a detailed overview of the information that's available through the API, we recommend consulting the official documentation.
+* https://docs.exchange.coinbase.com/#api
+
+We provide a synchronous and asynchronous client.  The only functional difference between the two clients is that the asynchronous client must be started inside the Eventmachine reactor loop.
+
+**Sychronous Client**
+
+```ruby
+require 'coinbase/exchange'
+
+rest_api = Coinbase::Exchange::Client.new(api_key, api_secret, api_pass)
+while true
+  sleep 10
+  rest_api.last_trade("BTC-GBP") do |resp|
+    p "Spot Rate: £ %.2f" % resp.price
+  end
+end
+```
+
+**Asynchronous Client**
+
+```ruby
+require 'coinbase/exchange'
+require 'eventmachine'
+
+rest_api = Coinbase::Exchange::AsyncClient.new(api_key, api_secret, api_pass)
+EM.run {
+  EM.add_periodic_timer(10) {
+    rest_api.last_trade("BTC-GBP") do |resp|
+      p "Spot Rate: £ %.2f" % resp.price
+    end
+  }
+}
+```
+
+## Usage
+
+### Initialization
+
+To initialize the client, simply pass in an API Key, API Secret, and API Passphrase which you generate on the web interface:
+* https://exchange.coinbase.com/settings
+
+```ruby
+rest_api = Coinbase::Exchange::Client.new(api_key, api_secret, api_pass)
+```
+
+```ruby
+rest_api = Coinbase::Exchange::AsyncClient.new(api_key, api_secret, api_pass)
+```
+
+**Default Product**
+
+Coinbase supports trading bitcoin in several currencies.  If you wish to trade a different currency, you can specify an alterative default currency.
+
+```ruby
+gbp_client = Coinbase::Exchange::Client.new(api_key, api_secret, api_pass,
+                                            product_id: "BTC-GBP")
+```
+
+**Sandbox**
+
+You can initialize a connection to the sandbox by specifying an alternative api endpoint.
+
+```ruby
+sandbox = Coinbase::Exchange::Client.new(api_key, api_secret, api_pass,
+                                          api_url: "https://api-public.sandbox.exchange.coinbase.com")
+```
+
+### Methods
+
+The default representation of return data is an unmodified hash from the JSON blob returned in the body of the API response.  The response should be accessed in a block like this.
+
+```ruby
+rest_api.last_trade do |resp|
+  p "Spot Rate: $ %.2f" % BigDecimal(resp['price'])
+end
+```
+
+Note, the synchronous client will also return the same data.  However, this is discouraged since it will make porting code to an asynchronous client more difficult.  Here is an example of what that might look like.
+
+```ruby
+resp = rest_api.last_trade
+p "Spot Rate: $ %.2f" % BigDecimal(resp['price'])
+```
+
+### Parameters
+
+The gem will automatically encode any additional parameters you pass to method calls.  For instance to get the full orderbook, you must explicitly set the level parameter to 3.
+
+```ruby
+rest_api.orderbook('BTC-GBP', level: 3) do |resp|
+  p "There are #{resp['bids'].count} open bids on the orderbook"
+  p "There are #{resp['asks'].count} open asks on the orderbook"
+end
+```
+
+### Return Values
+
+Data format is a sensitive issue when writing financial software.  The exchange API represents monetary data in string format.  This is a good intermediary data format for the user to apply their own data format, but is not escpecially useful on its own.
+
+For representing monetary data in ruby, we recomend using the [BigDecimal] (http://ruby-doc.org/stdlib-2.1.1/libdoc/bigdecimal/rdoc/BigDecimal.html) library.  If you access data by calling response items as though they were methods on the response itself.  If you access data this way, any numerical data will be converted to BigDecimal format.
+
+```ruby
+rest_api.orders(before: Time.now - 60*60) do |resp|
+  resp.each do |order|
+    p sprintf "#{order.side} ฿ %.8f for $ %.2f", order.size, order.price
+  end
+end
+```
+
+### Errors
+
+The gem will throw an error if it detects an exception.  The possible errors are:
+
+|Error|Description
+|---|---
+|APIError|Parent class for all errors.
+|BadRequestError|Server returned status 400.
+|NotAuthorizedError|Server returned status 401.
+|ForbiddenError|Server returned status 403.
+|NotFoundError|Server returned status 404.
+|RateLimitError|Server returned status 429.
+|InternalServerError|Server returned status 500.
+
+### Metadata
+
+You may need more fine-grained access to API response than just the body.  We additionally provide access to the response headers, status, and the raw response as represented by the underlying library.
+
+```ruby
+rest_api.last_trade do |resp|
+  p "Status: #{resp.response_status}"
+  p "Headers: #{resp.response_headers}"
+  p "Response: #{resp.raw}"
+end
+```
+
+## Endpoints
+
+### [Market Data] (https://docs.exchange.coinbase.com/#market-data)
+
+Coinbase supports trading in multiple currencies.  When interacting with market data, you can get information about a product other than your default by setting the product_id parameter.
+
+```ruby
+rest_api.last_trade(product_id: 'BTC-GBP') do |resp|
+  p "The spot rate is £ %.2f" resp.price
+end
+```
+
+**currencies**
+
+Fetches a list of currencies we support.
+
+```ruby
+rest_api.currencies do |resp|
+  resp.each do |currency|
+    p "The symbol for #{currency.name} is #{currency.id}"
+  end
+end
+```
+
+**products**
+
+Fetches a list of products we offer.
+
+```ruby
+rest_api.products do |resp|
+  resp.each do |product|
+    p "The most #{product.base_currency} you can buy with #{product.quote_currency} is %f" % product.base_max_size
+  end
+end
+```
+
+**orderbook**
+
+Downloads a list of all open orders on our exchange.
+
+```ruby
+rest_api.orderbook do |resp|
+  p resp
+end
+```
+
+If you wish to download a level 2 or level 3 orderbook, pass a level parameter to the method.
+
+```ruby
+rest_api.orderbook(level: 3) do |resp|
+  p "There are #{resp.bids.count} open bids on the orderbook"
+  p "There are #{resp.asks.count} open asks on the orderbook"
+end
+```
+
+**last_trade**
+
+Downloads information about the last trade, which is exposed through the /ticker endpoint.
+
+```ruby
+rest_api.last_trade do |resp|
+  p "The spot rate is $ %.2f" resp.price
+end
+```
+
+**trade_history**
+
+Downloads recent trades.  Please be aware that if you don't explicitly pass a before parameter this will recursively download every trade that's ever been placed.
+
+```ruby
+rest_api.trade_history(before: Time.now - 10*60) do |resp|
+  p "#{resp.count} trades have occured in the past 10 minutes."
+end
+```
+
+**price_history**
+
+Downloads price history.  We recommend setting a start parameter.  You may also find the granularity parameter useful.
+
+```ruby
+rest_api.price_history(start: Time.now - 60*60, granularity: 60) do |resp|
+  p "In the past hour, the maximum price movement was $ %.2f" % resp.map { |candle| candle.high - candle.low }.max
+end
+```
+
+**daily_stats**
+
+Downloads price information over the past 24 hours.
+
+```ruby
+rest_api.daily_stats do |resp|
+  p "The highest price in in the past 24 hours was %.2f" % resp.high
+  p "The lowest price in in the past 24 hours was %.2f" % resp.low
+end
+```
+
+### [Accounts] (https://docs.exchange.coinbase.com/#accounts)
+
+**accounts**
+
+Downloads information about your accounts.
+
+```ruby
+rest_api.accounts do |resp|
+  resp.each do |account|
+    p "#{account.id}: %.2f #{account.currency} available for trading" % account.available
+  end
+end
+```
+
+**account**
+
+Downloads information about a single account.  You must pass the account id as the first parameter.
+
+```ruby
+rest_api.account(account_id) do |account|
+  p "Account balance is %.2f #{account.currency}" % account.balance
+end
+```
+
+**account_history**
+
+Downloads a ledger of transfers, matches, and fees associated with an account.  You must pass the account id as the first paramter.
+
+```ruby
+rest_api.account_history(account_id) do |resp|
+  p resp
+end
+```
+
+**account_holds**
+
+Holds are placed on an account for open orders.  This will download a list of all account holds.
+
+```ruby
+rest_api.account_holds(account_id) do |resp|
+  p resp
+end
+```
+
+### [Orders] (https://docs.exchange.coinbase.com/#orders)
+
+**bid**
+
+Places a buy order.  Required parameters are amount and price.
+
+```ruby
+rest_api.bid(0.25, 250) do |resp|
+  p "Order ID is #{resp.id}"
+end
+```
+
+**buy**
+
+This is an alias for bid.
+
+```ruby
+rest_api.buy(0.25, 250) do |resp|
+  p "Order ID is #{resp.id}"
+end
+```
+
+**ask**
+
+Places a sell order.  Required parameters are amount and price.
+
+```ruby
+rest_api.ask(0.25, 250) do |resp|
+  p "Order ID is #{resp.id}"
+end
+```
+
+**sell**
+
+This is an alias for ask.
+
+```ruby
+rest_api.sell(0.25, 250) do |resp|
+  p "Order ID is #{resp.id}"
+end
+```
+
+**cancel**
+
+Cancels an order.  This returns no body, but you can still pass a block to execute on a successful return.
+
+```ruby
+rest_api.cancel(order_id) do
+  p "Order canceled successfully"
+end
+```
+
+**orders**
+
+Downloads a list of all you're orders.  Most likely, you only care about your open orders when using this.
+
+```ruby
+rest_api.orders(status: open) do |resp|
+  p "You have #{resp.count} open orders."
+end
+```
+
+**order**
+
+Downloads information about a single order.
+
+```ruby
+rest_api.order(order_id) do |resp|
+  p "Order status is #{resp.status}"
+end
+```
+
+**fills**
+
+Downloads a list of fills.
+
+```ruby
+rest_api.fills do |resp|
+  p resp
+end
+```
+
+### [Transfers] (https://docs.exchange.coinbase.com/#transfer-funds)
+
+**deposit**
+
+Deposit money from a Coinbase wallet.
+
+```ruby
+rest_api.deposit(wallet_id, 10) do |resp|
+  p "Deposited 10 BTC"
+end
+```
+
+**withdraw**
+
+Withdraw money for your Coinbase wallet.
+
+```ruby
+rest_api.withdraw(wallet_id, 10) do |resp|
+  p "Withdrew 10 BTC"
+end
+```
+
+### Other
+
+**server_time**
+
+Download the server time.
+
+```ruby
+rest_api.server_time do |resp|
+  p "The time on the server is #{resp}"
+end
+```
+
+## Websocket Client
+
+We recommend reading the official websocket documentation before proceeding.
+
+* https://docs.exchange.coinbase.com/#websocket-feed
+
+We provide a websocket interface in the gem for convenience.  This is typically used to build a real-time orderbook, although it can also be used for simpler purposes such as tracking the market rate, or tracking when your orders fill.  Like the asynchronous client, this depends Eventmachine for asycnhronous processing.
+
+Please consider setting the keepalive flag to true when initializing the websocket.  This will cause the websocket to proactively refresh the connection whenever it closes.
+
+```ruby
+websocket = Coinbase::Exchange::Websocket.new(keepalive: true)
+```
+
+Before starting the websocket, you should hook into whatever messages you're interested in by passing a block to the corresponding method.  The methods you can use for access are open, match, change, done, and error.  Additionally, you can use message to run a block on every websocket event.
+
+```ruby
+require 'coinbase/exchange'
+require 'eventmachine'
+
+websocket = Coinbase::Exchange::Websocket.new(product_id: 'BTC-GBP',
+                                              keepalive: true)
+websocket.match do |data|
+  p "Spot Rate: £ %.2f" % resp.price
+end
+
+EM.run do
+  websocket.start!
+  EM.add_periodic_timer(1) {
+    websocket.ping do
+      p "Websocket is alive"
+    end
+  }
+  EM.error_handler { |e|
+    p "Websocket Error: #{e.message}"
+  }
+end
+```
+
+If started outside the reactor loop, the websocket client will use a very basic Eventmachine handler.
+
+```ruby
+require 'coinbase/exchange'
+
+websocket = Coinbase::Exchange::Websocket.new(product_id: 'BTC-GBP')
+websocket.on_match do |data|
+  p "Spot Rate: £ %.2f" % resp.price
+end
+websocket.start!
+```