trade-o-matic 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9300715275fb3f78ca15a6d534d493f61c75ea7e
-  data.tar.gz: b3f66fd9b2f31736c86260f45c817ea8dc85dc01
+  metadata.gz: 9b2ab1e0af6b6c8685d51d92657660229ac270e4
+  data.tar.gz: f03f687cbae9e0d8436d5b879166ae186a57bd16
 SHA512:
-  metadata.gz: 5208ae28f7c8d4da98d1a65bfdef0f1f9b2b1a09e4744ee79b87c32f104a6c9e71ceca7ea4045af8cba160c7b4ffca7f2b338b694cb514310957791e3fd24897
-  data.tar.gz: 4efe51fef441d0a483e38a766743268f87bf4fb9a968496763c85befd879aa6e05902b5732e24e6e525199e83c4e2435019ca16130341f5ed25f9e18cd7e0b5a
+  metadata.gz: c524eb2a14bf4d3258e98356ed20493b2ce7943488833137c53fc338ba9a4181c082a4d8a63e0eb08d46cc0a4d0f8e3d400d6ce38c1909cba93f493d75d1db92
+  data.tar.gz: 3e5696eafbdcf0e0022166540eace85363ae4f88fb28704d14ea27cf1c1596c5868e8f97c5a2d2ee8756f54f993f2f95b72b0ced2bbdf1da9bb4f64da90adac6

data/lib/trade-o-matic/adapters/base/raw_account_order.rb

@@ -0,0 +1,7 @@
+require 'trade-o-matic/adapters/base/raw_resource'
+
+module Trader
+  class RawAccountOrder < RawResource
+    enforce_attr :id, :status, :price, :volume, :executed_volume, :instruction, :limit?
+  end
+end

data/lib/trade-o-matic/adapters/base/raw_balance.rb

@@ -0,0 +1,7 @@
+require 'trade-o-matic/adapters/base/raw_resource'
+
+module Trader
+  class RawBalance < RawResource
+    enforce_attr :amount, :available_amount
+  end
+end

data/lib/trade-o-matic/adapters/base/raw_resource.rb

@@ -0,0 +1,31 @@
+module Trader
+  class RawResource
+
+    def self.enforce_attr(*_attrs)
+      _attrs.each do |att|
+        define_method(att) do
+          raise NotImplementedError, "#{att} was not implemented by backend"
+        end
+      end
+    end
+
+    def self.attr_mapped(_attr, _path=nil, &_block)
+      define_method(_attr) do
+        if _block
+          _block.call(raw)
+        elsif _path
+          raw[_path]
+        else
+          raw[_attr.to_s]
+        end
+      end
+    end
+
+    attr_reader :raw
+
+    def initialize(_raw)
+      @raw = _raw
+    end
+
+  end
+end

data/lib/trade-o-matic/adapters/bitstamp_backend.rb

@@ -0,0 +1,166 @@
+require 'rest-client'
+require 'json'
+require 'trade-o-matic/adapters/base/raw_account_order'
+require 'trade-o-matic/adapters/base/raw_balance'
+
+module Trader
+  class BitstampBackend
+    BASE_CUR = Currency.for_code(:BTC)
+    QUOTE_CUR = Currency.for_code(:BITSTAMP_USD)
+    MAIN_MARKET = CurrencyPair.new BASE_CUR, QUOTE_CUR
+
+    TYPE_MAP = {
+      0 => Order::BID,
+      1 => Order::ASK
+    }
+
+    class BackendBalance < Struct.new(:amount, :available_amount)
+      # nothing for now
+    end
+
+    class BitstampOrder < RawAccountOrder
+      attr_mapped(:id, 'raw') # use original order information as id
+      attr_mapped(:pair) { |r| MAIN_MARKET }
+      attr_mapped(:price) { |r| r['raw']['price'].to_f }
+      attr_mapped(:volume) { |r| r['raw']['amount'].to_f }
+      attr_mapped(:executed_volume)
+      attr_mapped(:instruction) { |r| r['raw']['type'] == 0 ? Order::BID : Order::ASK }
+
+      attr_mapped(:status) do |r|
+        case r['status']
+        when 'Open'
+          AccountOrder::OPEN
+        when 'Finished'
+          r['executed_volume'] < r['raw']['amount'].to_f ? AccountOrder::CANCELED : AccountOrder::CLOSED
+        else
+          AccountOrder::PENDING
+        end
+      end
+
+      def limit?
+        true
+      end
+    end
+
+    def initialize(_session=nil)
+      @session = _session
+    end
+
+    def get_available_markets
+      [MAIN_MARKET]
+    end
+
+    def fill_book(_book)
+      # TODO: consider book pair
+
+      _book.prepare Time.now
+
+      ob = execute_request(nil, 'order_book')
+      ob['bids'].each { |o| _book.add_bid(o[0].to_f, o[1].to_f) }
+      ob['asks'].each { |o| _book.add_ask(o[0].to_f, o[1].to_f) }
+
+      tx = execute_request(nil, 'transactions')
+      tx.each do |t|
+        _book.add_transaction t['price'].to_f, t['amount'].to_f, Time.at(t['date'].to_i)
+      end
+    end
+
+    def get_session(_credentials)
+      _credentials
+    end
+
+    def get_balance(_session, _currency)
+      raise "#{_currency} not supported" unless _currency == BASE_CUR || _currency == QUOTE_CUR
+
+      raw = execute_request(_session || session, 'balance')
+
+      if _currency == BASE_CUR
+        return BackendBalance.new raw['btc_balance'].to_f, raw['btc_available'].to_f
+      else
+        return BackendBalance.new raw['usd_balance'].to_f, raw['usd_available'].to_f
+      end
+    end
+
+    def get_orders(_session, _pair)
+      raise 'market not supported' unless _pair == MAIN_MARKET
+
+      raw_orders = execute_request(_session || session, 'open_orders')
+      raw_orders.map { |o| normalize_raw_order o }
+    end
+
+    def create_order(_session, _pair, _volume, _price, _type)
+      raise 'market not supported' unless _pair == MAIN_MARKET
+      raise 'market orders not supported' if _price.nil?
+
+      normalize_raw_order execute_request(
+        _session || session,
+        _type == Order::BID ? 'buy' : 'sell',
+        { amount: _volume, price: _price }
+      )
+    end
+
+    def fetch_order(_session, _id)
+      normalize_raw_order_status _id, execute_request(
+        _session || session,
+        'order_status',
+        { id: _id['id'] }
+      )
+    end
+
+    def cancel_order(_session, _id)
+      # TODO
+    end
+
+    private
+
+    attr_reader :session
+
+    def execute_request(_signing, _resource, _data=nil)
+      _data = sign_params _signing, _data if _signing
+
+      JSON.parse(if _data.nil?
+        RestClient.get "https://www.bitstamp.net/api/#{_resource}/"
+      else
+        RestClient.post "https://www.bitstamp.net/api/#{_resource}/", _data
+      end)
+    end
+
+    def sign_params(_keys, _params)
+      nonce = (Time.now.to_f*10000).to_i.to_s
+
+      customer_id = _keys[:customer_id].to_s
+      api_key = _keys[:api_key]
+      api_secret = _keys[:api_secret]
+
+      digest = OpenSSL::Digest.new('sha256')
+      signature_data = "#{nonce}#{customer_id}#{api_key}"
+      signature = OpenSSL::HMAC.hexdigest(digest, api_secret, signature_data)
+
+      (_params || {}).merge({
+        nonce: nonce,
+        signature: signature.upcase,
+        key: api_key
+      })
+    end
+
+    def normalize_raw_order(_order)
+      BitstampOrder.new({
+        'raw' => _order,
+        'executed_volume' => 0.0,
+        'status' => 'In Queue'
+      })
+    end
+
+    def normalize_raw_order_status(_id, _status)
+      executed_volume = _status['transactions'].inject(0.0) { |r, t| r + t['btc'].to_f }
+      executed_price = _status['transactions'].inject(0.0) { |r, t| r + (t['price'].to_f * t['btc'].to_f) }
+
+      BitstampOrder.new({
+        'raw' => _id,
+        'executed_volume' => executed_volume,
+        'executed_price' => executed_price / executed_volume,
+        'status' => _status['status']
+      })
+    end
+  end
+end

data/lib/trade-o-matic/adapters/fake_backend.rb

@@ -0,0 +1,235 @@
+require 'rest-client'
+require 'json'
+require 'trade-o-matic/adapters/base/raw_account_order'
+require 'rainbow'
+require 'rainbow/ext/string'
+
+module Trader
+  class FakeBackend
+    class FakeBalance < Struct.new(:amount, :available_amount);
+    end
+
+    class FakeOrder < RawAccountOrder
+      attr_mapped(:id, :id)
+      attr_mapped(:pair, :pair)
+      attr_mapped(:price, :price)
+      attr_mapped(:volume) { |r| r[:pend_volume] + r[:traded_volume] }
+      attr_mapped(:executed_volume, :traded_volume)
+      attr_mapped(:instruction, :instruction)
+      attr_mapped(:status, :status)
+
+      def limit?
+        true
+      end
+    end
+
+    attr_reader :pair, :asks, :bids, :verbose
+
+    def open_bids
+      bids.select { |o| o[:status] == AccountOrder::OPEN }
+    end
+
+    def open_asks
+      asks.select { |o| o[:status] == AccountOrder::OPEN }
+    end
+
+    def open_orders
+      open_bids + open_asks
+    end
+
+    def self.instance
+      @@instance ||= self.new
+    end
+
+    def self.reset_instance
+      @@instance = nil
+    end
+
+    def initialize(_config=nil)
+      get_session(_config) unless _config.nil?
+    end
+
+    def get_available_markets
+      [@pair]
+    end
+
+    def fill_book(_book)
+      # TODO
+    end
+
+    def available_base_balance
+      @base_balance
+    end
+
+    def available_quote_balance
+      @quote_balance
+    end
+
+    def total_base_balance
+      @base_balance + frozen_base
+    end
+
+    def total_quote_balance
+      @quote_balance + frozen_quote
+    end
+
+    def get_session(_config)
+      raise ArgumentError, 'must provide login information' if _config.nil?
+
+      if @config.nil?
+        @pair = CurrencyPair.for_code(_config[:base], _config[:quote])
+        @base_balance = _config[:base_balance]
+        @quote_balance = _config[:quote_balance]
+        @verbose = !!_config[:verbose]
+        @config = _config
+        @bids = []
+        @asks = []
+        @id = 1
+      elsif @config != _config
+        raise ArgumentError, 'invalid credentials'
+      end
+
+      nil
+    end
+
+    def get_balance(_session, _currency)
+      if _currency == pair.base
+        FakeBalance.new(total_base_balance, available_base_balance)
+      elsif _currency == pair.quote
+        FakeBalance.new(total_quote_balance, available_quote_balance)
+      else
+        raise 'currency not supported'
+      end
+    end
+
+    def get_orders(_session, _pair)
+      return [] unless _pair == pair
+      (@bids + @asks).map { |o| FakeOrder.new o.clone }
+    end
+
+    def create_order(_session, _pair, _volume, _price, _instruction)
+      raise 'market not supported' unless _pair == pair
+      raise 'market orders not supported' if _price.nil?
+
+      if _instruction == Order::ASK
+        raise 'Not enough funds' if _volume > @base_balance
+        @base_balance -= _volume
+      else
+        raise 'Not enough funds' if _volume * _price > @quote_balance
+        @quote_balance -= _volume * _price
+      end
+
+      info "Creating #{_instruction} order for #{_volume} #{pair.base} @ #{_price} #{pair.quote}", :green
+
+      raw_order = {
+        id: @id.to_s,
+        pair: pair,
+        instruction: _instruction,
+        status: AccountOrder::OPEN,
+        price: _price,
+        pend_volume: _volume,
+        traded_volume: 0.0
+      }
+
+      @id += 1
+      (_instruction == Order::ASK ? @asks : @bids) << raw_order
+
+      FakeOrder.new raw_order.clone
+    end
+
+    def fetch_order(_session, _order_id)
+      FakeOrder.new find_order_by_id(_order_id).clone
+    end
+
+    def cancel_order(_session, _order_id)
+      order = find_order_by_id(_order_id)
+
+      info "Closing #{order[:instruction]} order for #{order[:pend_volume] + order[:traded_volume]} #{pair.base} @ #{order[:price]} #{pair.quote}", :red
+
+      if order[:status] == AccountOrder::OPEN
+        if order[:instruction] == Order::ASK
+          @base_balance += order[:pend_volume]
+        else
+          @quote_balance += order[:pend_volume] * order[:price]
+        end
+        order[:status] = AccountOrder::CANCELED
+      end
+
+      FakeOrder.new order.clone
+    end
+
+    def simulate_buy(_price, _volume)
+      ordered_asks = @asks.sort { |b| b[:price] * -1 }
+      ordered_asks.each do |order|
+        if order[:status] == AccountOrder::OPEN and order[:price] <= _price and _volume > 0
+          if order[:pend_volume] > _volume
+            @quote_balance += _volume * order[:price]
+            order[:pend_volume] -= _volume
+            order[:traded_volume] += _volume
+            _volume = 0
+          else
+            @quote_balance += order[:pend_volume] * order[:price]
+            _volume -= order[:pend_volume]
+            order[:traded_volume] += order[:pend_volume]
+            order[:pend_volume] = 0
+          end
+
+          if order[:pend_volume] == 0
+            order[:status] = AccountOrder::CLOSED
+          end
+        end
+      end
+    end
+
+    def simulate_sell(_price, _volume)
+      ordered_bids = @bids.sort { |b| b[:price] }
+      ordered_bids.each do |order|
+        if order[:status] == AccountOrder::OPEN and order[:price] >= _price and _volume > 0
+          if order[:pend_volume] > _volume
+            @base_balance += _volume
+            order[:pend_volume] -= _volume
+            order[:traded_volume] += _volume
+            _volume = 0
+          else
+            @base_balance += order[:pend_volume]
+            _volume -= order[:pend_volume]
+            order[:traded_volume] += order[:pend_volume]
+            order[:pend_volume] = 0
+          end
+
+          if order[:pend_volume] == 0
+            order[:status] = AccountOrder::CLOSED
+          end
+        end
+      end
+    end
+
+  private
+
+    def info(_msg, _color=:white)
+      if verbose
+        puts "FakeEx: #{_msg}".color(_color)
+      end
+    end
+
+    def frozen_base
+      @asks.inject(0) do |r, order|
+        next r if order[:status] != AccountOrder::OPEN
+        r + order[:pend_volume]
+      end
+    end
+
+    def frozen_quote
+      @bids.inject(0) do |r, order|
+        next r if order[:status] != AccountOrder::OPEN
+        r + (order[:pend_volume] * order[:price])
+      end
+    end
+
+    def find_order_by_id(_id)
+      order = @bids.find { |o| o[:id] == _id }
+      order = @asks.find { |o| o[:id] == _id } if order.nil?
+      order
+    end
+  end
+end

data/lib/trade-o-matic/adapters/itbit_backend.rb

@@ -0,0 +1,57 @@
+require 'rest-client'
+require 'json'
+require 'time'
+
+module Trader
+  class ItbitBackend
+    def fill_book(_book)
+      # TODO: consider book pair
+
+      _book.prepare Time.now
+
+      ob = fetch_raw_order_book _book.pair
+      ob['bids'].each { |o| _book.add_bid(o[0].to_f, o[1].to_f) }
+      ob['asks'].each { |o| _book.add_ask(o[0].to_f, o[1].to_f) }
+
+      tx = fetch_raw_transactions _book.pair
+      tx['recentTrades'].each do |t|
+        _book.add_transaction t['price'].to_f, t['amount'].to_f, Time.parse(t['timestamp'])
+      end
+    end
+
+    def get_available_markets
+      # TODO.
+    end
+
+    def get_session(_credentials)
+      _credentials
+    end
+
+    def get_balance(_session, _currency)
+      return Price.new(_currency, 0.0) if _currency.code == :BTC
+      return Price.new(_currency, 20000.0) if _currency.code == :Bitstamp_USD
+    end
+
+    def get_orders(_session, _pair)
+    end
+
+    def create_order(_session, _pair, _volume, _price, _type)
+    end
+
+    def fetch_order(_session, _order)
+    end
+
+    def cancel_order(_session, _order)
+    end
+
+    private
+
+    def fetch_raw_order_book(_pair)
+      JSON.parse(RestClient.get "https://api.itbit.com/v1/markets/XBTUSD/order_book")
+    end
+
+    def fetch_raw_transactions(_pair)
+      JSON.parse(RestClient.get "https://api.itbit.com/v1/markets/XBTUSD/trades")
+    end
+  end
+end

data/lib/trade-o-matic/adapters/surbtc_backend.rb

@@ -0,0 +1,149 @@
+require 'rest-client'
+require 'json'
+require 'trade-o-matic/adapters/base/raw_account_order'
+require 'trade-o-matic/adapters/base/raw_balance'
+
+module Trader
+  class SurbtcBackend
+    API_PREFIX = 'https://www.surbtc.com/api/v1'
+
+    TYPE_MAP = {
+      'ask' => Order::ASK,
+      'bid' => Order::BID
+    }
+
+    STATUS_MAP = {
+      'received' => AccountOrder::PENDING,
+      'pending' => AccountOrder::OPEN,
+      'traded' => AccountOrder::CLOSED,
+      'canceling' => AccountOrder::OPEN,
+      'canceled' => AccountOrder::CANCELED
+    }
+
+    MAIN_MARKET = CurrencyPair.new(:SATOSHI, :SURBTC_CLP)
+
+    class SurbtcBalance < RawBalance
+      attr_mapped :amount
+      attr_mapped :available_amount
+    end
+
+    class SurbtcBalanceBTC < RawBalance
+      attr_mapped(:amount) { |r| r['amount'].to_f }
+      attr_mapped(:available_amount) { |r| r['available_amount'].to_f }
+    end
+
+    class SurbtcOrder < RawAccountOrder
+      attr_mapped(:id)
+      attr_mapped(:pair) { |r| MAIN_MARKET }
+      attr_mapped(:price) { |r| r['limit'] }
+      attr_mapped(:volume) { |r| r['original_amount'].to_f }
+      attr_mapped(:executed_volume) { |r| r['total_exchanged'].to_f }
+      attr_mapped(:instruction) { |r| TYPE_MAP[r['type']] }
+      attr_mapped(:status) { |r| STATUS_MAP[r['state']] }
+      attr_mapped(:limit?) { |r| r['price_type'] == 'limit' }
+    end
+
+    def get_available_markets
+      [MAIN_MARKET]
+    end
+
+    def fill_book(_book)
+      # TODO
+    end
+
+    def get_session(_credentials)
+      _credentials
+    end
+
+    def get_balance(_session, _currency)
+      res = resource_for "balances/#{currency_code_for(_currency)}", _session
+      raw_balance = postprocess res.get
+
+      if _currency == MAIN_MARKET.base
+        SurbtcBalanceBTC.new raw_balance['balance']
+      else
+        SurbtcBalance.new raw_balance['balance']
+      end
+    end
+
+    def get_orders(_session, _pair)
+      res = resource_for "markets/#{market_code_for(_pair)}/orders", _session
+
+      raw_orders = postprocess res.get
+      raw_orders['orders'].map { |o| SurbtcOrder.new o }
+    end
+
+    def create_order(_session, _pair, _volume, _price, _instruction)
+      raise 'market not supported' unless _pair == MAIN_MARKET
+
+      res = resource_for "markets/#{market_code_for(_pair)}/orders", _session
+
+      raw_order = postprocess res.post({
+        order: build_order_json(_price, _volume, _instruction)
+      }, :content_type => 'application/json')
+
+      SurbtcOrder.new raw_order['order']
+    end
+
+    def fetch_order(_session, _order_id)
+      res = resource_for "orders/#{_order_id}", _session
+
+      raw_order = postprocess res.get
+      SurbtcOrder.new raw_order['order']
+    end
+
+    def cancel_order(_session, _order_id)
+      res = resource_for "orders/#{_order_id}", _session
+
+      raw_order = postprocess res.put({
+        state: 'canceling'
+      }, :content_type => 'application/json')
+
+      while raw_order['order']['state'] == 'canceling'
+        raw_order = postprocess res.get
+      end
+
+      SurbtcOrder.new raw_order['order']
+    end
+
+    private
+
+    def resource_for(_url, _session=nil)
+      res = RestClient::Resource.new "#{API_PREFIX}/#{_url}"
+      res.options[:headers] = { params: { 'api_key' => _session[:api_key] } } if _session
+      res
+    end
+
+    def postprocess(_response)
+      # TODO: handle error responses
+      JSON.parse _response
+    end
+
+    def currency_code_for(_currency)
+      return 'clp' if _currency.code == :SURBTC_CLP
+      return 'btc' if _currency.code == :SATOSHI
+      _currency.to_s.downcase
+    end
+
+    def market_code_for(_pair)
+      "#{currency_code_for(_pair.base)}-#{currency_code_for(_pair.quote)}"
+    end
+
+    def build_order_json(_price, _volume, _instruction)
+      if _price.nil?
+        {
+          amount: _volume,
+          type: _instruction == Order::BID ? 'bid' : 'ask',
+          price_type: 'market'
+        }
+      else
+        {
+          limit: _price,
+          amount: _volume,
+          type: _instruction == Order::BID ? 'bid' : 'ask',
+          price_type: 'limit'
+        }
+      end
+    end
+  end
+end