crypto-service 0.0.0 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caeb3d4bf826a92cf335e649c50fb7abadd7b6175c021f438641781f070f3e05
-  data.tar.gz: 9b5a35056f03f7701f8482cd28b2a55edbb0d587548192859bcfd2c0b5cc7c49
+  metadata.gz: 42f3bc09e96cae2487fc28602311063ed0d80ec1fbf7a3617b55b1dac90ca755
+  data.tar.gz: 54acf3951a8b663e41dfa98965b3c064218d4b070f0b7930cb5a4176200dcf5f
 SHA512:
-  metadata.gz: 91558907b161b5cde84533d8df178cf2c20e31d570e029045a7eea9cf85a80868b39d7f0f51f4d9fdb03f712209affe94fc6f296c97b6db609ee18ca0fb7aea4
-  data.tar.gz: 4024d5c5eaa55c595a46f0404d778eabdcaa20cd27eba183c9b996f40f6053def3d78be7e41cf4bbafb0f3fab4fcb67a45b3100acba536a5ae398dc93cec4c18
+  metadata.gz: bee095306e6b1ee2d8baf40ec285295851fb92dd4fc842e65d1c464a23f8c60b6ba54a29ca66331623f6b56d7cd7fe42794954707baf7d91ea3ba1d4b37b8a64
+  data.tar.gz: 483f2a06607e4499e7de5659eca9d064bacf6befccf407c18271a1d6e1c12eda21b0ca568fb7fbeec86ece9329906a20f0d52b82a79ba1f82891cae504ee2419

data/lib/crypto/base.rb

@@ -4,13 +4,46 @@ 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
+      attr_accessor :app_info, :path_prefix, :development, :testing
+
+      def test(fixture)
+        load_fixture(fixture)
+      end
+
+      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)
+        { 'status' => :success, 'code' => 200, 'payload' => result }
+      end
+
+      def error(result)
+        { 'status' => :failed, 'code' => result['code'], 'message' => result['message'] }
+      end
+
+      def binance?(exchanges)
+        exchanges.include?('Binance')
+      end
+
+      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 # For rspec & test
+    self.testing = false # For real call, but return development payload
   end
 end

data/lib/crypto/resources/buy.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Class that buy crypto, set TP & SL and return their responses
+# Parameter of order:
+# Payload: Hash of Crypto::Listing.info or Crypto::Top.info
+# Settings: contact settings
+# Exchange: exchange where crypto is listed or buy, (Binance → 20%, Other exchange → 10% )
+
+module Crypto
+  class Buy < Operation
+    class << self
+      # rubocop: disable Metrics/MethodLength, Lint/MissingCopEnableDirective
+      def order(data)
+        return test('crypto_buy.json') if Crypto.testing
+
+        operations(data: data, index: nil)
+      end
+
+      private
+
+      def divert(data)
+        operations = []
+        data[:result]['operation'] = 'B'
+        operations << data[:result]
+
+        loss = Crypto::Loss.limit(data: data, index: 0)
+        loss['operation'] = 'SL'
+        operations << loss
+        return operations if data.dig(:payload, :mode) == :top
+
+        profit = Crypto::Profit.limit(data: data, index: 1)
+        profit['operation'] = 'TP'
+        operations << profit
+
+        operations
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# Exchange -> Coinex
+
+module Crypto
+  module Exchanges
+    class Cx < Base
+      class << self
+        def access_id(access_id)
+          return unless ping
+
+          Coinex.access_id = access_id
+        end
+
+        def secret_key(secret_key)
+          return unless ping
+
+          Coinex.secret_key = secret_key
+        end
+
+        def clean_keys
+          return unless ping
+
+          Coinex.access_id = nil
+          Coinex.secret_key = nil
+        end
+
+        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
+end

data/lib/crypto/resources/listing.rb

@@ -2,6 +2,8 @@
 
 require 'active_support/all'
 
+# Class that return crypto listed in a interval of MINUTES
+
 module Crypto
   class Listing < Base
     MINUTES = 15
@@ -14,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 = []
@@ -34,7 +38,7 @@ module Crypto
 
       def detail
         uri = URI("#{Crypto.path}/listings/new?limit=100&start=1")
-        Crypto::Request.request(uri: uri, method: 'GET')
+        Request::Http.request(uri: uri, method: 'GET')
       end
 
       def status?(payload)

data/lib/crypto/resources/loss.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Crypto
+  class Loss < Stop
+    class << self
+      private
+
+      def what_price(prices)
+        prices[1]
+      end
+    end
+  end
+end

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/profit.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Crypto
+  class Profit < Stop
+    class << self
+      private
+
+      def what_price(prices)
+        prices.first
+      end
+    end
+  end
+end

data/lib/crypto/resources/sell.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crypto
+  class Sell < Operation
+    class << self
+      def order(data)
+        operations(data: data, index: 2)
+      end
+    end
+  end
+end

data/lib/crypto/resources/stop.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crypto
+  class Stop < Operation
+    class << self
+      def limit(data:, index:)
+        operations(data: data, index: index)
+      end
+    end
+  end
+end

data/lib/crypto/resources/top.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Class that return crypto after a percentage in top gainers
+
 module Crypto
   class Top < Base
     PERCENTAGE = 20.0
@@ -32,7 +34,7 @@ module Crypto
 
       def detail
         uri = URI("#{Crypto.path}/trending/gainers-losers?limit=100&sort_dir=desc&start=1")
-        Crypto::Request.request(uri: uri, method: 'GET')
+        Request::Http.request(uri: uri, method: 'GET')
       end
 
       def status?(payload)

data/lib/crypto/version.rb

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

data/lib/crypto.rb

@@ -27,6 +27,22 @@ module Crypto
     def version
       VERSION
     end
+
+    def development=(boolean)
+      @mutex.synchronize { ::Crypto::Base.development = boolean }
+    end
+
+    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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crypto-service
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.2
 platform: ruby
 authors:
 - Stefano Baldazzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-02 00:00:00.000000000 Z
+date: 2023-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,76 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 7.0.4
+- !ruby/object:Gem::Dependency
+  name: aga-request
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+- !ruby/object:Gem::Dependency
+  name: coinex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: coinpaprika
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: gecko-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: string-similarity
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -162,8 +232,15 @@ files:
 - lib/crypto.rb
 - lib/crypto/autoloader.rb
 - lib/crypto/base.rb
+- lib/crypto/resources/buy.rb
+- lib/crypto/resources/exchange.rb
+- lib/crypto/resources/exchanges/cx.rb
 - lib/crypto/resources/listing.rb
-- lib/crypto/resources/request.rb
+- lib/crypto/resources/loss.rb
+- lib/crypto/resources/operation.rb
+- lib/crypto/resources/profit.rb
+- lib/crypto/resources/sell.rb
+- lib/crypto/resources/stop.rb
 - lib/crypto/resources/top.rb
 - lib/crypto/version.rb
 homepage: https://github.com/Baldaz02/crypto-ruby
@@ -188,5 +265,5 @@ requirements: []
 rubygems_version: 3.3.24
 signing_key: 
 specification_version: 4
-summary: crypto0.0.0
+summary: crypto0.0.2
 test_files: []

data/lib/crypto/resources/request.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Crypto
-  class Request < Base
-    class << self
-      def request(uri:, method:)
-        req = get_method(name: method, uri: uri)
-        req['Content-Type'] = 'application/json'
-
-        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
-          http.request(req)
-        end
-
-        JSON.parse(res.body)
-      end
-
-      def get_method(name:, uri:)
-        case name
-        when 'GET'
-          req = Net::HTTP::Get.new(uri)
-          # when 'POST'
-          #   req = Net::HTTP::Post.new(uri)
-          # when 'DELETE'
-          #   req = Net::HTTP::Delete.new(uri)
-        end
-
-        req
-      end
-    end
-  end
-end