coinsync 0.1.0

data/lib/coinsync/importers/bitbay20.rb

@@ -0,0 +1,144 @@
+require 'bigdecimal'
+require 'csv'
+require 'time'
+
+require_relative 'base'
+require_relative '../currencies'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    class BitBay20 < Base
+      register_importer :bitbay20
+
+      OP_PAY_BUYING = 'Pay for buying currency'
+      OP_PAY_SELLING = 'Pay for selling currency'
+      OP_PURCHASE = 'Currency purchase'
+      OP_SALE = 'Currency sale'
+      OP_FEE = 'Transaction fee'
+
+      MAX_TIME_DIFFERENCE = 5.0
+
+      TRANSACTION_TYPES = [OP_PAY_BUYING, OP_PAY_SELLING, OP_PURCHASE, OP_SALE, OP_FEE]
+
+      class HistoryEntry
+        attr_accessor :date, :accounting_date, :type, :amount, :currency
+
+        def initialize(line)
+          # TODO: force parsing in Polish timezone
+          @date = Time.parse(line[0]) unless line[0] == '-'
+          @accounting_date = Time.parse(line[1]) unless line[1] == '-'
+          @type = line[2]
+
+          amount, currency = line[3].split(' ')
+          @amount = BigDecimal.new(amount.gsub(/,/, ''))
+          @currency = parse_currency(currency)
+        end
+
+        def crypto?
+          @currency.crypto?
+        end
+
+        def fiat?
+          @currency.fiat?
+        end
+
+        def parse_currency(code)
+          case code
+          when 'BTC' then CryptoCurrency.new('BTC')
+          when 'ETH' then CryptoCurrency.new('ETH')
+          when 'LSK' then CryptoCurrency.new('LSK')
+          when 'LTC' then CryptoCurrency.new('LTC')
+          when 'PLN' then FiatCurrency.new('PLN')
+          else raise "Unknown currency: #{code}"
+          end
+        end
+      end
+
+      def read_transaction_list(source)
+        csv = CSV.new(source, col_sep: ';')
+
+        matching = []
+        transactions = []
+
+        csv.each do |line|
+          next if line.empty?
+          next if line[0] !~ /^\d/
+
+          entry = HistoryEntry.new(line)
+
+          next unless TRANSACTION_TYPES.include?(entry.type)
+
+          if !matching.empty? && matching.any? { |e| (e.date - entry.date).abs > MAX_TIME_DIFFERENCE }
+            if matching.any? { |e| e.type != OP_FEE }
+              raise "BitBay importer error: Couldn't match some history lines"
+            else
+              matching.clear
+            end
+          end
+
+          matching << entry
+
+          if matching.length == 3
+            matching.sort_by!(&:type)
+            types = matching.map(&:type)
+            time = matching.map(&:date).sort.last
+
+            if types == [OP_PURCHASE, OP_PAY_BUYING, OP_FEE] &&
+              matching[0].crypto? && matching[0].amount > 0 &&
+              matching[1].fiat? && matching[1].amount < 0 &&
+              matching[2].crypto? && matching[2].amount <= 0 &&
+              matching[0].currency == matching[2].currency
+                transactions << Transaction.new(
+                  exchange: 'BitBay',
+                  bought_currency: matching[0].currency,
+                  sold_currency: matching[1].currency,
+                  time: time,
+                  bought_amount: matching[0].amount + matching[2].amount,
+                  sold_amount: -matching[1].amount
+                )
+            elsif types == [OP_SALE, OP_PAY_SELLING, OP_FEE] &&
+              matching[0].crypto? && matching[0].amount < 0 &&
+              matching[1].fiat? && matching[1].amount > 0 &&
+              matching[2].fiat? && matching[2].amount <= 0 &&
+              matching[1].currency == matching[2].currency
+                transactions << Transaction.new(
+                  exchange: 'BitBay',
+                  bought_currency: matching[1].currency,
+                  sold_currency: matching[0].currency,
+                  time: time,
+                  bought_amount: matching[1].amount + matching[2].amount,
+                  sold_amount: -matching[0].amount
+                )
+            elsif types == [OP_PURCHASE, OP_SALE, OP_FEE] &&
+              matching[0].fiat? && matching[0].amount > 0 &&
+              matching[1].crypto? && matching[1].amount < 0 &&
+              matching[2].fiat? && matching[2].amount <= 0 &&
+              matching[0].currency == matching[2].currency
+                transactions << Transaction.new(
+                  exchange: 'BitBay',
+                  bought_currency: matching[0].currency,
+                  sold_currency: matching[1].currency,
+                  time: time,
+                  bought_amount: matching[0].amount + matching[2].amount,
+                  sold_amount: -matching[1].amount
+                )
+            else
+              raise "BitBay importer error: Couldn't match some history lines"
+            end
+
+            matching.clear
+          end
+        end
+
+        if !matching.empty?
+          if matching.any? { |l| l.type != OP_FEE }
+            raise "BitBay importer error: Couldn't match some history lines"
+          end
+        end
+
+        transactions.reverse
+      end
+    end
+  end
+end

data/lib/coinsync/importers/bitbay_api.rb

@@ -0,0 +1,224 @@
+require 'bigdecimal'
+require 'json'
+require 'net/http'
+require 'openssl'
+require 'time'
+require 'uri'
+
+require_relative 'base'
+require_relative '../balance'
+require_relative '../currencies'
+require_relative '../request'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    class BitBayAPI < Base
+      register_importer :bitbay_api
+
+      BASE_URL = "https://bitbay.net/API/Trading/tradingApi.php"
+
+      OP_PURCHASE = '+currency_transaction'
+      OP_SALE = '-pay_for_currency'
+      OP_FEE = '-fee'
+
+      MAX_TIME_DIFFERENCE = 5.0
+      TRANSACTION_TYPES = [OP_PURCHASE, OP_SALE, OP_FEE]
+
+      class HistoryEntry
+        attr_accessor :date, :amount, :type, :currency
+
+        def initialize(hash)
+          @date = Time.parse(hash['time'])  # TODO: these times are all fucked up
+          @amount = BigDecimal.new(hash['amount'])
+          @type = hash['operation_type']
+          @currency = parse_currency(hash['currency'])
+        end
+
+        def crypto?
+          @currency.crypto?
+        end
+
+        def fiat?
+          @currency.fiat?
+        end
+
+        def parse_currency(code)
+          case code.upcase
+          when 'BTC' then CryptoCurrency.new('BTC')
+          when 'ETH' then CryptoCurrency.new('ETH')
+          when 'LTC' then CryptoCurrency.new('LTC')
+          when 'LSK' then CryptoCurrency.new('LSK')
+          when 'BCC' then CryptoCurrency.new('BCH')
+          when 'BTG' then CryptoCurrency.new('BTG')
+          when 'GAME' then CryptoCurrency.new('GAME')
+          when 'DASH' then CryptoCurrency.new('DASH')
+          when 'PLN' then FiatCurrency.new('PLN')
+          when 'EUR' then FiatCurrency.new('EUR')
+          when 'USD' then FiatCurrency.new('USD')
+          else raise "Unknown currency: #{code}"
+          end
+        end
+      end
+
+      def initialize(config, params = {})
+        super
+
+        # required permissions:
+        # * for balance checks:
+        #   - "Crypto deposit" (shown as "Get and create cryptocurrency addresses" + "Funds deposit")
+        #   - "Updating a wallets list" (shown as "Pobieranie rachunków")
+        # * for transaction history:
+        #   - "History" (shown as "Fetch history of transactions")
+
+        @public_key = params['api_public_key']
+        @secret_key = params['api_private_key']
+      end
+
+      def can_import?(type)
+        @public_key && @secret_key && [:balances, :transactions].include?(type)
+      end
+
+      def import_transactions(filename)
+        info = fetch_info
+
+        currencies = info['balances'].keys
+        transactions = []
+
+        currencies.each do |currency|
+          sleep 1  # rate limiting
+
+          response = make_request('history', currency: currency, limit: 10000)  # TODO: does this limit really work?
+
+          case response
+          when Net::HTTPSuccess
+            json = JSON.parse(response.body)
+
+            if !json.is_a?(Array)
+              raise "BitBay API importer: Invalid response: #{response.body}"
+            end
+
+            transactions.concat(json)
+          when Net::HTTPBadRequest
+            raise "BitBay API importer: Bad request: #{response}"
+          else
+            raise "BitBay API importer: Bad response: #{response}"
+          end
+        end
+
+        transactions.each_with_index { |tx, i| tx['i'] = i }
+        transactions.sort_by! { |tx| [tx['time'], -tx['i']] }
+        transactions.each_with_index { |tx, i| tx.delete('i') }
+
+        File.write(filename, JSON.pretty_generate(transactions))
+      end
+
+      def import_balances
+        info = fetch_info
+
+        info['balances'].select { |k, v|
+          v['available'].to_f > 0 || v['locked'].to_f > 0
+        }.map { |k, v|
+          Balance.new(
+            CryptoCurrency.new(k),
+            available: BigDecimal.new(v['available']),
+            locked: BigDecimal.new(v['locked'])
+          )
+        }
+      end
+
+      def read_transaction_list(source)
+        json = JSON.parse(source.read)
+
+        matching = []
+        transactions = []
+
+        json.each do |hash|
+          entry = HistoryEntry.new(hash)
+
+          next unless TRANSACTION_TYPES.include?(entry.type)
+
+          if !matching.empty? && matching.any? { |e| (e.date - entry.date).abs > MAX_TIME_DIFFERENCE }
+            transactions << process_matched(matching)
+          end
+
+          matching << entry
+        end
+
+        if !matching.empty?
+          transactions << process_matched(matching)
+        end
+
+        transactions
+      end
+
+
+      private
+
+      def process_matched(matching)
+        if matching.length % 3 == 0
+          purchases = matching.select { |tx| tx.type == OP_PURCHASE }
+          sales = matching.select { |tx| tx.type == OP_SALE }
+          fees = matching.select { |tx| tx.type == OP_FEE }
+
+          if purchases.length == sales.length && purchases.length == fees.length
+            bought_currency = (purchases + fees).map(&:currency).uniq
+            sold_currency = sales.map(&:currency).uniq
+
+            if bought_currency.length == 1 && sold_currency.length == 1
+              matching.clear
+
+              return Transaction.new(
+                exchange: 'BitBay',
+                bought_currency: bought_currency.first,
+                sold_currency: sold_currency.first,
+                time: (purchases + sales + fees).map(&:date).last,
+                bought_amount: (purchases + fees).map(&:amount).reduce(&:+),
+                sold_amount: -sales.map(&:amount).reduce(&:+)
+              )
+            end
+          end
+        end
+
+        raise "BitBay API importer error: Couldn't match some history lines: #{matching}"
+      end
+
+      def make_request(method, params = {})
+        (@public_key && @secret_key) or raise "Public and secret API keys must be provided"
+
+        url = URI(BASE_URL)
+
+        params['method'] = method
+        params['moment'] = Time.now.to_i
+
+        param_string = URI.encode_www_form(params)
+        hmac = OpenSSL::HMAC.hexdigest('sha512', @secret_key, param_string)
+
+        Request.post(url) do |request|
+          request.body = param_string
+          request['API-Key'] = @public_key
+          request['API-Hash'] = hmac
+        end
+      end
+
+      def fetch_info
+        response = make_request('info')
+
+        case response
+        when Net::HTTPSuccess
+          json = JSON.parse(response.body)
+
+          if json['success'] != 1 || json['code'] || json['balances'].nil?
+            raise "BitBay API importer: Invalid response: #{response.body}"
+          end
+
+          json
+        when Net::HTTPBadRequest
+          raise "BitBay API importer: Bad request: #{response}"
+        else
+          raise "BitBay API importer: Bad response: #{response}"
+        end
+      end
+    end
+  end
+end

data/lib/coinsync/importers/bitcurex.rb

@@ -0,0 +1,71 @@
+require 'bigdecimal'
+require 'csv'
+require 'time'
+
+require_relative 'base'
+require_relative '../currencies'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    class Bitcurex < Base
+      register_importer :bitcurex
+
+      class HistoryEntry
+        attr_accessor :lp, :type, :date, :market, :amount, :price, :total, :fee, :fee_currency, :id
+
+        def initialize(line)
+          # TODO: force parsing in Polish timezone
+          @lp = line[0].to_i
+          @type = line[1]
+          @date = Time.parse(line[2])
+          @market = FiatCurrency.new(line[3])
+          @amount = BigDecimal.new(line[4])
+          @price = BigDecimal.new(line[5].split(' ').first)
+          @total = BigDecimal.new(line[6].split(' ').first)
+          @fee = BigDecimal.new(line[7].split(' ').first)
+          @fee_currency = line[7].split(' ').last
+          @id = line[8].to_i
+        end
+      end
+
+      def read_transaction_list(source)
+        csv = CSV.new(source, col_sep: ',')
+
+        transactions = []
+        bitcoin = CryptoCurrency.new('BTC')
+
+        csv.each do |line|
+          next if line.empty?
+          next if line[0] == 'LP'
+
+          entry = HistoryEntry.new(line)
+
+          if entry.type == 'Kup'
+            transactions << Transaction.new(
+              exchange: 'Bitcurex',
+              bought_currency: bitcoin,
+              sold_currency: entry.market,
+              time: entry.date,
+              bought_amount: entry.amount,
+              sold_amount: entry.total
+            )
+          elsif entry.type == 'Sprzedaj'
+            transactions << Transaction.new(
+              exchange: 'Bitcurex',
+              bought_currency: entry.market,
+              sold_currency: bitcoin,
+              time: entry.date,
+              bought_amount: entry.total,
+              sold_amount: entry.amount
+            )
+          else
+            raise "Bitcurex importer error: unexpected entry type '#{entry.type}'"
+          end
+        end
+
+        transactions.reverse
+      end
+    end
+  end
+end

data/lib/coinsync/importers/bittrex_api.rb

@@ -0,0 +1,81 @@
+require 'bigdecimal'
+require 'json'
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+require_relative 'base'
+require_relative '../balance'
+require_relative '../currencies'
+require_relative '../request'
+
+module CoinSync
+  module Importers
+    class BittrexAPI < Base
+      register_importer :bittrex_api
+
+      BASE_URL = "https://bittrex.com/api/v1.1"
+
+      def initialize(config, params = {})
+        super
+
+        # only "Read Info" permission is required for the key
+        @api_key = params['api_key']
+        @api_secret = params['api_secret']
+      end
+
+      def can_import?(type)
+        @api_key && @api_secret && [:balances].include?(type)
+      end
+
+      def can_build?
+        false
+      end
+
+      def import_balances
+        response = make_request('/account/getbalances')
+
+        case response
+        when Net::HTTPSuccess
+          json = JSON.parse(response.body)
+
+          if json['success'] != true || !json['result']
+            raise "Bittrex importer: Invalid response: #{response.body}"
+          end
+
+          return json['result'].select { |b|
+            b['Balance'] > 0
+          }.map { |b|
+            Balance.new(
+              CryptoCurrency.new(b['Currency']),
+              available: BigDecimal.new(b['Available'], 0),
+              locked: BigDecimal.new(b['Balance'], 0) - BigDecimal.new(b['Available'], 0)
+            )
+          }
+        when Net::HTTPBadRequest
+          raise "Bittrex importer: Bad request: #{response}"
+        else
+          raise "Bittrex importer: Bad response: #{response}"
+        end
+      end
+
+      private
+
+      def make_request(path, params = {})
+        (@api_key && @api_secret) or raise "Public and secret API keys must be provided"
+
+        params['apikey'] = @api_key
+        params['nonce'] = (Time.now.to_f * 1000).to_i
+
+        url = URI(BASE_URL + path)
+        url.query = URI.encode_www_form(params)
+
+        hmac = OpenSSL::HMAC.hexdigest('sha512', @api_secret, url.to_s)
+
+        Request.get(url) do |request|
+          request['apisign'] = hmac
+        end
+      end
+    end
+  end
+end