gemini-rb 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f8b6bdb4c745a5e128399dc907263c45cc246494
+  data.tar.gz: 51b0da98bbe215bd3f98d97cf181b50eefc6fa92
+SHA512:
+  metadata.gz: e58aad70668f996a1ed5eba5b50615c25a739601dce52bb86cd3bbdadde40d13cdb514d700af39cf4c80d56ab963ad32921a05b7f738b1f283df67c365ca3bf5
+  data.tar.gz: 773a41a59776f1702ba415555aa215e255fab65e85fdefaa0dad47c0d240ef35eb72837546cb832431993e68dd1afb7cc435b2b0dc01d497c092b0eb8a9f20e9

data/lib/gemini/api_versions.rb

@@ -0,0 +1,7 @@
+module Gemini
+  # API logic for Version 1
+  module V1; end
+
+  # API logic for Version 2
+  module V2; end
+end

data/lib/gemini/authenticated_rest.rb

@@ -0,0 +1,58 @@
+module Gemini
+  module AuthenticatedConnection
+
+    private
+    def authenticated_post(url, options = {})
+      raise Gemini::InvalidAuthKeyError unless valid_key?
+      complete_url = build_url(url)
+      body = options[:params] || {}
+      nonce = new_nonce
+
+      payload = if config.api_version == 1
+        build_payload("/v1/#{url}", options[:params], nonce)
+      else
+        "/api#{complete_url}#{nonce}#{body.to_json}"
+      end
+
+      response = rest_connection.post do |req|
+        req.url complete_url
+        req.body = body.to_json
+        req.options.timeout = config.rest_timeout
+        req.options.open_timeout = config.rest_open_timeout
+        req.headers['Content-Type'] = 'application/json'
+        req.headers['Accept'] = 'application/json'
+
+        if config.api_version == 1
+          req.headers['X-GEMINI-PAYLOAD'] = payload
+          req.headers['X-GEMINI-SIGNATURE'] = sign(payload)
+          req.headers['X-GEMINI-APIKEY'] = config.api_key
+        else
+          # TODO: Verify if this applies to Gemini.
+          req.headers['gemini-nonce'] = nonce
+          req.headers['gemini-signature'] = sign(payload)
+          req.headers['gemini-apikey'] = config.api_key
+        end
+      end
+    end
+
+    def build_payload(url, params = {}, nonce)
+      payload = {}
+      payload['nonce'] = nonce
+      payload['request'] = url
+      payload.merge!(params) if params
+      Base64.strict_encode64(payload.to_json)
+    end
+
+    def new_nonce
+      (Time.now.to_f * 10_000).to_i.to_s
+    end
+
+    def sign(payload)
+      OpenSSL::HMAC.hexdigest('sha384', config.secret, payload)
+    end
+
+    def valid_key?
+      !! (config.api_key && config.secret)
+    end
+  end
+end

data/lib/gemini/client.rb

@@ -0,0 +1,38 @@
+module Gemini
+  class Client
+    include Gemini::RestConnection
+    include Gemini::WebsocketConnection
+    include Gemini::AuthenticatedConnection
+    include Gemini::Configurable
+
+
+    def initialize
+      if config.api_version == 1
+        extend Gemini::V1::TickerClient
+        extend Gemini::V1::TradesClient
+        extend Gemini::V1::FundingBookClient
+        extend Gemini::V1::OrderbookClient
+        extend Gemini::V1::StatsClient
+        extend Gemini::V1::LendsClient
+        extend Gemini::V1::SymbolsClient
+        extend Gemini::V1::AccountInfoClient
+        extend Gemini::V1::DepositClient
+        extend Gemini::V1::OrdersClient
+        extend Gemini::V1::PositionsClient
+        extend Gemini::V1::HistoricalDataClient
+        extend Gemini::V1::MarginFundingClient
+        extend Gemini::V1::WalletClient
+      else
+        extend Gemini::V2::TickerClient
+        extend Gemini::V2::StatsClient
+        extend Gemini::V2::UtilsClient
+        extend Gemini::V2::PersonalClient
+        extend Gemini::V2::TradingClient
+        extend Gemini::V2::MarginClient
+      end
+
+      @mutex = Mutex.new
+      @c_counter = 1
+    end
+  end
+end

data/lib/gemini/configurable.rb

@@ -0,0 +1,48 @@
+module Gemini
+  module Configurable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def config
+      self.class.config
+    end
+
+    module ClassMethods
+      def configure
+        yield config
+      end
+
+      def config
+        @configuration ||= Configuration.new
+      end
+    end
+  end
+
+  class Configuration
+    attr_accessor :api_endpoint, :debug, :debug_connection, :secret
+    attr_accessor :api_key, :websocket_api_endpoint, :rest_timeout
+    attr_accessor :reconnect, :reconnect_after, :rest_open_timeout
+    attr_accessor :api_version
+
+    def initialize
+      self.api_endpoint = "https://api.gemini.com/v1/"
+      self.websocket_api_endpoint = "wss://api.gemini.com/ws"
+      self.debug = false
+      self.reconnect = true
+      self.reconnect_after = 60
+      self.rest_timeout = 30
+      self.rest_open_timeout = 30
+      self.debug_connection = false
+      self.api_version = 1
+    end
+
+    # Helper that configure to version 2
+    def use_api_v2
+      self.api_version = 2
+      self.api_endpoint = "https://api.gemini.com/v2/"
+      self.websocket_api_endpoint = "wss://api.gemini.com/ws/2/"
+    end
+  end
+
+end

data/lib/gemini/connection.rb

@@ -0,0 +1,52 @@
+require 'logger'
+module Gemini
+  # Network Layer for API Rest client
+  module RestConnection
+    private
+    # Make an HTTP GET request
+    def get(url, params={})
+      rest_connection.get do |req|
+        req.url build_url(url)
+        req.headers['Content-Type'] = 'application/json'
+        req.headers['Accept'] = 'application/json'
+        params.each do |k,v|
+          req.params[k] = v
+        end
+        req.options.timeout = config.rest_timeout
+        req.options.open_timeout = config.rest_open_timeout
+      end
+    end
+
+    # Make sure parameters are allowed for the HTTP call
+    def check_params(params, allowed_params)
+      if (params.keys - allowed_params).empty?
+        return params
+      else
+        raise Gemini::ParamsError
+      end
+    end
+
+    def rest_connection
+      @conn ||= new_rest_connection
+    end
+
+    def build_url(url)
+      URI.join(config.api_endpoint, url).path
+    end
+
+    def new_rest_connection
+      Faraday.new(url: base_api_endpoint) do |conn|
+        conn.use Gemini::CustomErrors
+        conn.response :logger, Logger.new(STDOUT) , bodies: true  if config.debug_connection
+        conn.use FaradayMiddleware::ParseJson, :content_type => /\bjson$/
+        conn.adapter :net_http
+      end
+    end
+
+    def base_api_endpoint
+      url = URI.parse config.api_endpoint
+      "#{url.scheme}://#{url.host}:#{url.port}"
+    end
+
+  end
+end

data/lib/gemini/errors.rb

@@ -0,0 +1,35 @@
+require 'faraday'
+
+module Gemini
+  class ClientError < Exception; end
+  class ParamsError < ClientError; end
+  class InvalidAuthKeyError < ClientError; end
+  class BlockMissingError < ParamsError; end
+  class ServerError < Exception; end # Error reported back by Binfinex server
+  class ConnectionClosed < Exception; end
+  class BadRequestError < ServerError; end
+  class NotFoundError < ServerError; end
+  class ForbiddenError < ServerError; end
+  class UnauthorizedError < ServerError; end
+  class InternalServerError < ServerError; end
+  class WebsocketError < ServerError; end
+
+  class CustomErrors < Faraday::Response::Middleware
+    def on_complete(env)
+      case env[:status]
+      when 400
+        raise BadRequestError, env.body['message']
+      when 401
+        raise UnauthorizedError, env.body['message']
+      when 403
+        raise ForbiddenError, env.body['message']
+      when 404
+        raise NotFoundError, env.body['message']
+      when 500
+        raise InternalServerError, env.body['message']
+      else
+        super
+      end
+    end
+  end
+end

data/lib/gemini/v1/account_info.rb

@@ -0,0 +1,38 @@
+module Gemini
+  module V1::AccountInfoClient
+
+    # Get account information
+    #
+    # @return [Hash] your account information
+    # @example:
+    #   client.account_info
+    def account_info
+      resp = authenticated_post("account_infos")
+      resp.body
+    end
+
+
+    # Call block passing all account related specific messages sent via websocket
+    #
+    # @param block [Block] The code to be executed when new message is received
+    # @example:
+    #   client.listen_account do |message|
+    #     puts message.inspect
+    #   end
+    def listen_account(&block)
+      raise BlockMissingError unless block_given?
+      ws_auth(&block)
+    end
+
+    # See the fees applied to your withdrawals
+    #
+    # @return [Hash]
+    # @example:
+    #   client.fees
+    def fees
+      resp = authenticated_post("fees")
+      resp.body
+    end
+  end
+
+end

data/lib/gemini/v1/deposit.rb

@@ -0,0 +1,23 @@
+module Gemini
+  module V1::DepositClient
+
+    # Return your deposit address to make a new deposit.
+    #
+    # @param method [string] Method of deposit (methods accepted: “bitcoin”, “litecoin”, “darkcoin”, “mastercoin” (tethers)).
+    # @param wallet_name [string] Wallet to deposit in (accepted: “trading”, “exchange”, “deposit”). Your wallet needs to already exist
+    # @params renew [integer] (optional) Default is 0. If set to 1, will return a new unused deposit address
+    #
+    # @return [Hash] confirmation of your deposit
+    # @example:
+    #   client.deposit("bitcoin", "exchange")
+    def deposit method, wallet_name, renew=0
+      params = {
+        method: method,
+        wallet_name: wallet_name,
+        renew: renew
+      }
+
+      authenticated_post("deposit/new", params: params).body
+    end
+  end
+end

data/lib/gemini/v1/funding_book.rb

@@ -0,0 +1,18 @@
+module Gemini
+  module V1::FundingBookClient
+
+    # Get the full margin funding book
+
+    # @param currency [string] (optional) Speficy the currency, default "USD"
+    # @param params :limit_bids [int] (optional) Limit the number of funding bids returned. May be 0 in which case the array of bids is empty.
+    # @param params :limit_asks [int] (optional) Limit the number of funding offers returned. May be 0 in which case the array of asks is empty.
+    # @return [Hash] of :bids and :asks arrays
+    # @example:
+    #   client.funding_book
+    def funding_book(currency="usd", params = {})
+      check_params(params, %i{limit_bids limit_asks})
+      get("lendbook/#{currency}", params: params).body
+    end
+
+  end
+end

data/lib/gemini/v1/historical_data.rb

@@ -0,0 +1,53 @@
+module Gemini
+  module V1::HistoricalDataClient
+
+    # View all of your balance ledger entries.
+    #
+    # @param currency [string] (optional) Specify the currency, default "USD"
+    # @param params :since [time] (optional) Return only the history after this timestamp.
+    # @param params :until [time] (optional) Return only the history before this timestamp.
+    # @param params :limit [int] (optional) Limit the number of entries to return. Default is 500.
+    # @param params  :wallet [string] (optional) Return only entries that took place in this wallet. Accepted inputs are: “trading”, “exchange”, “deposit”
+    # @return [Array]
+    # @example:
+    #   client.history
+    def history(currency="usd", params = {})
+      check_params(params, %i{since until limit wallet})
+      params.merge!({currency: currency})
+      authenticated_post("history", params: params).body
+    end
+
+    # View your past deposits/withdrawals.
+    #
+    # @param currency [string] (optional) Specify the currency, default "USD"
+    # @param params :method (optional) The method of the deposit/withdrawal (can be “bitcoin”, “litecoin”, “darkcoin”, “wire”)
+    # @param params :since (optional) Return only the history after this timestamp
+    # @param params :until [time] (optional) Return only the history before this timestamp.
+    # @param params :limit [int] (optional) Limit the number of entries to return. Default is 500.
+    # @return [Array]
+    # @example:
+    #   client.movements
+    def movements(currency="usd", params = {})
+      check_params(params, %i{method since until limit})
+      params.merge!({currency: currency})
+      authenticated_post("history/movements", params: params).body
+    end
+
+    # View your past trades.
+    #
+    # @param symbol The pair traded (BTCUSD, LTCUSD, LTCBTC)
+    # @param params :until [time] (optional) Return only the history before this timestamp.
+    # @param params :timestamp [time] (optional) Trades made before this timestamp won’t be returned
+    # @param params :until [time] (optional) Trades made after this timestamp won’t be returned
+    # @param params :limit_trades [int] Limit the number of trades returned. Default is 50.
+    # @param params :reverse [int] Return trades in reverse order (the oldest comes first). Default is returning newest trades first.
+    # @return [Array]
+    # @example:
+    #   client.mytrades
+    def mytrades(symbol, params = {})
+      check_params(params, %i{until limit_trades reverse timestamp})
+      params.merge!({symbol: symbol})
+      authenticated_post("mytrades", params: params).body
+    end
+  end
+end

data/lib/gemini/v1/lends.rb

@@ -0,0 +1,18 @@
+module Gemini
+  module V1::LendsClient
+
+    # Get a list of the most recent funding data for the given currency: total amount provided and Flash Return Rate (in % by 365 days) over time.
+    #
+    # @param currency [string] (optional) Specify the currency, default "USD"
+    # @param params :timestamp [time] (optional) Only show data at or after this timestamp
+    # @param params :limit_lends [int] (optional) Limit the amount of funding data returned. Must be > 1, default 50
+    # @return [Array]
+    # @example:
+    #   client.lends
+    def lends(currency = "usd", params = {})
+      check_params(params, %i{timestamp limit_lends})
+      get("lends/#{currency}", params: params).body
+    end
+
+  end
+end

data/lib/gemini/v1/margin_funding.rb

@@ -0,0 +1,103 @@
+module Gemini
+  module V1::MarginFundingClient
+
+    # Submit a new offer
+    #
+    # @param currency [string] The name of the currency, es: 'USD'
+    # @param amount [decimal] Offer size: how much to lend or borrow
+    # @param rate [decimal] Rate to lend or borrow at. In percentage per 365 days.
+    #                       Set to 0 for FRR, ±delta for FRR±delta.
+    # @param period [integer] Number of days of the funding contract (in days)
+    # @param direction [string] Either “lend” or “loan”
+    # @param frrdelta [bool] If true, the rate represents ±delta to FRR.
+    # @return [Hash]
+    # @example:
+    #   client.new_offer("btc", 10.0, 20, 365, "lend")
+    def new_offer(currency, amount, rate, period, direction, frrdelta=false)
+      params = {
+        currency: currency,
+        amount: amount.to_s,
+        rate: rate.to_s,
+        period: period.to_i,
+        direction: direction,
+        frrdelta: !!frrdelta
+      }
+      authenticated_post("offer/new", params: params).body
+    end
+
+    # Cancel an offer
+    #
+    # @param offer_id [int] The offer ID given by `#new_offer`
+    # @return [Hash]
+    # @example:
+    #   client.cancel_offer(1000)
+    def cancel_offer(offer_id)
+      authenticated_post("offer/cancel", params: {offer_id: offer_id.to_i}).body
+    end
+
+    # Get the status of an offer. Is it active? Was it cancelled? To what extent has it been executed? etc.
+    #
+    # @param offer_id [int] The offer ID give by `#new_offer`
+    # @return [Hash]
+    # @example:
+    #   client.offer_status(1000)
+    def offer_status(offer_id)
+      authenticated_post("offer/status", params: {offer_id: offer_id.to_i}).body
+    end
+
+    # View your funds currently taken (active credits)
+    #
+    # @return [Array]
+    # @example:
+    #   client.credits
+    def credits
+      authenticated_post("credits").body
+    end
+
+    # View your active offers
+    #
+    # @return  [Array] An array of the results of /offer/status for all your live offers (lending or borrowing
+    # @example:
+    #   client.offers
+    def offers
+      authenticated_post("offers").body
+    end
+
+    # View your funding currently borrowed and used in a margin position
+    #
+    # @return [Array] An array of your active margin funds
+    # @example:
+    #   client.taken_funds
+    def taken_funds
+      authenticated_post("taken_funds").body
+    end
+
+    # View your funding currently borrowed and not used (available for a new margin position).
+    #
+    # @return [Array] An array of your active unused margin funds
+    # @example:
+    #   client.unused_taken_funds
+    def unused_taken_funds
+      authenticated_post("unused_taken_funds").body
+    end
+
+    # View the total of your active funding used in your position(s).
+    #
+    # @return [Array] An array of your active funding
+    # @example:
+    #   client.total_taken_funds
+    def total_taken_funds
+      authenticated_post("total_taken_funds").body
+    end
+
+    # Allow you to close an unused or used taken fund
+    #
+    # @param swap_id [int] The ID given by `#taken_funds` or `#unused_taken_funds
+    # @return [Hash]
+    # @example:
+    #   client.close_funding(1000)
+    def close_funding(swap_id)
+      authenticated_post("funding/close", params: {swap_id: swap_id.to_i}).body
+    end
+  end
+end

data/lib/gemini/v1/orderbook.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+module Gemini
+  module V1::OrderbookClient
+
+    # Get the full order book
+    #
+    # @param symbol [string]
+    # @param params :limit_bids [int] (optional) Limit the number of bids returned. May be 0 in which case the array of bids is empty. Default 50.
+    # @param params :limit_asks [int] (optional) Limit the number of asks returned. May be 0 in which case the array of asks is empty. Default 50.
+    # @param params :group [0/1] (optional) If 1, orders are grouped by price in the orderbook. If 0, orders are not grouped and sorted individually. Default 1
+    # @return [Hash] :bids [Array], :asks [Array]
+    # @example:
+    #   client.orderbook("btcusd")
+    def orderbook(symbol="btcusd", params = {})
+      check_params(params, %i{limit_bids limit_asks group})
+      get("book/#{symbol}", params: params).body
+    end
+
+
+    # Get the order book changes using websocket
+    #
+    # @param pair [string]
+    # @param prec [string] Level of price aggregation (P0, P1, P2, P3). The default is P0.
+    # @param freq [string] Frequency of updates (F0, F1, F2, F3). F0=realtime / F1=2sec / F2=5sec / F3=10sec
+    # @param len [int] Number of price points (“25”, “100”) [default=“25”]
+    # @param block [Block] The code to be executed when a new order is submitted
+    # @example:
+    #    client.listen_book do |order|
+    #      puts order.inspect
+    #    end
+    def listen_book(pair="BTCUSD", prec='P0', freq='F0',len=25, &block)
+      raise BlockMissingError unless block_given?
+      register_channel pair:pair, channel: 'book', prec: prec, freq: freq, len: len, &block
+    end
+  end
+end

data/lib/gemini/v1/orders.rb

@@ -0,0 +1,121 @@
+module Gemini
+  module V1::OrdersClient
+
+    # Submit a new order
+    # @param symbol [string] The name of the symbol (see `#symbols`)
+    # @param amount [decimal] Order size: how much to buy or sell
+    # @param type [string] Either “market” / “limit” / “stop” / “trailing-stop” / “fill-or-kill” / “exchange market” / “exchange limit” / “exchange stop” / “exchange trailing-stop” / “exchange fill-or-kill”. (type starting by “exchange ” are exchange orders, others are margin trading orders)
+    # @param side [string] Either “buy” or “sell”
+    # @param price [decimal] Price to buy or sell at. Must be positive. Use random number for market orders.
+    # @param params :is_hidden [bool] (optional) true if the order should be hidden. Default is false
+    # @param params :is_postonly [bool] (optional) true if the order should be post only. Default is false. Only relevant for limit orders
+    # @param params :ocoorder [bool] Set an additional STOP OCO order that will be linked with the current order
+    # @param params :buy_price_oco [decimal] If ocoorder is true, this field represent the price of the OCO stop order to place
+    # @return [Hash]
+    # @example:
+    #   client.new_order("usdbtc", 100, "market", "sell", 0)
+    def new_order(symbol, amount, type, side, price = nil, params = {})
+      check_params(params, %i{is_hidden is_postonly ocoorder buy_price_oco})
+
+      # for 'market' order, we need to pass a random positive price, not nil
+      price ||= 0.001 if type == "market" || type == "exchange market"
+
+      params.merge!({
+        symbol: symbol,
+        amount: amount.to_s,
+        type: type,
+        side: side,
+        exchange: 'gemini',
+        price: "%.10f" % price.to_f.round(10) # Decimalize float price (necessary for small numbers)
+      })
+      authenticated_post("order/new", params: params).body
+    end
+
+    # Submit several new orders at once
+    #
+    # @param orders [Array] Array of Hash with the following elements
+    # @param orders :symbol [string] The name of the symbol
+    # @param orders :amount [decimal] Order size: how much to buy or sell
+    # @param orders :price [decimal] Price to buy or sell at. May omit if a market order
+    # @param orders :exchange [string] "gemini"
+    # @param orders :side [string] Either “buy” or “sell”
+    # @param orders :type [string] Either “market” / “limit” / “stop” / “trailing-stop” / “fill-or-kill”
+    # @return [Hash] with a `object_id` that is an `Array`
+    # @example:
+    #   client.multiple_orders([{symbol: "usdbtc", amount: 10, price: 0, exchange: "gemini", side: "buy", type: "market"}])
+    def multiple_orders(orders)
+      authenticated_post("order/new/multi", params: orders).body
+    end
+
+    # Cancel an order
+    #
+    # @param ids [Array] or [integer] or nil
+    #   if it's Array it's supposed to specify a list of IDS
+    #   if it's an integer it's supposed to be a single ID
+    #   if it's not specified it deletes all the orders placed
+    # @return [Hash]
+    # @example
+    #   client.cancel_orders([100,231,400])
+    def cancel_orders(ids=nil)
+      case ids
+      when Array
+          authenticated_post("order/cancel/multi", params: {order_ids: ids.map(&:to_i)}).body
+      when Numeric, String
+          authenticated_post("order/cancel", params: {order_id: ids.to_i}).body
+      when NilClass
+          authenticated_post("order/cancel/all").body
+      else
+          raise ParamsError
+      end
+    end
+
+    # Replace an orders with a new one
+    #
+    # @param id [int] the ID of the order to replace
+    # @param symbol [string] the name of the symbol
+    # @param amount [decimal] Order size: how much to buy or sell
+    # @param type [string] Either “market” / “limit” / “stop” / “trailing-stop” / “fill-or-kill” / “exchange market” / “exchange limit” / “exchange stop” / “exchange trailing-stop” / “exchange fill-or-kill”. (type starting by “exchange ” are exchange orders, others are margin trading orders)
+    # @param side [string] Either “buy” or “sell”
+    # @param price [decimal] Price to buy or sell at. May omit if a market order
+    # @param is_hidden [bool] (optional) true if the order should be hidden. Default is false
+    # @param use_remaining [bool] (optional) will use the amount remaining of the canceled order as the amount of the new order. Default is false
+    # @return [Hash] the order
+    # @example:
+    #   client.replace_order(100,"usdbtc", 10, "market", "buy", 0)
+    def replace_order(id, symbol, amount, type, side, price, is_hidden=false, use_remaining=false)
+      params = {
+        order_id: id.to_i,
+        symbol: symbol,
+        amount: amount.to_s,
+        type: type,
+        side: side,
+        exchange: 'gemini',
+        is_hidden: is_hidden,
+        use_remaining: use_remaining,
+        price: price.to_s
+      }
+      authenticated_post("order/cancel/replace", params: params).body
+    end
+
+    # Get the status of an order. Is it active? Was it cancelled? To what extent has it been executed? etc.
+    #
+    # @param id
+    # @return [Hash]
+    # @exmaple:
+    #   client.order_status(100)
+    def order_status(id)
+      authenticated_post("order/status", params: {order_id: id.to_i}).body
+    end
+
+
+    # View your active orders.
+    #
+    # @return [Hash]
+    # @example:
+    #   client.orders
+    def orders
+      authenticated_post("orders").body
+    end
+
+  end
+end