abot-whitelist 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87bf91fb9d03999272df0b4acac7cdaa84388253b42cb4c42730289095ccea4b
-  data.tar.gz: 13664637d383cc08486b67df9d257e15d156b4f712f225722eae949dc2f76845
+  metadata.gz: d399811d901d4890fefcd6db8442638ee60e3bd05cf37daab990813e0a630fed
+  data.tar.gz: ee0dce6fb6bf1d9e444d43ec3a6bf63123b84135b26c1a54c6dfb5acbe1e0958
 SHA512:
-  metadata.gz: 123fff02723291bae6eeca4d8ec8bfc6bc21bc74f23d1b171884555451702d33fe57fad9d21529b350b37b91b99a1a469854d3444e630afbba83954447cda359
-  data.tar.gz: 86f9135baf85bd8df12ffc3b2c66ee980114ed35555cc86fbe9084597318dae1692588505e151123e86e8f91259393e4fbd0895a88c2b2d7f6a62c09ba3d26ab
+  metadata.gz: 7788fdefec41dc9397e9a494f674e0e49da88aebf547b129c6a7090745cba60c9ad68447f02a24e4797c5339e2bc0e3c383682908ad10d75a4321273f289f92b
+  data.tar.gz: d836ccacf75442c67dba3ba95c2e1c0db0f4d6d39ab518d2af1517a0f160358e5ca8fa5e589788e8939aca8797723255981f39d899a6f26b96033d78aebb73d0

data/Gemfile

@@ -2,3 +2,4 @@ source 'https://rubygems.org'
 
 gem 'activerecord', '~> 6.1.3'
 gem 'binance-ruby', '~> 1.3.1'
+gem 'coingecko_ruby', '~> 0.4.2'

data/abot-whitelist.gemspec

@@ -34,5 +34,6 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "activerecord", '~> 6.1.3'
   spec.add_dependency "binance-ruby", '~> 1.3.1'
+  spec.add_dependency 'coingecko_ruby', '~> 0.4.2'
 
 end

data/lib/abot/whitelist/abot_config_site.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Abot
+  module Whitelist
+    class AbotConfigSite
+      include HTTParty
+
+      base_uri 'https://abot-config.ru'
+
+      def list(list_number)
+        path = "/coins/whitelist-#{list_number}.txt"
+        response = self.class.get(path)
+
+        if response.code == 200
+          response.body.split(' ') || ''
+        else
+          raise "get base whitelist from #{self.class.base_uri} error"
+        end
+      end
+    end
+  end
+end

data/lib/abot/whitelist/base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Abot
+  module Whitelist
+    class Base
+      attr_reader :top, :list_number
+
+      DEFAULT_COINS = %w[one unfi sol].freeze
+      FIAT = %w[usdt busd aud bidr brl eur gbr rub try tusd usdc dai idrt pax uah ngn vai bvnd].freeze
+      BLACK_LIST = %w[fun xvs aion btc].freeze
+
+      def self.black_coins
+        FIAT + BLACK_LIST
+      end
+
+      def initialize(options)
+        @top = options[:top]
+        @list_number = options[:list_number]
+      end
+
+      def process!
+        coins_list = top_list
+        if list_number
+          base_list = Abot::Whitelist::AbotConfigSite.new.list(list_number)
+          coins_list = coins_list.map { |m| base_list.include?(m) ? m : nil }.compact
+
+          puts "base list: #{base_list}\n"
+          puts "coins (count = #{coins_list.count}) from the base list in the top #{top} by capitalization:"
+        else
+          puts "coins (count = #{coins_list.count}) in the top #{top} by capitalization:"
+        end
+
+        puts coins_list.join(' ')
+      end
+
+    end
+  end
+end

data/lib/abot/whitelist/binance.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Abot
+  module Whitelist
+    class Binance < Base
+      attr_reader :top, :list_number
+
+      include HTTParty
+      base_uri 'https://www.binance.com'
+
+      def self.list_all_usdt_coins
+        usdt_coins.map { |m| black_coins.include?(m[:b].downcase) ? nil : m[:b].downcase }.compact
+      end
+
+      def self.usdt_coins
+        begin
+          JSON.parse(products, symbolize_names: true)[:data].select { |s| s[:q] == 'USDT' }
+        rescue JSON::ParserError => error
+          # binance 500 errors are html format
+          raise Error.new(message: error)
+        end
+      end
+
+      def self.products
+        path = '/exchange-api/v2/public/asset-service/product/get-products'
+        get(path).body
+      end
+
+      def top_list
+        all_coins = self.class.usdt_coins.map { |s| [s[:b], (s[:cs].to_f * s[:c].to_f)] }
+                                                  .sort_by { |s| s[1] }
+                                                  .reverse
+                                                  .map { |m| m[0] }
+        result = (all_coins - FIAT - BLACK_LIST - DEFAULT_COINS)[0..((top - 1) - DEFAULT_COINS.count)]
+        (result + DEFAULT_COINS).map(&:upcase)
+      end
+    end
+  end
+end
+

data/lib/abot/whitelist/coingecko.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'abot_config_site'
+require 'coingecko_ruby'
+
+module Abot
+  module Whitelist
+    class Coingecko < Base
+      attr_reader :client, :top, :list_number
+
+      DIF_COINS = {
+        'iota' => 'miota',
+        'data' => 'xdata',
+      }.freeze
+
+      def initialize(options)
+        @client = CoingeckoRuby::Client.new
+
+        super(options)
+      end
+
+      def top_list
+        coins_ids = []
+        list_all_usdt_coins = Binance.list_all_usdt_coins.map do |m|
+          DIF_COINS.find { |k, v| k == m }&.dig(1) || m
+        end
+
+        list_all_usdt_coins.each do |coin|
+          decorated_all_coins[coin]&.each { |e| coins_ids << e }
+          decorated_all_coins[coin.upcase]&.each { |e| coins_ids << e }
+        end
+        info = coins_info(coins_ids)
+        info.keys[0...top].map(&:upcase)
+      end
+
+      def coins_info(coins)
+        info = client.markets(coins.join(', '), vs_currency: 'gbp')
+        result = {}
+        info.each do |m|
+          if result[m['symbol']].nil? || (!m['market_cap_rank'].nil? && result[m['symbol']].to_i > m['market_cap_rank'].to_i)
+            result[m['symbol'].downcase] = m['market_cap_rank']
+          end
+        end
+
+        DIF_COINS.each { |k, v| result[k] = result.delete v }
+        result = result.sort_by { |_, v| v.nil? ? 100_000 : v }.to_h
+
+        no_rank_coins(result)
+        all_usdt_coins(result)
+
+        result
+      end
+
+      def all_coins
+        @all_coins ||= client.coins_list
+      end
+
+      private
+
+      def no_rank_coins(list)
+        puts "No rank coins: #{list.select { |_, v|  v.nil? }.keys.map(&:upcase).join(', ')}\n\n"
+      end
+
+      def all_usdt_coins(list)
+        puts "Rank all Binance USDT coins : #{list.map { |k, v| "#{k.upcase}-#{v}" }.join('; ')}\n\n"
+      end
+
+      def decorated_all_coins
+        return @decorated_all_coins if @decorated_all_coins
+
+        @decorated_all_coins = {}
+        all_coins.each do |m|
+          @decorated_all_coins["#{m['symbol']}"] ||= []
+          unless @decorated_all_coins["#{m['symbol']}"].include?(m['id'])
+            (@decorated_all_coins["#{m['symbol']}"] << m['id'])
+          end
+        end
+        @decorated_all_coins
+      end
+
+    end
+  end
+end

data/lib/abot/whitelist/version.rb

@@ -1,5 +1,5 @@
 module Abot
   module Whitelist
-    VERSION = "0.2.0"
+    VERSION = "0.3.1"
   end
 end

data/lib/abot/whitelist.rb

@@ -3,8 +3,11 @@
 require 'active_record'
 require 'binance-ruby'
 
+require_relative 'whitelist/abot_config_site'
 require_relative 'whitelist/option_parser'
-require_relative 'whitelist/binance_cap'
+require_relative 'whitelist/base'
+require_relative 'whitelist/binance'
+require_relative 'whitelist/coingecko'
 require_relative 'whitelist/version'
 
 module Abot
@@ -27,15 +30,37 @@ module Abot
             :top, '--top=number',
             'Число монет (ТОП по капитализации)',
           )
+
+          parser.add_option(
+            :api, '--api=string',
+            'Api: Binance, Coingecko',
+            )
         end.final!
 
-        list_number = Whitelist::OptionParser.instance.options[:list_number].to_i
-        top_number = (Whitelist::OptionParser.instance.options[:top] || 100).to_i
+        case opts[:api].downcase
+        when 'binance'
+          Abot::Whitelist::Binance.new(opts).process!
+        when 'coingecko'
+          Abot::Whitelist::Coingecko.new(opts).process!
+        else
+          # nothing
+        end
+      end
 
+      private
+
+      def opts
+        top_number = (Whitelist::OptionParser.instance.options[:top] || 150).to_i
         raise 'top is wrong' unless top_number.positive?
 
-        base_list = Abot::Whitelist::BaseWhitelist.base_whitelist(list_number: list_number) if list_number.positive?
-        BinanceCap.send_req(base_list: base_list, top_number: top_number)
+        api = Whitelist::OptionParser.instance.options[:api]&.downcase || 'coingecko'
+        raise 'api must be Binance, Coingecko' unless ['binance', 'coingecko'].include?(api)
+
+        {
+          list_number: Whitelist::OptionParser.instance.options[:list_number],
+          top: top_number,
+          api: api,
+        }
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abot-whitelist
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - w_dmitrii
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-24 00:00:00.000000000 Z
+date: 2021-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: coingecko_ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
 description:
 email:
 - wiz.work2021@gmail.com
@@ -95,8 +109,10 @@ files:
 - abot-whitelist.gemspec
 - exe/abot-whitelist
 - lib/abot/whitelist.rb
-- lib/abot/whitelist/base_whitelist.rb
-- lib/abot/whitelist/binance_cap.rb
+- lib/abot/whitelist/abot_config_site.rb
+- lib/abot/whitelist/base.rb
+- lib/abot/whitelist/binance.rb
+- lib/abot/whitelist/coingecko.rb
 - lib/abot/whitelist/option_parser.rb
 - lib/abot/whitelist/version.rb
 - spec/abot/whitelist_spec.rb

data/lib/abot/whitelist/base_whitelist.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Abot
-  module Whitelist
-    class BaseWhitelist
-      include HTTParty
-
-      class << self
-        def base_whitelist(list_number:)
-          self.base_uri 'https://abot-config.ru'
-
-          path = "/coins/whitelist-#{list_number}.txt"
-          response = get(path)
-
-          if response.code == 200
-            response.body.split(' ') || ''
-          else
-            raise "get base whitelist from #{base_uri} error"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/abot/whitelist/binance_cap.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require_relative 'base_whitelist'
-
-module Abot
-  module Whitelist
-    class BinanceCap
-      include HTTParty
-
-      DEFAULT_COINS = %w[ONE UNFI SOL].freeze
-      FIAT = %w[USDT BUSD AUD BIDR BRL EUR GBR RUB TRY TUSD USDC DAI IDRT PAX UAH NGN VAI BVND].freeze
-      BLACK_LIST = %w[FUN XVS AION BTC].freeze
-
-      class << self
-        def send_req(base_list:, top_number:)
-          self.base_uri 'https://www.binance.com'
-
-          path = '/exchange-api/v2/public/asset-service/product/get-products'
-          response = get(path)
-          process!(response: response || '{}', base_list: base_list, top_number: top_number)
-        end
-
-        private
-
-        def process!(response:, base_list:, top_number:)
-          result = top(response: response, top_number: top_number)
-          if base_list
-            result = result.map { |m| base_list.include?(m) ? m : nil }.compact
-
-            puts "base list: #{base_list}"
-            puts '+++++++++++++++++++++++++++++++++++++++++++++'
-            puts "coins (count = #{result.count}) from the base list in the top #{top_number} by capitalization:"
-          else
-            puts "coins (count = #{result.count}) in the top #{top_number} by capitalization:"
-          end
-
-          puts result.join(' ')
-        end
-
-        def top(response:, top_number:)
-          all_coins = usdt_coins(response: response).map { |s| [s[:b], (s[:cs].to_f * s[:c].to_f)] }
-                                                    .sort_by { |s| s[1] }
-                                                    .reverse
-                                                    .map { |m| m[0] }
-          result = (all_coins - FIAT - BLACK_LIST)[0..((top_number - 1) - DEFAULT_COINS.count)]
-          result + DEFAULT_COINS
-        end
-
-        def usdt_coins(response:)
-          serialized_response(response: response)[:data].select { |s| s[:q] == 'USDT' }
-        end
-
-        def serialized_response(response:)
-          begin
-            JSON.parse(response.body, symbolize_names: true)
-          rescue JSON::ParserError => error
-            # binance 500 errors are html format
-            raise Error.new(message: error)
-          end
-        end
-      end
-    end
-  end
-end