cryptum 0.0.359 → 0.0.360

data/lib/cryptum/bot_conf.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Cryptum
+  # This plugin is used to read and update bot conf files.
+  module BotConf
+    # Deserialize Cryptum Bot Conf
+    public_class_method def self.read(opts = {})
+      option_choice = opts[:option_choice]
+      event_history = opts[:event_history]
+
+      session_root = option_choice.session_root
+      symbol = option_choice.symbol
+      bot_conf_file = "#{session_root}/etc/bot_confs/#{symbol}_bot_conf.yaml"
+      unless File.exist?(bot_conf_file)
+        FileUtils.cp(
+          "#{session_root}/etc/bot_confs/BOT_CONF.TEMPLATE",
+          bot_conf_file
+        )
+      end
+
+      bot_conf = YAML.load_file(
+        bot_conf_file,
+        symbolize_names: true
+      )
+
+      ai_enabled = bot_conf[:artifical_intelligence]
+      if ai_enabled && event_history
+        bot_conf = Cryptum::BotConf.recalculate_tpm(
+          option_choice: option_choice,
+          event_history: event_history,
+          bot_conf: bot_conf
+        )
+      end
+
+      bot_conf
+    rescue Errno::ENOENT, NoMethodError => e
+      File.open('/tmp/cryptum-errors.txt', 'a') do |f|
+        f.puts Time.now.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+        f.puts "Module: #{self}"
+        f.puts "#{e}\n\n\n"
+      end
+
+      retry
+    rescue Interrupt
+      # Exit Gracefully if CTRL+C is Pressed During Session
+      Cryptum.exit_gracefully(which_self: self)
+    rescue StandardError => e
+      # Produce a Stacktrace for anything else
+      Curses.close_screen
+      raise e
+    end
+
+    # SAUCE 1
+    # Calculate Target Profit Margin Percent Based Upon
+    # Observed Margins of Change in the Past 24hrs.
+    public_class_method def self.recalculate_tpm(opts = {})
+      option_choice = opts[:option_choice]
+      event_history = opts[:event_history]
+      bot_conf = opts[:bot_conf]
+
+      # BE EXTREMELY CAREFUL CHANGING THIS VALUE AS IT DICTATES
+      # THE TARGET PRICE AND SUBSEQUENT TIME IT TAKES FOR AN OPEN
+      # SELL ORDER TO BE TRIGGERED!!! SHOULD NEVER BE > 1
+      default_net_tpm = 1.0
+      maker_rate = 0.4
+      taker_rate = 0.6
+
+      gross_tpm = bot_conf[:target_profit_margin_percent].to_f
+
+      # Refactor TPM to be 1.0 > than fee tier,
+      # particularly as fee tier goes up or down
+      fees = event_history.order_book[:fees]
+      maker_rate = fees[:maker_fee_rate].to_f unless fees.empty?
+      # maker_fee = format('%0.2f', maker_rate * 100)
+
+      taker_rate = fees[:taker_fee_rate].to_f unless fees.empty?
+      # taker_fee = format('%0.2f', taker_rate * 100)
+
+      # Set default_net_tpm if AI is true in bot_conf.
+      low_24h = event_history.order_book[:low_24h].to_f
+      high_24h = event_history.order_book[:high_24h].to_f
+
+      case option_choice.market_trend_reset
+      when 604_800
+        # 1W Chart
+        ai_net_tpm = ((1 - (low_24h / high_24h)) * 100) * 7
+      when 86_400
+        # 1D Chart
+        ai_net_tpm = (1 - (low_24h / high_24h)) * 100
+      when 14_400
+        # 4H Chart
+        ai_net_tpm = ((1 - (low_24h / high_24h)) * 100) / 6
+      when 10_800
+        # 3H Chart
+        ai_net_tpm = ((1 - (low_24h / high_24h)) * 100) / 8
+      when 7_200
+        # 2H Chart
+        ai_net_tpm = ((1 - (low_24h / high_24h)) * 100) / 12
+      when 3_600
+        # 1H Chart
+        ai_net_tpm = ((1 - (low_24h / high_24h)) * 100) / 24
+      when 2_700
+        # 45m Chart
+        ai_net_tpm = (((1 - (low_24h / high_24h)) * 100) / 24) * 0.75
+      when 1_800
+        # 30m Chart
+        ai_net_tpm = (((1 - (low_24h / high_24h)) * 100) / 24) * 0.5
+      when 900
+        # 15m Chart
+        ai_net_tpm = (((1 - (low_24h / high_24h)) * 100) / 24) * 0.25
+      when 300
+        # 5m Chart
+        ai_net_tpm = (((1 - (low_24h / high_24h)) * 100) / 24) * 0.083
+      when 180
+        # 3m Chart
+        ai_net_tpm = (((1 - (low_24h / high_24h)) * 100) / 24) * 0.05
+      when 60
+        # 1m Chart
+        ai_net_tpm = (((1 - (low_24h / high_24h)) * 100) / 24) * 0.017
+      end
+
+      default_net_tpm = ai_net_tpm if ai_net_tpm > default_net_tpm
+
+      min_gross_tpm = format(
+        '%0.2f',
+        (maker_rate.to_f + taker_rate.to_f) + default_net_tpm
+      )
+
+      if min_gross_tpm != gross_tpm.to_s
+        bot_conf[:target_profit_margin_percent] = min_gross_tpm.to_f
+        Cryptum::BotConf.update(
+          option_choice: option_choice,
+          bot_conf: bot_conf,
+          key: :target_profit_margin_percent,
+          value: min_gross_tpm.to_f
+        )
+      end
+
+      bot_conf
+    rescue Errno::ENOENT, NoMethodError => e
+      File.open('/tmp/cryptum-errors.txt', 'a') do |f|
+        f.puts Time.now.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+        f.puts "Module: #{self}"
+        f.puts "#{e}\n\n\n"
+      end
+
+      retry
+    rescue Interrupt
+      # Exit Gracefully if CTRL+C is Pressed During Session
+      Cryptum.exit_gracefully(which_self: self)
+    rescue StandardError => e
+      # Produce a Stacktrace for anything else
+      Curses.close_screen
+      raise e
+    end
+
+    # Update Key/Value Pair in Bot Conf and Serialize to YAML File
+    public_class_method def self.update(opts = {})
+      option_choice = opts[:option_choice]
+      bot_conf = opts[:bot_conf]
+      key = opts[:key].to_s.to_sym
+      value = opts[:value]
+
+      session_root = option_choice.session_root
+      symbol = option_choice.symbol
+      bot_conf_file = "#{session_root}/etc/bot_confs/#{symbol}_bot_conf.yaml"
+
+      bot_conf[key] = value
+      File.write(bot_conf_file, bot_conf.to_yaml)
+    rescue Errno::ENOENT, NoMethodError => e
+      File.open('/tmp/cryptum-errors.txt', 'a') do |f|
+        f.puts Time.now.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+        f.puts "Module: #{self}"
+        f.puts "#{e}\n\n\n"
+      end
+
+      retry
+    rescue Interrupt
+      # Exit Gracefully if CTRL+C is Pressed During Session
+      Cryptum.exit_gracefully(which_self: self)
+    rescue StandardError => e
+      # Produce a Stacktrace for anything else
+      Curses.close_screen
+      raise e
+    end
+
+    # Display Usage for this Module
+
+    public_class_method def self.help
+      puts "USAGE:
+        logger = #{self}.create()
+      "
+    end
+  end
+end

data/lib/cryptum/event/bot_conf.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Reload the Bot Conf When the "r" Key is Pressed
+  module Event
+    module BotConf
+      # Supported Method Parameters::
+      # Cryptum::Event::BotConf.reload(
+      # )
+      public_class_method def self.reload(opts = {})
+        terminal_win = opts[:terminal_win]
+        event_history = opts[:event_history]
+        option_choice = opts[:option_choice]
+
+        event_history.recalculate_order_plan = true
+        terminal_win.key_press_event.key_r = false
+
+        Cryptum::BotConf.read(
+          option_choice: option_choice,
+          event_history: event_history
+        )
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+      public_class_method def self.help
+        puts "USAGE:
+         bot_conf = #{self}.reload()
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/event/buy.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Submit a Limit Order
+  # to Buy Crypto Currency
+
+  module Event
+    module Buy
+      # Supported Method Parameters::
+      # Cryptum::Event::Buy.crypto(
+      # )
+      public_class_method def self.crypto(opts = {})
+        option_choice = opts[:option_choice]
+        env = opts[:env]
+        bot_conf = opts[:bot_conf]
+        event_history = opts[:event_history]
+        order_type = opts[:order_type]
+        fiat_smallest_decimal = opts[:fiat_smallest_decimal]
+        # fiat_portfolio_file = opts[:fiat_portfolio_file]
+        order_history = opts[:order_history]
+        crypto_smallest_decimal = opts[:crypto_smallest_decimal]
+        # base_min_size = opts[:base_min_size]
+        min_market_funds = this_product[:min_market_funds]
+        indicator_status = opts[:indicator_status]
+
+        # Initialize some bot_conf variables
+        pie_in_sky_buy_percent = bot_conf[:pie_in_sky_buy_percent].to_f
+        autotrade_portfolio_percent = bot_conf[:autotrade_portfolio_percent].to_f
+        # target_profit_margin_percent = bot_conf[:target_profit_margin_percent].to_f
+
+        crypto_currency = option_choice.symbol.to_s.upcase.split('_').first
+        portfolio = event_history.order_book[:portfolio]
+        symbol_portfolio = portfolio.select do |this_portfolio|
+          this_portfolio if this_portfolio[:currency] == crypto_currency
+        end
+
+        symbol_balance = format(
+          '%0.8f',
+          symbol_portfolio.first[:balance].to_f
+        ).to_f
+
+        # 2. Calculate Price, Size, Fees
+        # Get the middle of last 3 ticker prices
+        # to avoid over purcase blips.
+        last_three_prices_arr = []
+        last_ticker_price = event_history.order_book[:ticker_price].to_f
+        second_to_last_ticker_price = event_history.order_book[:ticker_price_second_to_last].to_f
+        third_to_last_ticker_price = event_history.order_book[:ticker_price_third_to_last].to_f
+        last_three_prices_arr.push(last_ticker_price)
+        last_three_prices_arr.push(second_to_last_ticker_price)
+        last_three_prices_arr.push(third_to_last_ticker_price)
+
+        case order_type
+        when :pie
+          limit_price = last_three_prices_arr.sort[1]
+          pie_in_sky_buy_percent_cast_as_decimal = format(
+            '%0.2f',
+            pie_in_sky_buy_percent * 0.01
+          ).to_f
+
+          limit_price -= (limit_price * pie_in_sky_buy_percent_cast_as_decimal)
+        when :tpm
+          limit_price = last_three_prices_arr.sort[1]
+        when :gtfo
+          # price = format("%0.#{fiat_smallest_decimal}f", limit_price)
+          raise "ERROR: Why is a Buy Submitted for #{order_type}?"
+        else
+          raise "ERROR: Unknown order_type: #{order_type}"
+        end
+
+        price = format("%0.#{fiat_smallest_decimal}f", limit_price)
+
+        # TODO: Determine if our N% Autotrade
+        # Threshold has already been met
+        # Buying Crypto w/ Fiat
+        autotrade_portfolio_percent_cast_as_decimal = format(
+          '%0.7f',
+          autotrade_portfolio_percent * 0.01
+        ).to_f
+
+        fiat_portfolio = event_history.order_book[:fiat_portfolio]
+        fiat_balance_available = format(
+          "%0.#{fiat_smallest_decimal}f",
+          fiat_portfolio.first[:available]
+        ).to_f
+
+        # Make sure size is within constraints
+        # of autotrade_portfolio_percent
+        total_limit_buy_orders_open = order_history.select do |orders|
+          orders[:type] == 'limit' &&
+            orders[:side] == 'buy' &&
+            orders[:status] == 'open'
+        end
+
+        total_limit_buy_order_open_tot = total_limit_buy_orders_open.length
+        total_limit_buy_orders_open_size = total_limit_buy_orders_open.inject(0) do |sum, hash|
+          sum + hash[:size].to_f
+        end.to_f
+
+        fiat_to_autotrade = fiat_balance_available * autotrade_portfolio_percent_cast_as_decimal
+        calc_fiat_to_buy = (fiat_to_autotrade / last_ticker_price) - symbol_balance
+        size = format(
+          "%0.#{crypto_smallest_decimal}f",
+          calc_fiat_to_buy - total_limit_buy_orders_open_size
+        )
+
+        if min_market_funds.to_i >= 1
+          size = (
+            (calc_fiat_to_buy - total_limit_buy_orders_open_size).to_i - min_market_funds.to_i
+          ).to_s
+        end
+
+        if size.to_f >= min_market_funds.to_f &&
+           total_limit_buy_order_open_tot.zero? &&
+           price.to_f.positive?
+          # SUBMIT BUY ORDER
+          event_history.order_submitted = true
+          event_history.event_notes = "{ \"event_type\": \"#{event_history.event_type}\", \"cancel\": \"#{event_history.order_canceled}\", \"submitted\": \"#{event_history.order_submitted}\" }" if option_choice.proxy
+
+          event_history = Cryptum::API.submit_limit_order(
+            option_choice: option_choice,
+            env: env,
+            price: price,
+            size: size,
+            buy_or_sell: :buy,
+            order_type: order_type,
+            event_history: event_history,
+            indicator_status: indicator_status
+          )
+        end
+
+        event_history
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+      public_class_method def self.help
+        puts "USAGE:
+         event_history = #{self}.crypto()
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/event/cancel.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Reload the Bot Conf When the "C" Key is Pressed
+  module Event
+    module Cancel
+      # Supported Method Parameters::
+      # Cryptum::Event::Cancel.open_orders(
+      # )
+      public_class_method def self.open_orders(opts = {})
+        terminal_win = opts[:terminal_win]
+        option_choice = opts[:option_choice]
+        env = opts[:env]
+        # event_history = opts[:event_history]
+        # order_type = opts[:order_type]
+        # order_action = opts[:order_action]
+
+        terminal_win.key_press_event.key_c = false
+        Cryptum::API.cancel_all_open_orders(
+          env: env,
+          option_choice: option_choice
+        )
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+      public_class_method def self.help
+        puts "USAGE:
+          #{self}.open_orders()
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/event/exit.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Exit Cryptum Gracefully When the "x" Key is Pressed
+  module Event
+    module Exit
+      # Supported Method Parameters::
+      # Cryptum::Event::BotConf.gracefully(
+      # )
+      public_class_method def self.gracefully(opts = {})
+        terminal_win = opts[:terminal_win]
+        event_history = opts[:event_history]
+        option_choice = opts[:option_choice]
+        env = opts[:env]
+
+        terminal_win.key_press_event.key_x = false
+        Cryptum.exit_gracefully(
+          which_self: self,
+          event_history: event_history,
+          option_choice: option_choice,
+          env: env
+        )
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+      public_class_method def self.help
+        puts "USAGE:
+          #{self}.gracefully()
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/event/gtfo.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Get the F* Out (GTFO) when the "G" Key is Pressed
+  module Event
+    module GTFO
+      # Supported Method Parameters::
+      # Cryptum::Event::GTFO.now(
+      # )
+      public_class_method def self.now(opts = {})
+        terminal_win = opts[:terminal_win]
+        option_choice = opts[:option_choice]
+        env = opts[:env]
+        event_history = opts[:event_history]
+        bot_conf = opts[:bot_conf]
+
+        terminal_win.key_press_event.key_g = false
+        Cryptum::API.gtfo(
+          option_choice: option_choice,
+          env: env,
+          event_history: event_history,
+          bot_conf: bot_conf
+        )
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+      public_class_method def self.help
+        puts "USAGE:
+         bot_conf = #{self}.now()
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/event/history.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Track Event History
+  module Event
+    # Keep Last Event History When Terminal Resize Occuers
+    class History
+      attr_accessor :bullish_trend,
+                    :event,
+                    :event_notes,
+                    :event_type,
+                    :first_event,
+                    :market_trend_event,
+                    :open_sell_orders,
+                    :open_sell_orders_max,
+                    :open_sell_orders_merge,
+                    :order_book,
+                    :order_canceled,
+                    :order_execute_win_active,
+                    :order_execute_details_win_active,
+                    :order_execute_index_offset,
+                    :order_execute_max_rows_to_display,
+                    :order_execute_max_records_available_to_display,
+                    :order_execute_row_to_select,
+                    :order_execute_selected_data,
+                    :order_plan_win_active,
+                    :order_plan_details_win_active,
+                    :order_plan_index_offset,
+                    :order_plan_max_rows_to_display,
+                    :order_plan_max_records_available_to_display,
+                    :order_plan_row_to_select,
+                    :order_plan_selected_data,
+                    :order_ready,
+                    :order_submitted,
+                    :plan_no,
+                    :reconnected,
+                    :red_pill,
+                    :start_time,
+                    :ticker_event,
+                    :time_between_orders,
+                    :time_between_orders_max,
+                    :time_between_orders_min,
+                    :time_between_orders_reset,
+                    :recalculate_order_plan
+
+      def initialize(opts = {})
+        # option_choice = opts[:option_choice]
+        start_time = opts[:start_time]
+        order_book = opts[:order_book]
+
+        self.bullish_trend = true
+        self.first_event = true
+        self.open_sell_orders = 0
+        self.open_sell_orders_max = 500
+        self.open_sell_orders_merge = false
+        self.order_book = order_book
+        self.order_canceled = false
+        self.order_execute_win_active = false
+        self.order_execute_details_win_active = false
+        self.order_execute_index_offset = 0
+        self.order_execute_max_rows_to_display = 6
+        self.order_execute_max_records_available_to_display = 6
+        self.order_execute_row_to_select = order_execute_index_offset
+        self.order_execute_selected_data = { color: :white }
+        self.order_plan_win_active = true
+        self.order_plan_details_win_active = false
+        self.order_plan_index_offset = 0
+        self.order_plan_max_rows_to_display = 6
+        self.order_plan_max_records_available_to_display = 6
+        self.order_plan_row_to_select = order_plan_index_offset
+        self.order_plan_selected_data = { color: :white }
+        self.order_ready = false
+        self.order_submitted = false
+        self.plan_no = 1
+        self.reconnected = false
+        self.red_pill = false
+        self.recalculate_order_plan = false
+        self.start_time = start_time
+
+        # -------------------------------------------------- #
+        # SAUCE 4
+        # TODO: develop algorithm to calculate
+        # FAST BUY && SLOW BUY values taking
+        # market_trend_reset values into account
+
+        # FAST BUY = 10 minutes
+        # self.time_between_orders = 600
+        self.time_between_orders = 3_600
+        self.time_between_orders_reset = time_between_orders
+
+        # SLOW BUY = 1 hour
+        self.time_between_orders_max = 14_400
+        # self.time_between_orders_max = 3_600
+
+        # 5 seconds
+        # self.time_between_orders_min = 5
+        self.time_between_orders_min = 600
+        # -------------------------------------------------- #
+      end
+    rescue Interrupt
+      # Exit Gracefully if CTRL+C is Pressed During Session
+      Cryptum.exit_gracefully(which_self: self)
+    rescue StandardError => e
+      # Produce a Stacktrace for anything else
+      raise e
+    end
+  end
+end

data/lib/cryptum/event/key_press.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Detect if any Keys were Pressed on the Keyboard
+  module Event
+    module KeyPress
+      # Supported Method Parameters::
+      # Cryptum::Event::KeyPress.detect(
+      # )
+      public_class_method def self.detect(opts = {})
+        terminal_win = opts[:terminal_win]
+
+        Cryptum::UI.detect_key_press_in_ui(
+          key_press_event: terminal_win.key_press_event,
+          ui_win: terminal_win.ticker_section
+        )
+
+        Cryptum::UI.detect_key_press_in_ui(
+          key_press_event: terminal_win.key_press_event,
+          ui_win: terminal_win.portfolio_section
+        )
+
+        Cryptum::UI.detect_key_press_in_ui(
+          key_press_event: terminal_win.key_press_event,
+          ui_win: terminal_win.order_plan_section
+        )
+
+        Cryptum::UI.detect_key_press_in_ui(
+          key_press_event: terminal_win.key_press_event,
+          ui_win: terminal_win.order_timer_section
+        )
+
+        Cryptum::UI.detect_key_press_in_ui(
+          key_press_event: terminal_win.key_press_event,
+          ui_win: terminal_win.market_trend_section
+        )
+
+        Cryptum::UI.detect_key_press_in_ui(
+          key_press_event: terminal_win.key_press_event,
+          ui_win: terminal_win.signal_engine_section
+        )
+
+        Cryptum::UI.detect_key_press_in_ui(
+          key_press_event: terminal_win.key_press_event,
+          ui_win: terminal_win.order_execute_section
+        )
+
+        Cryptum::UI.detect_key_press_in_ui(
+          key_press_event: terminal_win.key_press_event,
+          ui_win: terminal_win.command_section
+        )
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+      public_class_method def self.help
+        puts "USAGE:
+         order_book = #{self}.crypto()
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/event/order_book.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Write the Order Book from Memory
+  # to File When the "w" Key is Pressed
+  module Event
+    module OrderBook
+      # Supported Method Parameters::
+      # Cryptum::Event::BotConf.write(
+      # )
+      public_class_method def self.write(opts = {})
+        terminal_win = opts[:terminal_win]
+        event_history = opts[:event_history]
+
+        terminal_win.key_press_event.key_w = false
+        order_book_file = event_history.order_book[:path]
+
+        File.write(
+          order_book_file,
+          JSON.pretty_generate(event_history.order_book)
+        )
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+      public_class_method def self.help
+        puts "USAGE:
+          #{self}.write()
+        "
+      end
+    end
+  end
+end