excoin 0.0.1

data/lib/exchange/exchange.rb

@@ -0,0 +1,75 @@
+class Excoin::Market::Exchange
+  attr_reader :name, :currency, :commodity, :last_price, :daily_high,
+              :daily_low, :daily_volume, :top_bid, :lowest_ask, :orders,
+              :trades, :spread
+
+  def initialize(exchange_data)
+    begin
+      @name = exchange_data['currency'] + exchange_data['commodity']
+      @currency = exchange_data['currency']
+      @commodity = exchange_data['commodity']
+
+      self.update_summary(exchange_data)
+      @orders = Orders.new(self)
+      @trades = Trades.new(self)
+    rescue
+      puts "Error in Excoin::Market::Exchange.initialize"
+      puts exchange_data
+    end
+  end
+
+  def update_summary(exchange_data = nil)
+    begin
+      exchange_data ||= self.get_summary
+
+      @last_price = BigDecimal.new(exchange_data['last_price'])
+      @daily_high = BigDecimal.new(exchange_data['high'])
+      @daily_low = BigDecimal.new(exchange_data['low'])
+      @daily_volume = BigDecimal.new(exchange_data['volume'])
+      @top_bid = BigDecimal.new(exchange_data['top_bid'])
+      @lowest_ask = BigDecimal.new(exchange_data['lowest_ask'])
+      spread = self.top_bid - self.lowest_ask
+      @spread = (spread > 0 ? spread : (spread * -1))
+    rescue
+      puts "Error in Excoin::Market::Exchange.update_summary"
+      puts exchange_data
+    end
+  end
+
+  def update(exchange_data = nil)
+    self.update_summary(exchange_data)
+    @orders.update
+    @trades.update
+  end
+
+  def issue_order(type, amount, price)
+    decimal_amount = amount
+    if amount.class == String
+      decimal_amount = BigDecimal.new(amount)
+    end
+    if type.upcase == "BID" and (Excoin.account.wallet(self.currency).status == "inactive" or Excoin.account.wallet(self.currency).available_balance < decimal_amount)
+      return "Insufficient funds for this order (#{self.currency})"
+    elsif type.upcase == "ASK" and (Excoin.account.wallet(self.commodity).status == "inactive" or Excoin.account.wallet(self.commodity).available_balance < decimal_amount)
+      return "Insufficient funds for this order (#{self.commodity})"
+    else
+      begin
+        order = Excoin.api.account_issue_order(self.currency, self.commodity, type, amount, price)
+        order.merge!({"currency" => self.currency, "commodity" => self.commodity})
+        exchange_order = Excoin::Market::Exchange::Order.new(order)
+        account_order = Excoin::Account::Order.new(order)
+        self.orders.add(exchange_order)
+        Excoin.account.orders.add(account_order)
+        return account_order.id
+      rescue
+        puts "Error in Excoin::Market::Exchange.issue_order"
+        puts order
+      end
+    end
+  end
+
+  protected
+    def get_summary
+      Excoin.api(@api_key).exchange_summary(@currency, @commodity)
+    end
+
+end

data/lib/exchange/market.rb

@@ -0,0 +1,50 @@
+class Excoin::Market < Array
+
+  def initialize
+    self.refresh_all_data
+  end
+
+  def exchanges(currency)
+    return self.select{ |e| e.currency == currency }
+  end
+
+  def exchange(exchange_name)
+    return self.select{ |e| e.name == exchange_name }[0]
+  end
+
+  def update
+    exchanges_data = self.get_summary
+    begin
+      exchanges_data.each do |exchange_data|
+        if self.select{|e| e.exchange_name == exchange_data['currency'] + exchange_data['commodity']}.empty?
+          self.push(Exchange.new(exchange_data))
+        else
+          exchange.update(exchange_data)
+        end
+      end
+    rescue
+      puts "Error in Excoin::Market.update"
+      puts exchanges_data
+    end
+  end
+
+  def update_orders
+    self.each do |exchange|
+      exchange.orders.update
+    end
+  end
+
+  def refresh_all_data
+    self.clear
+    exchanges_data = self.get_summary
+    exchanges_data.each do |e|
+      self.push(Exchange.new(e))
+    end
+  end
+
+  protected
+    def get_summary
+      Excoin.api(@api_key).multiple_exchange_summary
+    end
+
+end

data/lib/exchange/order.rb

@@ -0,0 +1,23 @@
+class Excoin::Market::Exchange::Order
+  attr_reader :currency, :commodity, :type, :price,
+              :commodity_amount, :currency_amount
+
+  def initialize(order_data)
+    begin
+      @currency = order_data['currency']
+      @commodity = order_data['commodity']
+      @type = order_data['type']
+      @price = BigDecimal.new(order_data['price'])
+      @commodity_amount = BigDecimal.new(order_data['commodity_amount'])
+      @currency_amount = BigDecimal.new(order_data['currency_amount'])
+    rescue
+      puts "Error in Excoin::Market::Exchange::Order.initialize"
+      puts order_data
+    end
+  end
+
+  def exchange
+    return Excoin.market.exchange(@currency + @commodity)
+  end
+
+end

data/lib/exchange/order_depth_chart.rb

@@ -0,0 +1,41 @@
+class Excoin::Market::Exchange::OrderDepthChart
+  attr_reader :currency, :commodity, :bid_orders, :ask_orders
+
+  def initialize(exchange_name)
+    @exchange_name = exchange_name
+    exchange = self.exchange
+
+    @currency = exchange.currency
+    @commodity = exchange.commodity
+    self.update
+  end
+
+  def update
+    @bid_orders = Array.new
+    @ask_orders = Array.new
+    self.populate_orders
+  end
+
+  def exchange
+    return Excoin.market.exchange(@exchange_name)
+  end
+
+  protected
+
+    def populate_orders
+      data = self.get
+      data.each do |order_data|
+        order = DataPoint.new(order_data)
+        if order.type == "BID"
+          @bid_orders << order
+        elsif order.type == "ASK"
+          @ask_orders << order
+        end
+      end
+    end
+
+    def get
+      Excoin.api.exchange_order_depth_chart_data(@currency, @commodity)
+    end
+
+end

data/lib/exchange/order_depth_data.rb

@@ -0,0 +1,23 @@
+class Excoin::Market::Exchange::OrderDepthChart::DataPoint
+  attr_reader :type, :currency_amount, :price
+
+  def initialize(order_data)
+    update(order_data)
+  end
+
+  protected
+
+    def update(order_data)
+      begin
+        type_array = order_data.select{|h| h != "price"}.to_a.flatten
+        @type = type_array[0]
+        @currency_amount = type_array[1]
+        @price = BigDecimal.new(order_data['price'])
+      rescue
+        puts "Error in Excoin::Market::Exchange::OrderDepthChart::DataPoint.update"
+        puts order_data
+      end
+    end
+
+end
+

data/lib/exchange/orders.rb

@@ -0,0 +1,119 @@
+class Excoin::Market::Exchange::Orders
+  attr_reader :bids, :asks, :all, :orders
+
+  def initialize(exchange)
+    @currency = exchange.currency
+    @commodity = exchange.commodity
+    self.update
+  end
+
+  def update(type = nil)
+    unless type
+      order_data = self.get
+      begin
+        @orders = self.process_orders(order_data)
+        @bids = @orders['bid_orders']
+        @asks = @orders['ask_orders']
+        @all = self.populate_all
+      rescue
+        puts "Error in Excoin::Market::Exchange::Orders.update (unless type)"
+        puts order_data
+      end
+    else
+      order_data = self.get(type)
+      begin
+       orders_by_type = self.process_by_type(order_data)
+       @orders.merge!(orders_by_type)
+       self.set_order_arrays(type)
+      rescue
+        puts "Error in Excoin::Market::Exchange::Orders.update (else)"
+        puts order_data
+      end
+    end
+  end
+
+  def add(new_order)
+    begin
+      type = new_order.type.downcase
+      @orders.select{|k,v| k =~ Regexp.new(type)}[type + "_orders"] << new_order
+      if type == "BID"
+        @orders.select{|k,v| k =~ Regexp.new(type)}[type + "_orders"].sort_by{|order| order.price}.reverse!
+      elsif type == "ASK"
+        @orders.select{|k,v| k =~ Regexp.new(type)}[type + "_orders"].sort_by{|order| order.price}
+      end
+      self.set_order_arrays(new_order.type)
+    rescue
+      puts "Error in Excoin::Market::Exchange::Orders.add"
+      puts new_order
+    end
+  end
+
+  def remove(order_data)
+    begin
+      type = order_data['type'].downcase
+      @orders.select{|k,v| k =~ Regexp.new(type)}[type + "_orders"].delete_at(@orders.select{|k,v| k =~ Regexp.new(type)}[type + "_orders"].find_index{|order| order.price == BigDecimal.new(order_data['price']) and order.currency_amount == BigDecimal.new(order_data['currency_amount']) and order.commodity_amount == BigDecimal.new(order_data['commodity_amount'])})
+      self.set_order_arrays(order_data['type'])
+    rescue
+      puts "Error in Excoin::Market::Exchange::Orders.remove"
+      puts order_data
+    end
+  end
+
+  def filter(attr, value, operator = :==)
+    attr = attr.to_sym
+    if attr == :price or attr == :commodity_amount or attr == :currency_amount
+      value = BigDecimal.new(value)
+    end
+    return @all.select{|order| order.send(attr).send(operator, value)}
+  end
+
+  def count(attr, value, operator = :==)
+    return filter(attr, value, operator).size
+  end
+
+  protected
+
+    def get(type = nil)
+      Excoin.api.exchange_open_orders(@currency, @commodity, type)
+    end
+
+    def process_orders(exchange_order_data)
+      exchange_orders = Hash.new
+      exchange_order_data.each do |hash_by_type|
+        exchange_orders.merge!(process_by_type(hash_by_type))
+      end
+      return exchange_orders
+    end
+
+    def process_by_type(hash_by_type)
+      orders_by_type = Array.new
+      type = hash_by_type.select{|k,v| k == 'type'}
+      hash_by_type['orders'].each do |o|
+        o.merge!(type).merge!({"currency" => @currency, "commodity" => @commodity})
+        order = Excoin::Market::Exchange::Order.new(o)
+        orders_by_type << order
+      end
+      return { "#{type['type'].downcase}_orders" => orders_by_type }
+    end
+
+    def set_order_arrays(type)
+      if type.downcase == "bid"
+        @bids = @orders[type.downcase + "_orders"]
+      elsif type.downcase == "ask"
+        @asks = @orders[type.downcase + "_orders"]
+      end
+      @all = self.populate_all
+    end
+
+    def populate_all
+      all = Array.new
+      @bids.each do |o|
+        all << o
+      end
+      @asks.each do |o|
+        all << o
+      end
+      return all
+    end
+
+end

data/lib/exchange/trade.rb

@@ -0,0 +1,26 @@
+class Excoin::Market::Exchange::Trade
+  attr_reader :timestamp, :currency, :commodity, :type, :price,
+              :commodity_amount, :currency_amount
+
+
+  def initialize(trade_data)
+    begin
+      @timestamp = Time.parse(trade_data['timestamp'])
+      @currency = trade_data['currency']
+      @commodity = trade_data['commodity']
+      @type = trade_data['type']
+      @price = BigDecimal.new(trade_data['price'])
+      @commodity_amount = BigDecimal.new(trade_data['commodity_amount'])
+      @currency_amount = BigDecimal.new(trade_data['currency_amount'])
+    rescue
+      puts "Error in Excoin::Market::Exchange::Trade.initialize"
+      puts trade_data
+    end
+  end
+
+  def exchange
+    Excoin.market.exchange(@currency + @commodity)
+  end
+
+
+end

data/lib/exchange/trades.rb

@@ -0,0 +1,68 @@
+class Excoin::Market::Exchange::Trades < Array
+
+  def initialize(exchange)
+    @currency = exchange.currency
+    @commodity = exchange.commodity
+    self.update
+  end
+
+  def update(limit_type = "count", limit = 100)
+    self.clear
+    trade_data = self.get_recent(@currency, @commodity, limit_type, limit)
+    begin
+      trade_data['trades'].each do |trade|
+        self.push(Excoin::Market::Exchange::Trade.new(trade))
+      end
+    rescue
+      puts "Error in Excoin::Market::Exchange::Trades.update"
+      puts trade_data
+    end
+  end
+
+  def buys
+    self.select{|trade| trade.type == "BUY"}
+  end
+
+  def sells
+    self.select{|trade| trade.type == "SELL"}
+  end
+
+  def highest(type = nil)
+    unless type
+      self.max_by{|trade| trade.price}
+    else
+      self.select{|trade| trade.type == type.upcase}.max_by{|trade| trade.price}
+    end
+  end
+
+  def lowest(type = nil)
+    unless type
+      self.min_by{|trade| trade.price}
+    else
+      self.select{|trade| trade.type == type.upcase}.min_by{|trade| trade.price}
+    end
+  end
+
+  def add(trade_data)
+    begin
+      unless trade_data.has_key?("currency")
+        trade_data.merge!({"currency" => @currency, "commodity" => @commodity})
+      end
+      self.insert(0, Excoin::Market::Exchange::Trade.new(trade_data))
+    rescue
+      puts "Error in Excoin::Market::Exchange::Trades.add"
+      puts trade_data
+    end
+  end
+
+  def trim(number)
+    self.pop(number)
+  end
+
+  protected
+
+    def get_recent(currency, commodity, limit_type = "count", limit = 100)
+      Excoin.api.exchange_recent_trades(currency, commodity, limit_type, limit)
+    end
+
+end

data/lib/excoin.rb

@@ -0,0 +1,45 @@
+module Excoin
+  require "time"
+  require "bigdecimal"
+  require "bigdecimal/util"
+  require "excoin/api"
+  require "account/account"
+  require "account/wallet"
+  require "account/deposit"
+  require "account/withdrawal"
+  require "account/orders"
+  require "account/order"
+  require "account/trades"
+  require "account/trade"
+  require "exchange/market"
+  require "exchange/exchange"
+  require "exchange/orders"
+  require "exchange/order"
+  require "exchange/trades"
+  require "exchange/trade"
+  require "exchange/order_depth_chart"
+  require "exchange/order_depth_data"
+  require "exchange/candlestick_chart"
+  require "exchange/candlestick_data"
+
+
+  def self.account
+    self.api if @api.nil?
+    @account ||= Account.new
+  end
+
+  def self.exchange(exchange_name)
+    self.api if @api.nil?
+    @exchange ||= self.market.exchange(exchange_name)
+  end
+
+  def self.market
+    self.api if @api.nil?
+    @market ||= Market.new
+  end
+
+  def self.api(api_key = nil, api_secret = nil, replay_strategy = nil, strategy_parameter = nil)
+     @api ||= API.new(api_key, api_secret, replay_strategy, strategy_parameter)
+  end
+
+end