coinsync 0.1.0

data/lib/coinsync/importers/bittrex_csv.rb

@@ -0,0 +1,75 @@
+require 'bigdecimal'
+require 'csv'
+require 'time'
+
+require_relative 'base'
+require_relative '../currencies'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    class BittrexCSV < Base
+      register_importer :bittrex_csv
+
+      class HistoryEntry
+        TIME_FORMAT = '%m/%d/%Y %H:%M:%S %p %z'
+
+        attr_accessor :uuid, :currency, :asset, :type, :quantity, :limit, :commission, :price,
+          :time_opened, :time_closed
+
+        def initialize(line)
+          @uuid = line[0]
+          @currency, @asset = line[1].split('-').map { |c| CryptoCurrency.new(c) }
+          @type = line[2]
+          @quantity = BigDecimal.new(line[3])
+          @limit = BigDecimal.new(line[4])
+          @commission = BigDecimal.new(line[5])
+          @price = BigDecimal.new(line[6])
+          @time_opened = Time.strptime(line[7] + ' +0000', TIME_FORMAT)
+          @time_closed = Time.strptime(line[8] + ' +0000', TIME_FORMAT)
+        end
+      end
+
+      def read_transaction_list(source)
+        contents = source.read.gsub("\u0000", '').gsub("\r", '')
+        entries = []
+        transactions = []
+
+        CSV.parse(contents, col_sep: ',') do |line|
+          next if line[0] == 'OrderUuid'
+
+          entries << HistoryEntry.new(line)
+        end
+
+        entries.sort_by! { |e| [e.time_closed, e.uuid] }
+
+        entries.each do |entry|
+          case entry.type
+          when 'LIMIT_BUY', 'MARKET_BUY' then
+            transactions << Transaction.new(
+              exchange: 'Bittrex',
+              time: entry.time_closed,
+              bought_amount: entry.quantity,
+              bought_currency: entry.asset,
+              sold_amount: entry.price + entry.commission,
+              sold_currency: entry.currency
+            )
+          when 'LIMIT_SELL', 'MARKET_SELL' then
+            transactions << Transaction.new(
+              exchange: 'Bittrex',
+              time: entry.time_closed,
+              bought_amount: entry.price - entry.commission,   # TODO check this
+              bought_currency: entry.currency,
+              sold_amount: entry.quantity,
+              sold_currency: entry.asset
+            )
+          else
+            raise "Bittrex importer error: unexpected entry type '#{entry.type}'"
+          end
+        end
+
+        transactions
+      end
+    end
+  end
+end

data/lib/coinsync/importers/changelly.rb

@@ -0,0 +1,57 @@
+require 'bigdecimal'
+require 'csv'
+require 'time'
+
+require_relative 'base'
+require_relative '../currencies'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    class Changelly < Base
+      register_importer :changelly
+
+      class HistoryEntry
+        attr_accessor :status, :date, :exchanged_currency, :exchanged_amount, :received_currency, :received_amount
+
+        def initialize(line)
+          @status = line[0]
+          @date = Time.parse(line[1] + ' +0000')
+
+          amount, name = line[2].gsub(',', '').split(/\s+/)
+          @exchanged_currency = CryptoCurrency.new(name)
+          @exchanged_amount = BigDecimal.new(amount)
+
+          amount, name = line[6].gsub(',', '').split(/\s+/)
+          @received_currency = CryptoCurrency.new(name)
+          @received_amount = BigDecimal.new(amount)
+        end
+      end
+
+      def read_transaction_list(source)
+        csv = CSV.new(source, col_sep: ',')
+
+        transactions = []
+
+        csv.each do |line|
+          next if line[0] == 'Status'
+
+          entry = HistoryEntry.new(line)
+
+          next if entry.status != 'finished'
+
+          transactions << Transaction.new(
+            exchange: 'Changelly',
+            time: entry.date,
+            bought_amount: entry.received_amount,
+            bought_currency: entry.received_currency,
+            sold_amount: entry.exchanged_amount,
+            sold_currency: entry.exchanged_currency
+          )
+        end
+
+        transactions.reverse
+      end
+    end
+  end
+end

data/lib/coinsync/importers/circle.rb

@@ -0,0 +1,58 @@
+require 'bigdecimal'
+require 'csv'
+require 'time'
+
+require_relative 'base'
+require_relative '../currencies'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    class Circle < Base
+      register_importer :circle
+
+      class HistoryEntry
+        attr_accessor :date, :id, :type, :from_account, :to_account, :from_amount, :from_currency,
+          :to_amount, :to_currency, :status
+
+        def initialize(line)
+          @date = Time.strptime(line[0], '%a %b %d %Y %H:%M:%S GMT+0000 (%Z)')
+          @id = line[1]
+          @type = line[2]
+          @from_account = line[3]
+          @to_account = line[4]
+          @from_amount = BigDecimal.new(line[5].gsub(/[^\d\.]+/, ''))
+          @from_currency = FiatCurrency.new(line[6])
+          @to_amount = BigDecimal.new(line[7].gsub(/[^\d\.]+/, ''))
+          @to_currency = CryptoCurrency.new(line[8])
+          @status = line[9]
+        end
+      end
+
+      def read_transaction_list(source)
+        csv = CSV.new(source, col_sep: ',')
+
+        transactions = []
+
+        csv.each do |line|
+          next if line[0] == 'Date'
+
+          entry = HistoryEntry.new(line)
+
+          next if entry.type != 'deposit'
+
+          transactions << Transaction.new(
+            exchange: 'Circle',
+            bought_currency: entry.to_currency,
+            sold_currency: entry.from_currency,
+            time: entry.date,
+            bought_amount: entry.to_amount,
+            sold_amount: entry.from_amount
+          )
+        end
+
+        transactions
+      end
+    end
+  end
+end

data/lib/coinsync/importers/default.rb

@@ -0,0 +1,90 @@
+require 'bigdecimal'
+require 'csv'
+require 'time'
+
+require_relative 'base'
+require_relative '../currencies'
+require_relative '../formatter'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    class Default < Base
+      register_importer :default
+
+      class HistoryEntry
+        attr_accessor :lp, :exchange, :type, :date, :amount, :asset, :total, :currency
+      end
+
+      def initialize(config, params = {})
+        super
+        @decimal_separator = config.custom_decimal_separator
+        @formatter = Formatter.new(config)
+      end
+
+      def read_transaction_list(source)
+        csv = CSV.new(source, col_sep: @config.column_separator)
+
+        transactions = []
+
+        csv.each do |line|
+          next if line.empty?
+          next if line.all? { |f| f.to_s.strip == '' }
+          next if line[0] == 'Lp'
+
+          entry = parse_line(line)
+
+          if entry.type.downcase == Transaction::TYPE_PURCHASE.to_s
+            transactions << Transaction.new(
+              exchange: entry.exchange,
+              bought_currency: entry.asset,
+              sold_currency: entry.currency,
+              time: entry.date,
+              bought_amount: entry.amount,
+              sold_amount: entry.total
+            )
+          elsif entry.type.downcase == Transaction::TYPE_SALE.to_s
+            transactions << Transaction.new(
+              exchange: entry.exchange,
+              bought_currency: entry.currency,
+              sold_currency: entry.asset,
+              time: entry.date,
+              bought_amount: entry.total,
+              sold_amount: entry.amount
+            )
+          else
+            raise "Default importer error: unexpected entry type '#{entry.type}'"
+          end
+        end
+
+        transactions
+      end
+
+      private
+
+      def parse_line(line)
+        entry = HistoryEntry.new
+
+        entry.lp = line[0].to_i
+        entry.exchange = line[1]
+        entry.type = line[2]
+        entry.date = Time.parse(line[3])
+        entry.amount = @formatter.parse_decimal(line[4])
+        entry.asset = CryptoCurrency.new(line[5])
+        entry.total = @formatter.parse_decimal(line[6])
+
+        entry.currency = if line[7].to_s.start_with?('$')
+          CryptoCurrency.new(line[7][1..-1])
+        else
+          FiatCurrency.new(line[7])
+        end
+
+        if entry.currency.code.nil? && entry.total > 0
+          raise "Default importer error: Currency must be specified if total value is non-zero"
+        end
+
+        entry
+      end
+    end
+  end
+end

data/lib/coinsync/importers/etherdelta.rb

@@ -0,0 +1,93 @@
+require 'bigdecimal'
+require 'csv'
+require 'time'
+
+require_relative 'base'
+require_relative '../currencies'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    # Look up your transactions using DeltaBalances at https://deltabalances.github.io/history.html,
+    # specifying the time range you need, and then download the "Default" CSV in the top-right section
+
+    class EtherDelta < Base
+      register_importer :etherdelta
+
+      ETH = CryptoCurrency.new('ETH')
+
+      class HistoryEntry
+        attr_accessor :type, :trade, :token, :amount, :price, :total, :date, :fee, :fee_token
+
+        def initialize(line)
+          @type = line[0]
+
+          if !['Maker', 'Taker'].include?(@type)
+            raise "EtherDelta importer: incorrect csv format - unexpected '#{@type}' in the first column"
+          end
+
+          @trade = line[1]
+
+          if !['Buy', 'Sell'].include?(@trade)
+            raise "EtherDelta importer: incorrect csv format - unexpected '#{@trade}' in the second column"
+          end
+
+          @token = CryptoCurrency.new(line[2])
+
+          @amount = BigDecimal.new(line[3])
+          @price = BigDecimal.new(line[4])
+          @total = BigDecimal.new(line[5])
+          
+          @date = Time.parse(line[6])
+
+          @fee = BigDecimal.new(line[11])
+          @fee_token = CryptoCurrency.new(line[12])
+        end
+      end
+
+      def read_transaction_list(source)
+        csv = CSV.new(source, col_sep: ',')
+
+        transactions = []
+
+        csv.each do |line|
+          next if line[0] == 'Type'
+
+          entry = HistoryEntry.new(line)
+
+          next if entry.amount.round(8) == 0 || entry.total.round(8) == 0
+
+          if entry.trade == 'Buy'
+            if entry.fee_token != ETH
+              raise "EtherDelta importer: Unexpected fee currency: #{entry.fee_token.code}"
+            end
+
+            transactions << Transaction.new(
+              exchange: 'EtherDelta',
+              time: entry.date,
+              bought_amount: entry.amount,
+              bought_currency: entry.token,
+              sold_amount: entry.total + entry.fee,
+              sold_currency: ETH
+            )
+          else
+            if entry.fee_token != entry.token
+              raise "EtherDelta importer: Unexpected fee currency: #{entry.fee_token.code}"
+            end
+
+            transactions << Transaction.new(
+              exchange: 'EtherDelta',
+              time: entry.date,
+              bought_amount: entry.total,
+              bought_currency: ETH,
+              sold_amount: entry.amount + entry.fee,
+              sold_currency: entry.token
+            )
+          end
+        end
+
+        transactions.sort_by(&:time)
+      end
+    end
+  end
+end

data/lib/coinsync/importers/kraken_api.rb

@@ -0,0 +1,134 @@
+require 'base64'
+require 'bigdecimal'
+require 'json'
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+require_relative 'base'
+require_relative 'kraken_common'
+require_relative '../balance'
+require_relative '../currencies'
+require_relative '../request'
+
+module CoinSync
+  module Importers
+    class KrakenAPI < Base
+      register_importer :kraken_api
+
+      include Kraken::Common
+
+      BASE_URL = "https://api.kraken.com"
+      API_RENEWAL_INTERVAL = 3.0
+
+      def initialize(config, params = {})
+        super
+        @api_key = params['api_key']
+        @secret_api_key = params['private_key']
+        @decoded_secret = Base64.decode64(@secret_api_key) if @secret_api_key
+      end
+
+      def can_import?(type)
+        @api_key && @secret_api_key && [:balances, :transactions].include?(type)
+      end
+
+      def import_transactions(filename)
+        offset = 0
+        entries = []
+        slowdown = false
+
+        loop do
+          response = make_request('/0/private/Ledgers', ofs: offset)
+          print slowdown ? '-' : '.'
+          sleep(2 * API_RENEWAL_INTERVAL) if slowdown   # rate limiting
+
+          case response
+          when Net::HTTPSuccess
+            json = JSON.parse(response.body)
+
+            if json['result'].nil? || json['error'].length > 0
+              if json['error'].first == 'EAPI:Rate limit exceeded'
+                slowdown = true
+                print '!'
+                sleep(4 * API_RENEWAL_INTERVAL)
+                next
+              else
+                raise "Kraken importer: Invalid response: #{response.body}"
+              end
+            end
+
+            data = json['result']
+            list = data && data['ledger']
+
+            if !list
+              raise "Kraken importer: No data returned: #{response.body}"
+            end
+
+            break if list.empty?
+
+            entries.concat(list.values)
+            offset += list.length
+          when Net::HTTPBadRequest
+            raise "Kraken importer: Bad request: #{response.body}"
+          else
+            raise "Kraken importer: Bad response: #{response.body}"
+          end
+        end
+
+        File.write(filename, JSON.pretty_generate(entries) + "\n")
+      end
+
+      def import_balances
+        response = make_request('/0/private/Balance')
+
+        case response
+        when Net::HTTPSuccess
+          json = JSON.parse(response.body)
+
+          if !json['error'].empty? || !json['result']
+            raise "Kraken importer: Invalid response: #{response.body}"
+          end
+
+          return json['result'].map { |k, v|
+            [Kraken::LedgerEntry.parse_currency(k), BigDecimal.new(v)]
+          }.select { |currency, amount|
+            amount > 0 && currency.crypto?
+          }.map { |currency, amount|
+            Balance.new(currency, available: amount)
+          }
+        when Net::HTTPBadRequest
+          raise "Kraken importer: Bad request: #{response.body}"
+        else
+          raise "Kraken importer: Bad response: #{response.body}"
+        end
+      end
+
+      def read_transaction_list(source)
+        json = JSON.parse(source.read)
+
+        build_transaction_list(json.map { |hash| Kraken::LedgerEntry.from_json(hash) })
+      end
+
+      private
+
+      def make_request(path, params = {})
+        (@api_key && @secret_api_key) or raise "Public and secret API keys must be provided"
+
+        nonce = (Time.now.to_f * 1000).to_i
+
+        url = URI(BASE_URL + path)
+        params['nonce'] = nonce
+
+        post_data = URI.encode_www_form(params)
+        string_to_hash = path + OpenSSL::Digest.new('sha256', nonce.to_s + post_data).digest
+        hmac = Base64.strict_encode64(OpenSSL::HMAC.digest('sha512', @decoded_secret, string_to_hash))
+
+        Request.post(url) do |request|
+          request.body = post_data
+          request['API-Key'] = @api_key
+          request['API-Sign'] = hmac
+        end
+      end
+    end
+  end
+end