coinsync 0.1.0

data/lib/coinsync/currency_converters/cache.rb

@@ -0,0 +1,34 @@
+require 'fileutils'
+require 'json'
+
+module CoinSync
+  module CurrencyConverters
+    class Cache
+      def initialize(name)
+        @name = name
+        @filename = "caches/#{name}.json"
+
+        if File.exist?(@filename)
+          @rates = JSON.parse(File.read(@filename))
+        else
+          @rates = {}
+        end
+      end
+
+      def [](from, to, date)
+        @rates["#{from.code}:#{to.code}"] ||= {}
+        @rates["#{from.code}:#{to.code}"][date.to_s]
+      end
+
+      def []=(from, to, date, amount)
+        @rates["#{from.code}:#{to.code}"] ||= {}
+        @rates["#{from.code}:#{to.code}"][date.to_s] = amount
+      end
+
+      def save
+        FileUtils.mkdir_p(File.dirname(@filename))
+        File.write(@filename, JSON.generate(@rates))
+      end
+    end
+  end
+end

data/lib/coinsync/currency_converters/fixer.rb

@@ -0,0 +1,36 @@
+require 'json'
+require 'net/http'
+
+require_relative 'base'
+require_relative '../request'
+
+module CoinSync
+  module CurrencyConverters
+    class Fixer < Base
+      register_converter :fixer
+
+      BASE_URL = "https://api.fixer.io"
+
+      class Exception < StandardError; end
+      class NoDataException < Exception; end
+      class BadRequestException < Exception; end
+
+      def fetch_conversion_rate(from:, to:, date:)
+        response = Request.get("#{BASE_URL}/#{date}?base=#{from.code}")
+
+        case response
+        when Net::HTTPSuccess
+          json = JSON.parse(response.body)
+          rate = json['rates'][to.code.upcase]
+          raise NoDataException.new("No exchange rate found for #{to.code.upcase}") if rate.nil?
+
+          return rate
+        when Net::HTTPBadRequest
+          raise BadRequestException.new(response)
+        else
+          raise Exception.new(response)
+        end
+      end
+    end
+  end
+end

data/lib/coinsync/currency_converters/nbp.rb

@@ -0,0 +1,38 @@
+require 'json'
+require 'net/http'
+
+require_relative 'base'
+require_relative '../request'
+
+module CoinSync
+  module CurrencyConverters
+    class NBP < Base
+      register_converter :nbp
+
+      BASE_URL = "https://api.nbp.pl/api"
+
+      class Exception < StandardError; end
+      class NoDataException < Exception; end
+      class BadRequestException < Exception; end
+
+      def fetch_conversion_rate(from:, to:, date:)
+        raise "Only conversions to PLN are supported" if to.code != 'PLN'
+
+        response = Request.get("#{BASE_URL}/exchangerates/rates/a/#{from.code}/#{date - 8}/#{date - 1}/?format=json")
+
+        case response
+        when Net::HTTPSuccess
+          json = JSON.parse(response.body)
+          rate = json['rates'] && json['rates'].last && json['rates'].last['mid']
+          raise NoDataException.new("No exchange rate found for #{from.code.upcase}") if rate.nil?
+
+          return rate
+        when Net::HTTPBadRequest
+          raise BadRequestException.new(response)
+        else
+          raise Exception.new(response)
+        end
+      end
+    end
+  end
+end

data/lib/coinsync/formatter.rb

@@ -0,0 +1,44 @@
+require 'bigdecimal'
+
+module CoinSync
+  class Formatter
+    def initialize(config)
+      @config = config
+      @decimal_separator = config.custom_decimal_separator
+    end
+
+    def format_decimal(value, precision: nil)
+      v = precision ? value.round(precision) : value
+      s = v.to_s('F').gsub(/\.0$/, '')
+      s = s.gsub(/\./, @decimal_separator) if @decimal_separator
+      s
+    end
+
+    def format_float(value, precision:)
+      s = sprintf("%.#{precision}f", value)
+      s = s.gsub(/\./, @decimal_separator) if @decimal_separator
+      s
+    end
+
+    def format_fiat(amount)
+      format_float(amount, precision: 2)
+    end
+
+    def format_fiat_price(amount)
+      format_float(amount, precision: (amount < 10 ? 4 : 2))
+    end
+
+    def format_crypto(amount)
+      format_decimal(amount, precision: 8)
+    end
+
+    def format_time(time)
+      time.strftime(@config.time_format || '%Y-%m-%d %H:%M:%S')
+    end
+
+    def parse_decimal(string)
+      string = string.gsub(@decimal_separator, '.') if @decimal_separator
+      BigDecimal.new(string)
+    end
+  end
+end

data/lib/coinsync/import_task.rb

@@ -0,0 +1,37 @@
+require 'fileutils'
+
+require_relative 'importers/all'
+
+module CoinSync
+  class ImportTask
+    def initialize(config)
+      @config = config
+    end
+
+    def run(selected = nil, except = nil)
+      @config.filtered_sources(selected, except).each do |key, source|
+        importer = source.importer
+        filename = source.filename
+
+        if importer.respond_to?(:can_import?)
+          if importer.can_import?(:transactions)
+            if filename.nil?
+              raise "No filename specified for '#{key}', please add a 'file' parameter."
+            end
+
+            print "[#{key}] Importing transactions... "
+
+            FileUtils.mkdir_p(File.dirname(filename))
+            importer.import_transactions(filename)
+
+            puts "√"
+          else
+            puts "[#{key}] Skipping import"
+          end
+        end
+      end
+
+      puts "Done."
+    end
+  end
+end

data/lib/coinsync/importers/all.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '*.rb')].each { |f| require(f) }

data/lib/coinsync/importers/ark_voting.rb

@@ -0,0 +1,121 @@
+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 ArkVoting < Base
+      register_importer :ark_voting
+
+      BASE_URL = "https://explorer.dafty.net/api"
+      EPOCH_TIME = Time.parse('2017-03-21 13:00 UTC')
+      ARK = CryptoCurrency.new('ARK')
+
+      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)
+        offset = 0
+        limit = 50
+        transactions = []
+
+        loop do
+          response = make_request('/getTransactionsByAddress', address: @address, limit: limit, offset: offset)
+
+          case response
+          when Net::HTTPSuccess
+            json = JSON.parse(response.body)
+
+            if json['success'] != true || !json['transactions']
+              raise "Ark importer: Invalid response: #{response.body}"
+            end
+
+            break if json['transactions'].empty?
+
+            rewards = json['transactions'].select { |tx| tx['senderDelegate'] }
+            transactions.concat(rewards)
+
+            offset += limit
+          when Net::HTTPBadRequest
+            raise "Ark importer: Bad request: #{response}"
+          else
+            raise "Ark importer: Bad response: #{response}"
+          end
+        end
+
+        File.write(filename, JSON.pretty_generate(transactions) + "\n")
+      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 "Ark importer: Invalid response: #{response.body}"
+          end
+
+          [Balance.new(ARK, available: BigDecimal.new(json['balance']) / 100_000_000)]
+        when Net::HTTPBadRequest
+          raise "Ark importer: Bad request: #{response}"
+        else
+          raise "Ark 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: 'Ark voting',
+            time: entry.timestamp,
+            bought_amount: entry.amount,
+            bought_currency: ARK,
+            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

data/lib/coinsync/importers/base.rb

@@ -0,0 +1,35 @@
+module CoinSync
+  module Importers
+    def self.registered
+      @importers ||= {}
+    end
+
+    class Base
+      def self.register_importer(key)
+        if Importers.registered[key]
+          raise "Importer has already been registered at '#{key}'"
+        else
+          Importers.registered[key] = self
+        end
+      end
+
+      def self.register_commands(*commands)
+        @commands ||= []
+        @commands += commands.map(&:to_sym)
+      end
+
+      def self.registered_commands
+        @commands || []
+      end
+
+      def initialize(config, params = {})
+        @config = config
+        @params = params
+      end
+
+      def can_build?
+        true
+      end
+    end
+  end
+end

data/lib/coinsync/importers/binance_api.rb

@@ -0,0 +1,210 @@
+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 BinanceAPI < Base
+      register_importer :binance_api
+      register_commands :find_all_pairs
+
+      BASE_URL = "https://api.binance.com/api"
+      BASE_COINS = ['BTC', 'ETH', 'BNB', 'USDT']
+
+      class HistoryEntry
+        attr_accessor :quantity, :commission, :commission_asset, :price, :time, :buyer, :asset, :currency
+
+        def initialize(hash)
+          @quantity = BigDecimal.new(hash['qty'])
+          @commission = BigDecimal.new(hash['commission'])
+          @commission_asset = CryptoCurrency.new(hash['commissionAsset'])
+          @price = BigDecimal.new(hash['price'])
+          @time = Time.at(hash['time'] / 1000)
+          @buyer = hash['isBuyer']
+
+          @asset, @currency = parse_coins(hash['symbol'])
+
+          if (@buyer && @commission_asset != @asset) || (!@buyer && @commission_asset != @currency)
+            raise "Binance API: Unexpected fee: #{hash}"
+          end
+        end
+
+        def parse_coins(symbol)
+          BASE_COINS.each do |coin|
+            if symbol.end_with?(coin)
+              asset = symbol.gsub(/#{coin}$/, '')
+              return [CryptoCurrency.new(asset), CryptoCurrency.new(coin)]
+            end
+          end
+
+          raise "Binance API: Unexpected trade symbol: #{symbol}"
+        end
+      end
+
+      def initialize(config, params = {})
+        super
+
+        # only "Read Info" permission is required for the key
+        @api_key = params['api_key']
+        @secret_key = params['secret_key']
+        @traded_pairs = params['traded_pairs']
+      end
+
+      def can_import?(type)
+        @api_key && @secret_key && [:balances, :transactions].include?(type)
+      end
+
+      def import_transactions(filename)
+        @traded_pairs or raise "Please add a traded_pairs parameter"
+
+        transactions = []
+
+        @traded_pairs.uniq.each do |pair|
+          response = make_request('/v3/myTrades', limit: 500, symbol: pair) # TODO: paging
+
+          case response
+          when Net::HTTPSuccess
+            json = JSON.parse(response.body)
+
+            if json.is_a?(Hash)
+              raise "Binance importer: Invalid response: #{response.body}"
+            end
+
+            json.each { |tx| tx['symbol'] = pair }
+
+            transactions.concat(json)
+          when Net::HTTPBadRequest
+            raise "Binance importer: Bad request: #{response} (#{response.body})"
+          else
+            raise "Binance importer: Bad response: #{response}"
+          end
+        end
+
+        File.write(filename, JSON.pretty_generate(transactions.sort_by { |tx| [tx['time'], tx['id']] }))
+      end
+
+      def import_balances
+        response = make_request('/v3/account')
+
+        case response
+        when Net::HTTPSuccess
+          json = JSON.parse(response.body)
+
+          if json['code'] || !json['balances']
+            raise "Binance importer: Invalid response: #{response.body}"
+          end
+
+          return json['balances'].select { |b|
+            b['free'].to_f > 0 || b['locked'].to_f > 0
+          }.map { |b|
+            Balance.new(
+              CryptoCurrency.new(b['asset']),
+              available: BigDecimal.new(b['free']),
+              locked: BigDecimal.new(b['locked'])
+            )
+          }
+        when Net::HTTPBadRequest
+          raise "Binance importer: Bad request: #{response}"
+        else
+          raise "Binance importer: Bad response: #{response}"
+        end
+      end
+
+      def find_all_pairs
+        info_response = make_request('/v1/exchangeInfo', {}, false)
+
+        if !info_response.is_a?(Net::HTTPSuccess)
+          raise "Binance importer: Bad response: #{info_response.body}"
+        end
+
+        info_json = JSON.parse(info_response.body)
+
+        found = []
+
+        info_json['symbols'].each do |data|
+          symbol = data['symbol']
+          trades_response = make_request('/v3/myTrades', limit: 1, symbol: symbol)
+
+          case trades_response
+          when Net::HTTPSuccess
+            trades_json = JSON.parse(trades_response.body)
+
+            if trades_json.length > 0
+              print '*'
+              found << symbol
+            else
+              print '.'
+            end
+          else
+            raise "Binance importer: Bad response: #{trades_response.body}"
+          end
+        end
+
+        puts
+        puts "Trading pairs found:"
+        puts found.sort
+      end
+
+      def read_transaction_list(source)
+        json = JSON.parse(source.read)
+        transactions = []
+
+        json.each do |hash|
+          entry = HistoryEntry.new(hash)
+
+          if entry.buyer
+            transactions << Transaction.new(
+              exchange: 'Binance',
+              time: entry.time,
+              bought_amount: entry.quantity - entry.commission,
+              bought_currency: entry.asset,
+              sold_amount: entry.price * entry.quantity,
+              sold_currency: entry.currency
+            )
+          else
+            transactions << Transaction.new(
+              exchange: 'Binance',
+              time: entry.time,
+              bought_amount: entry.price * entry.quantity - entry.commission,
+              bought_currency: entry.currency,
+              sold_amount: entry.quantity,
+              sold_currency: entry.asset
+            )
+          end
+        end
+
+        transactions
+      end
+
+      private
+
+      def make_request(path, params = {}, signed = true)
+        if signed
+          (@api_key && @secret_key) or raise "Public and secret API keys must be provided"
+
+          params['timestamp'] = (Time.now.to_f * 1000).to_i
+        end
+
+        url = URI(BASE_URL + path)
+        url.query = URI.encode_www_form(params)
+
+        if signed
+          hmac = OpenSSL::HMAC.hexdigest('sha256', @secret_key, url.query)
+          url.query += "&signature=#{hmac}"
+        end
+
+        Request.get(url) do |request|
+          request['X-MBX-APIKEY'] = @api_key
+        end
+      end
+    end
+  end
+end