coinsync 0.1.0

data/lib/coinsync/importers/kraken_common.rb

@@ -0,0 +1,137 @@
+require 'bigdecimal'
+require 'time'
+
+require_relative '../currencies'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    module Kraken
+      class LedgerEntry
+        attr_accessor :txid, :refid, :time, :type, :aclass, :asset, :amount, :fee, :balance
+
+        def self.from_csv(line)
+          entry = self.new
+          entry.txid = line[0]
+          entry.refid = line[1]
+          entry.time = Time.parse(line[2] + " +0000")
+          entry.type = line[3]
+          entry.aclass = line[4]
+          entry.asset = parse_currency(line[5])
+          entry.amount = BigDecimal.new(line[6])
+          entry.fee = BigDecimal.new(line[7])
+          entry.balance = BigDecimal.new(line[8])
+          entry
+        end
+
+        def self.from_json(hash)
+          entry = self.new
+          entry.refid = hash['refid']
+          entry.time = Time.at(hash['time'])
+          entry.type = hash['type']
+          entry.aclass = hash['aclass']
+          entry.asset = parse_currency(hash['asset'])
+          entry.amount = BigDecimal.new(hash['amount'])
+          entry.fee = BigDecimal.new(hash['fee'])
+          entry.balance = BigDecimal.new(hash['balance'])
+          entry
+        end
+
+        def self.parse_currency(code)
+          case code
+          when 'BCH' then CryptoCurrency.new('BCH')
+          when 'DASH' then CryptoCurrency.new('DASH')
+          when 'EOS' then CryptoCurrency.new('EOS')
+          when 'GNO' then CryptoCurrency.new('GNO')
+          when 'KFEE' then CryptoCurrency.new('KFEE')
+          when 'USDT' then CryptoCurrency.new('USDT')
+
+          when 'XDAO' then CryptoCurrency.new('DAO')
+          when 'XETC' then CryptoCurrency.new('ETC')
+          when 'XETH' then CryptoCurrency.new('ETH')
+          when 'XICN' then CryptoCurrency.new('ICN')
+          when 'XLTC' then CryptoCurrency.new('LTC')
+          when 'XMLN' then CryptoCurrency.new('MLN')
+          when 'XNMC' then CryptoCurrency.new('NMC')
+          when 'XREP' then CryptoCurrency.new('REP')
+          when 'XXBT' then CryptoCurrency.new('BTC')
+          when 'XXDG' then CryptoCurrency.new('DOGE')
+          when 'XXLM' then CryptoCurrency.new('XLM')
+          when 'XXMR' then CryptoCurrency.new('XMR')
+          when 'XXRP' then CryptoCurrency.new('XRP')
+          when 'XXVN' then CryptoCurrency.new('VEN')
+          when 'XZEC' then CryptoCurrency.new('ZEC')
+
+          when 'ZCAD' then FiatCurrency.new('CAD')
+          when 'ZEUR' then FiatCurrency.new('EUR')
+          when 'ZGBP' then FiatCurrency.new('GBP')
+          when 'ZJPY' then FiatCurrency.new('JPY')
+          when 'ZKRW' then FiatCurrency.new('KRW')
+          when 'ZUSD' then FiatCurrency.new('USD')
+
+          else raise "Unknown currency: #{code}"
+          end
+        end
+
+        def crypto?
+          @asset.crypto?
+        end
+      end
+
+      module Common
+        def build_transaction_list(entries)
+          set = []
+          transactions = []
+
+          entries.each do |entry|
+            if entry.type == 'transfer'
+              transactions << Transaction.new(
+                exchange: 'Kraken',
+                time: entry.time,
+                bought_amount: entry.amount,
+                bought_currency: entry.asset,
+                sold_amount: BigDecimal(0),
+                sold_currency: FiatCurrency.new(nil)
+              )
+              next
+            end
+
+            next if entry.type != 'trade'
+
+            set << entry
+            next unless set.length == 2
+
+            if set[0].refid != set[1].refid
+              raise "Kraken importer error: Couldn't match a pair of ledger lines - ids don't match: #{set}"
+            end
+
+            if set.none? { |e| e.crypto? }
+              raise "Kraken importer error: Couldn't match a pair of ledger lines - " +
+                "no cryptocurrencies were exchanged: #{set}"
+            end
+
+            bought = set.detect { |e| e.amount > 0 }
+            sold = set.detect { |e| e.amount < 0 }
+
+            if bought.nil? || sold.nil?
+              raise "Kraken importer error: Couldn't match a pair of ledger lines - invalid transaction amounts: #{set}"
+            end
+
+            transactions << Transaction.new(
+              exchange: 'Kraken',
+              time: [bought.time, sold.time].max,
+              bought_amount: bought.amount - bought.fee,
+              bought_currency: bought.asset,
+              sold_amount: -(sold.amount - sold.fee),
+              sold_currency: sold.asset
+            )
+
+            set.clear
+          end
+
+          transactions
+        end
+      end
+    end
+  end
+end

data/lib/coinsync/importers/kraken_csv.rb

@@ -0,0 +1,28 @@
+require 'csv'
+
+require_relative 'base'
+require_relative 'kraken_common'
+
+module CoinSync
+  module Importers
+    class KrakenCSV < Base
+      register_importer :kraken_csv
+
+      include Kraken::Common
+
+      def read_transaction_list(source)
+        csv = CSV.new(source, col_sep: ',')
+
+        entries = []
+
+        csv.each do |line|
+          next if line[0] == 'txid'
+
+          entries << Kraken::LedgerEntry.from_csv(line)
+        end
+
+        build_transaction_list(entries)
+      end
+    end
+  end
+end

data/lib/coinsync/importers/kucoin_api.rb

@@ -0,0 +1,172 @@
+require 'base64'
+require 'bigdecimal'
+require 'json'
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+require_relative 'base'
+require_relative '../balance'
+require_relative '../currencies'
+require_relative '../request'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    class KucoinAPI < Base
+      register_importer :kucoin_api
+
+      BASE_URL = "https://api.kucoin.com"
+
+      class HistoryEntry
+        attr_accessor :created_at, :amount, :direction, :coin_type, :coin_type_pair, :deal_value, :fee
+
+        def initialize(hash)
+          @created_at = Time.at(hash['createdAt'] / 1000)
+          @amount = BigDecimal.new(hash['amount'], 0)
+          @direction = hash['direction']
+          @coin_type = CryptoCurrency.new(hash['coinType'])
+          @coin_type_pair = CryptoCurrency.new(hash['coinTypePair'])
+          @deal_value = BigDecimal.new(hash['dealValue'], 0)
+          @fee = BigDecimal.new(hash['fee'], 0)
+        end
+      end
+
+      def initialize(config, params = {})
+        super
+        @api_key = params['api_key']
+        @api_secret = params['api_secret']
+      end
+
+      def can_import?(type)
+        @api_key && @api_secret && [:balances, :transactions].include?(type)
+      end
+
+      def import_transactions(filename)
+        response = make_request('/order/dealt', limit: 100) # TODO: what if there's more than 100?
+
+        case response
+        when Net::HTTPSuccess
+          json = JSON.parse(response.body)
+
+          if json['success'] != true || json['code'] != 'OK'
+            raise "Kucoin importer: Invalid response: #{response.body}"
+          end
+
+          data = json['data']
+          list = data && data['datas']
+
+          if !list
+            raise "Kucoin importer: No data returned: #{response.body}"
+          end
+
+          File.write(filename, JSON.pretty_generate(list) + "\n")
+        when Net::HTTPBadRequest
+          raise "Kucoin importer: Bad request: #{response}"
+        else
+          raise "Kucoin importer: Bad response: #{response}"
+        end
+      end
+
+      def import_balances
+        page = 1
+        full_list = []
+
+        loop do
+          response = make_request('/account/balances', limit: 20, page: page)
+
+          case response
+          when Net::HTTPSuccess
+            json = JSON.parse(response.body)
+
+            if json['success'] != true || json['code'] != 'OK'
+              raise "Kucoin importer: Invalid response: #{response.body}"
+            end
+
+            data = json['data']
+            list = data && data['datas']
+
+            if !list
+              raise "Kucoin importer: No data returned: #{response.body}"
+            end
+
+            full_list.concat(list)
+
+            page += 1
+            break if page > data['pageNos']
+          when Net::HTTPBadRequest
+            raise "Kucoin importer: Bad request: #{response}"
+          else
+            raise "Kucoin importer: Bad response: #{response}"
+          end
+        end
+
+        full_list.delete_if { |b| b['balance'] == 0.0 && b['freezeBalance'] == 0.0 }
+
+        full_list.map do |b|
+          Balance.new(
+            CryptoCurrency.new(b['coinType']),
+            available: BigDecimal.new(b['balanceStr']),
+            locked: BigDecimal.new(b['freezeBalanceStr'])
+          )
+        end
+      end
+
+      def read_transaction_list(source)
+        json = JSON.parse(source.read)
+        transactions = []
+
+        json.each do |hash|
+          entry = HistoryEntry.new(hash)
+
+          if entry.direction == 'BUY'
+            transactions << Transaction.new(
+              exchange: 'Kucoin',
+              time: entry.created_at,
+              bought_amount: entry.amount - entry.fee,
+              bought_currency: entry.coin_type,
+              sold_amount: entry.deal_value,
+              sold_currency: entry.coin_type_pair
+            )
+          else
+            # TODO sell
+            raise "Kucoin importer error: unexpected entry direction '#{entry.direction}'"
+          end
+        end
+
+        transactions.reverse
+      end
+
+      private
+
+      def make_request(path, params = {})
+        (@api_key && @api_secret) or raise "Public and secret API keys must be provided"
+
+        endpoint = '/v1' + path
+        nonce = (Time.now.to_f * 1000).to_i
+        url = URI(BASE_URL + endpoint)
+
+        url.query = build_query_string(params)
+
+        string_to_hash = Base64.strict_encode64("#{endpoint}/#{nonce}/#{url.query}")
+        hmac = OpenSSL::HMAC.hexdigest('sha256', @api_secret, string_to_hash)
+
+        Request.get(url) do |request|
+          request['KC-API-KEY'] = @api_key
+          request['KC-API-NONCE'] = nonce
+          request['KC-API-SIGNATURE'] = hmac
+        end
+      end
+
+      def build_query_string(params)
+        params.map { |k, v|
+          [k.to_s, v.to_s]
+        }.sort_by { |k, v|
+          [k[0] < 'a' ? 1 : 0, k]
+        }.map { |k, v|
+          "#{k}=#{v}"
+        }.join('&')
+      end
+    end
+  end
+end

data/lib/coinsync/importers/lisk_voting.rb

@@ -0,0 +1,110 @@
+require 'bigdecimal'
+require 'json'
+require 'net/http'
+require 'time'
+require 'uri'
+
+require_relative 'base'
+require_relative '../balance'
+require_relative '../currencies'
+require_relative '../request'
+require_relative '../transaction'
+
+module CoinSync
+  module Importers
+    class LiskVoting < Base
+      register_importer :lisk_voting
+
+      BASE_URL = "https://explorer.lisk.io/api"
+      EPOCH_TIME = Time.parse('2016-05-24 17:00 UTC')
+      LISK = CryptoCurrency.new('LSK')
+
+      class HistoryEntry
+        attr_accessor :timestamp, :amount
+
+        def initialize(hash)
+          @timestamp = EPOCH_TIME + hash['timestamp']
+          @amount = BigDecimal.new(hash['amount']) / 100_000_000
+        end
+      end
+
+      def initialize(config, params = {})
+        super
+        @address = params['address']
+      end
+
+      def can_import?(type)
+        @address && [:balances, :transactions].include?(type)
+      end
+
+      def import_transactions(filename)
+        response = make_request('/getTransactionsByAddress', address: @address, limit: 1000)
+
+        case response
+        when Net::HTTPSuccess
+          json = JSON.parse(response.body)
+
+          if json['success'] != true || !json['transactions']
+            raise "Lisk importer: Invalid response: #{response.body}"
+          end
+
+          rewards = json['transactions'].select { |tx| tx['senderDelegate'] }
+
+          File.write(filename, JSON.pretty_generate(rewards) + "\n")
+        when Net::HTTPBadRequest
+          raise "Lisk importer: Bad request: #{response}"
+        else
+          raise "Lisk importer: Bad response: #{response}"
+        end
+      end
+
+      def import_balances
+        response = make_request('/getAccount', address: @address)
+
+        case response
+        when Net::HTTPSuccess
+          json = JSON.parse(response.body)
+
+          if json['success'] != true || !json['balance']
+            raise "Lisk importer: Invalid response: #{response.body}"
+          end
+
+          [Balance.new(LISK, available: BigDecimal.new(json['balance']) / 100_000_000)]
+        when Net::HTTPBadRequest
+          raise "Lisk importer: Bad request: #{response}"
+        else
+          raise "Lisk importer: Bad response: #{response}"
+        end
+      end
+
+      def read_transaction_list(source)
+        json = JSON.parse(source.read)
+        transactions = []
+
+        json.each do |hash|
+          entry = HistoryEntry.new(hash)
+
+          transactions << Transaction.new(
+            exchange: 'Lisk voting',
+            time: entry.timestamp,
+            bought_amount: entry.amount,
+            bought_currency: LISK,
+            sold_amount: BigDecimal.new(0),
+            sold_currency: FiatCurrency.new(nil)
+          )
+        end
+
+        transactions.reverse
+      end
+
+      private
+
+      def make_request(path, params = {})
+        url = URI(BASE_URL + path)
+        url.query = URI.encode_www_form(params)
+
+        Request.get(url)
+      end
+    end
+  end
+end