crypto-service 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed5769c8ed79cd6a12e10aabd5035776ea6ef5cdcc2f32812e65e86a1464ab1d
-  data.tar.gz: 9e547251610c7f066564c4af4d7ff87cb2b5c1a0e0a3ec90ee9bdad3aee464ea
+  metadata.gz: be4d060ae79ae7ee1ae22306b5fc62d91b89acda8265b287fbc7d2b0858acfa4
+  data.tar.gz: 4e1948a84ee2ab439c41b9ab15f30bb357ba3ac0214bc0d6a0a4ab3b2d7b4439
 SHA512:
-  metadata.gz: 1a06fc3a72160c2ce570e91725fcf8b3d749088a13b322b55e630a70a6ba40c2cc075f003f9dbe6e1ca29445782227b89f0a3b7902a55abdc296c915a9eae0f7
-  data.tar.gz: c3c7dc4526dc42383a968db113aad034aaf7da46e310e0436e6c4ed00a893ef7e897ac87a49b6999f5ffa130295f6ac8abe6986821f9d87e8f742421f93f9beb
+  metadata.gz: aea9190bcaeeb1fac078afbc71e0597496fc6b05b4509a458437b6a7f09b43d0e5af80c0b97d4660e57e487d3d7df1a61d9ac35270258a44ea542161ba9a4f5a
+  data.tar.gz: 8b557573f59ba140d4f30842ec2685ea76b970beeaeb99a8c13286232607647a9af709a3b6acd7b4e7251f56cfc068319b52ba2db6b33a2af03950cbd4b273b1

data/lib/crypto/base.rb

@@ -3,39 +3,25 @@
 require 'uri'
 require 'net/http'
 require 'json'
+
 require 'coinex'
+require 'coinpaprika'
+require 'gecko'
+require 'string/similarity'
 require 'request'
 
 module Crypto
   class Base
     class << self
-      attr_accessor :app_info, :path_prefix, :development
-
-      def calculate_win_or_lost(avg_price:, exchange:, settings:)
-        percentages = percentage(exchange: exchange, settings: settings)
-        profit = percentages.first
-        lost = percentages[1]
-
-        win_price = avg_price.to_f + ((avg_price.to_f * profit.to_f) / 100)
-        lost_price = avg_price.to_f - ((avg_price.to_f * lost.to_f) / 100)
-
-        [win_price, lost_price]
-      end
+      attr_accessor :app_info, :path_prefix, :development, :testing
 
-      def binance?(exchange)
-        exchange == 'Binance'
+      def test(fixture)
+        load_fixture(fixture)
       end
 
-      def percentage(exchange:, settings:)
-        if binance?(exchange)
-          profit = settings[:perc_profit_exchange]
-          loss = settings[:perc_lost_exchange]
-        else
-          profit = settings[:perc_profit_all]
-          loss = settings[:perc_lost_all]
-        end
-
-        [profit, loss]
+      def load_fixture(fixture)
+        fixture_path = File.expand_path(File.join(__dir__, '../../spec', 'fixtures/test', fixture))
+        JSON.parse(File.read(fixture_path))
       end
 
       def correct(result)
@@ -46,27 +32,18 @@ module Crypto
         { 'status' => :failed, 'code' => result['code'], 'message' => result['message'] }
       end
 
-      def coinex_keys(settings)
-        Crypto::Exchanges::Cx.access_id(settings[:access_id])
-        Crypto::Exchanges::Cx.secret_key(settings[:secret_key])
-      end
-
-      def response_correct?(result)
-        (result['code']).zero?
+      def binance?(exchanges)
+        exchanges.include?('Binance')
       end
 
-      def calculate_signature(params)
-        data_signature = Coinex::Signature.calculate(params: params)
-
-        params[:tonce] = Crypto.development ? '1672669323219' : data_signature[:tonce]
-        params[:signature] = data_signature[:signature]
-
-        params
+      def coinex?(exchanges)
+        exchanges.include?('CoinEx')
       end
     end
 
     self.app_info = ::ENV['APP_INFO'] || "#{::Crypto::NAME} V#{::Crypto.version}"
     self.path_prefix = 'https://www.binance.com/bapi/composite/v1/public/promo/cmc/cryptocurrency'
-    self.development = false
+    self.development = false # For rspec & test
+    self.testing = false # For real call, but return development payload
   end
 end

data/lib/crypto/resources/buy.rb

@@ -7,48 +7,29 @@
 # Exchange: exchange where crypto is listed or buy, (Binance → 20%, Other exchange → 10% )
 
 module Crypto
-  class Buy < Base
+  class Buy < Operation
     class << self
       # rubocop: disable Metrics/MethodLength, Lint/MissingCopEnableDirective
-      def order(payload:, settings:, exchange:, count:)
-        coinex_keys(settings)
-        result = Coinex::Order.market(params: params(
-          symbol: payload['symbol'],
-          count: count
-        ))
-
-        Crypto::Exchanges::Cx.clean_keys
-
-        if response_correct?(result)
-          prices = calculate_win_or_lost(avg_price: result['data']['avg_price'], exchange: exchange, settings: settings)
-          divert(payload: payload, result: result, prices: prices, settings: settings)
-        else
-          error(result)
-        end
-      end
-
-      def balance(count)
-        params = Coinex::Signature.calculate
-        params[:tonce] = '1672669323219' if Crypto.development
+      def order(data)
+        return test('crypto_buy.json') if Crypto.testing
 
-        balance = Coinex::Balance.info(params: params)
-        balance['data']['USDT']['available'].to_i / count.to_i
+        operations(data: data, index: nil)
       end
 
-      def params(symbol:, count:)
-        params = { market: "#{symbol}USDT", type: 'buy', amount: balance(count) }
-        calculate_signature(params)
-      end
+      private
 
-      def divert(payload:, result:, prices:, settings:)
+      def divert(data)
         operations = []
-        operations << result
+        data[:result]['operation'] = 'B'
+        operations << data[:result]
 
-        loss = Crypto::Loss.limit(payload: payload, result: result, prices: prices, settings: settings)
+        loss = Crypto::Loss.limit(data: data, index: 0)
+        loss['operation'] = 'SL'
         operations << loss
-        return operations if payload['mode'] == :top
+        return operations if data.dig(:payload, :mode) == :top
 
-        profit = Crypto::Profit.limit(payload: payload, result: result, prices: prices, settings: settings)
+        profit = Crypto::Profit.limit(data: data, index: 1)
+        profit['operation'] = 'TP'
         operations << profit
 
         operations

data/lib/crypto/resources/exchange.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Class that return exchanges of a crypto
+
+module Crypto
+  class Exchange < Base
+    PERCENTAGE = 70
+
+    class << self
+      def info(symbol:, name:)
+        exchanges = gecko(symbol: symbol, name: name)
+        return exchanges unless exchanges.nil?
+
+        coinpaprika(symbol: symbol, name: name)
+      end
+
+      private
+
+      def exchange(symbol:, service:, name:)
+        payload = Object.const_get(service).info(symbol)
+        return nil if payload.empty?
+
+        if hash?(payload) || (array?(payload) && payload.size <= 1)
+          return simple_exchange(service: service,
+                                 payload: payload)
+        end
+
+        # If array & size > 1, calculate max similar string
+        max_similarity(name: name, service: service, payload: payload)
+      end
+
+      def gecko(symbol:, name:)
+        exchange(symbol: symbol, service: 'Gecko::Coin', name: name)
+      end
+
+      def coinpaprika(symbol:, name:)
+        exchange(symbol: symbol, service: 'Coinpaprika::Coin', name: name)
+      end
+
+      def hash?(payload)
+        payload.instance_of?(::Hash)
+      end
+
+      def array?(payload)
+        payload.instance_of?(::Array)
+      end
+
+      def simple_exchange(service:, payload:)
+        if array?(payload)
+          Object.const_get(service).exchanges(payload.first['id'])
+        else
+          Object.const_get(service).exchanges(payload[:id])
+        end
+      end
+
+      def max_similarity(name:, service:, payload:)
+        similarity = calculate_similarity(name: name, payload: payload)
+        similarity = similarity.sort_by { |h| h[:percentage] }.reverse
+
+        crypto = similarity.select { |x| (x[:percentage] * 100).to_i > PERCENTAGE }.first
+        return nil if similarity.nil? || similarity.empty?
+
+        simple_exchange(service: service, payload: crypto)
+      end
+
+      def calculate_similarity(name:, payload:)
+        similarity = []
+        payload.each do |p|
+          similarity.push(
+            'id': p['id'],
+            'percentage': String::Similarity.cosine(name, p['name'])
+          )
+        end
+
+        similarity
+      end
+    end
+  end
+end

data/lib/crypto/resources/exchanges/cx.rb

@@ -28,6 +28,89 @@ module Crypto
         def ping
           Coinex.ping == { status: 200 }
         end
+
+        private
+
+        # rubocop: disable Lint/MissingCopEnableDirective
+        def order(data:, index: nil)
+          if data[:result].nil? && data[:prices].nil? # Buy
+            result = Coinex::Order.market(params: params(data: data, index: index))
+            return correct(result) if cex_response_correct?(result) && index == 2
+
+            order_market(data: data, result: result)
+          else # Limit (SL & TP)
+            result = Coinex::Order.limit(params: params(data: data, index: index))
+            order_limit(result: result)
+          end
+        end
+
+        # rubocop: disable Metrics/MethodLength
+        def order_market(data:, result:)
+          if cex_response_correct?(result) # If correct, call SL & TP
+            prices = Crypto::Operation.send :calculate_win_or_lost,
+                                            avg_price: result['data']['avg_price'],
+                                            exchanges: data[:exchanges],
+                                            settings: data[:settings]
+
+            data[:prices] = prices
+            data[:result] = result
+            Crypto::Buy.send :divert, data
+          else
+            error(result)
+          end
+        end
+
+        def order_limit(result:)
+          if cex_response_correct?(result)
+            correct(result)
+          else
+            error(result)
+          end
+        end
+
+        def balance(count)
+          params = Coinex::Signature.calculate
+          params[:tonce] = '1672669323219' if Crypto.development
+
+          balance = Coinex::Balance.info(params: params)
+          balance['data']['USDT']['available'].to_i / count.to_i
+        end
+
+        def params(data:, index: nil)
+          params = if index.nil?
+                     { market: "#{data.dig(:payload, :symbol)}USDT", type: 'buy', amount: balance(data[:count]) }
+                   else
+                     limit_params(data: data, index: index)
+                   end
+
+          calculate_signature(params)
+        end
+
+        def limit_params(data:, index:)
+          case index
+          when 0 # SL
+            { market: "#{data.dig(:payload, :symbol)}USDT", type: 'sell', amount: data.dig(:result, 'data', 'amount'),
+              stop_price: Crypto::Loss.send(:what_price, data[:prices]) }
+          when 1 # TP
+            { market: "#{data.dig(:payload, :symbol)}USDT", type: 'sell', amount: data.dig(:result, 'data', 'amount'),
+              stop_price: Crypto::Profit.send(:what_price, data[:prices]) }
+          when 2 # SELL
+            { market: "#{data.dig(:payload, :symbol)}USDT", type: 'sell', amount: data[:balance] }
+          end
+        end
+
+        def calculate_signature(params)
+          data_signature = Coinex::Signature.calculate(params: params)
+
+          params[:tonce] = Crypto.development ? '1672669323219' : data_signature[:tonce]
+          params[:signature] = data_signature[:signature]
+
+          params
+        end
+
+        def cex_response_correct?(result)
+          (result['code']).zero?
+        end
       end
     end
   end

data/lib/crypto/resources/listing.rb

@@ -16,6 +16,8 @@ module Crypto
 
       # rubocop: disable Metrics/MethodLength, Lint/MissingCopEnableDirective
       def info
+        return test('crypto_listing.json') if Crypto.testing
+
         payload = detail
         if status?(payload)
           news = []

data/lib/crypto/resources/operation.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Crypto
+  class Operation < Base
+    class << self
+      private
+
+      def setup_keys(exchanges:, settings:)
+        return unless coinex?(exchanges)
+
+        coinex_keys(settings)
+        'CoinEx'
+      end
+
+      def coinex_keys(settings)
+        Crypto::Exchanges::Cx.access_id(settings[:access_id])
+        Crypto::Exchanges::Cx.secret_key(settings[:secret_key])
+      end
+
+      def clean_keys(exchange)
+        first = exchange.chr.upcase
+        last = exchange[-1].downcase
+
+        class_send = "Crypto::Exchanges::#{first}#{last}"
+        Object.const_get(class_send).clean_keys
+      end
+
+      def operations(data:, index: nil)
+        exchange = setup_keys(exchanges: data[:exchanges], settings: data[:settings])
+        return nil if exchange.nil?
+
+        # Buy or TP or SL
+        result = buy_or_limit(data: data, exchange: exchange, index: index)
+        clean_keys(exchange)
+
+        result
+      end
+
+      def buy_or_limit(data:, exchange:, index:)
+        case exchange
+        when 'CoinEx'
+          Crypto::Exchanges::Cx.send(:order, data: data, index: index)
+        end
+      end
+
+      def calculate_win_or_lost(avg_price:, exchanges:, settings:)
+        percentages = percentage(exchanges: exchanges, settings: settings)
+        profit = percentages.first
+        lost = percentages[1]
+
+        win_price = avg_price.to_f + ((avg_price.to_f * profit.to_f) / 100)
+        lost_price = avg_price.to_f - ((avg_price.to_f * lost.to_f) / 100)
+
+        [win_price, lost_price]
+      end
+
+      def percentage(exchanges:, settings:)
+        if binance?(exchanges)
+          profit = settings[:perc_profit_exchange]
+          loss = settings[:perc_lost_exchange]
+        else
+          profit = settings[:perc_profit_all]
+          loss = settings[:perc_lost_all]
+        end
+
+        [profit, loss]
+      end
+    end
+  end
+end

data/lib/crypto/resources/sell.rb

@@ -1,26 +1,10 @@
 # frozen_string_literal: true
 
 module Crypto
-  class Sell < Base
+  class Sell < Operation
     class << self
-      def order(payload:, settings:)
-        coinex_keys(settings)
-        result = Coinex::Order.market(params: params(payload))
-
-        Crypto::Exchanges::Cx.clean_keys
-
-        if response_correct?(result)
-          correct(result)
-        else
-          error(result)
-        end
-      end
-
-      private
-
-      def params(payload)
-        params = { market: "#{payload['symbol']}USDT", type: 'sell', amount: payload['balance'] }
-        calculate_signature(params)
+      def order(data)
+        operations(data: data, index: 2)
       end
     end
   end

data/lib/crypto/resources/stop.rb

@@ -1,30 +1,10 @@
 # frozen_string_literal: true
 
 module Crypto
-  class Stop < Base
+  class Stop < Operation
     class << self
-      def limit(payload:, result:, prices:, settings:)
-        coinex_keys(settings)
-
-        result = Coinex::Order.limit(params: params(
-          payload: payload, result: result, prices: prices
-        ))
-
-        Crypto::Exchanges::Cx.clean_keys
-        if response_correct?(result)
-          correct(result)
-        else
-          error(result)
-        end
-      end
-
-      private
-
-      def params(payload:, result:, prices:)
-        params = { market: "#{payload['symbol']}USDT", type: 'sell', amount: result['data']['amount'],
-                   stop_price: what_price(prices) }
-
-        calculate_signature(params)
+      def limit(data:, index:)
+        operations(data: data, index: index)
       end
     end
   end

data/lib/crypto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Crypto
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end

data/lib/crypto.rb

@@ -35,6 +35,14 @@ module Crypto
     def development
       @mutex.synchronize { ::Crypto::Base.development }
     end
+
+    def testing=(boolean)
+      @mutex.synchronize { ::Crypto::Base.testing = boolean }
+    end
+
+    def testing
+      @mutex.synchronize { ::Crypto::Base.testing }
+    end
   end
 end
 

data/spec/fixtures/coinex/cx_balance_info.json

@@ -0,0 +1,22 @@
+{
+    "code": 0,
+    "data": {
+        "BTC": {
+            "available": "9080.84156954",
+            "frozen": "1"
+        },
+        "USDT": {
+            "available" : "43724611.65252752",
+            "frozen": "1897.84472856"
+        },
+        "CET": {
+            "available": "6524.13695056",
+            "frozen": "0"
+        },
+        "ETH": {
+            " available": "10000",
+            "frozen": "0"
+        }
+    },
+    "message": "Success"
+}

data/spec/fixtures/coinex/cx_error.json

@@ -0,0 +1,6 @@
+{
+    "code": 25,
+    "data": {
+    },
+    "message": "Incorrect Signature"
+}

data/spec/fixtures/coinex/cx_order_limit.json

@@ -0,0 +1,7 @@
+{
+    "code": 0,
+    "data": {
+        "status": "success"
+    },
+    "message": "Success"
+}

data/spec/fixtures/coinex/cx_order_market.json

@@ -0,0 +1,29 @@
+{
+    "code": 0,
+    "data": {
+        "id": 35435973,
+        "create_time": 1636020409,
+        "finished_time": null,
+        "amount": 43724611,
+        "price": " 0",
+        "deal_amount": "1",
+        "deal_money": "54334.4024000000000000",
+        "deal_fee": "0",
+        "stock_fee": "0",
+        "money_fee": "0",
+        " asset_fee": "30.427265344000000000000000",
+        "fee_asset": "CET",
+        "fee_discount": "0.70",
+        "avg_price": "54334.4024",
+        "market": "BTCUSDT",
+        "left": "0.00000000 ",
+        "maker_fee_rate": "0",
+        "taker_fee_rate": "0.0016",
+        "order_type": "market",
+        "type": "sell",
+        "status": "done",
+        "client_id ": "",
+        "source_id": "1234"
+    },
+    "message": "Success"
+}