cryptum 0.0.230

data/lib/cryptum/bot_conf.rb

@@ -0,0 +1,76 @@
+# 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]
+
+      bot_conf_file = "#{option_choice.repo_root}/etc/bot_confs/#{option_choice.symbol}_bot_conf.yaml"
+      unless File.exist?(bot_conf_file)
+        FileUtils.cp(
+          "#{option_choice.repo_root}/etc/bot_confs/BOT_CONF.TEMPLATE",
+          bot_conf_file
+        )
+      end
+
+      YAML.load_file(
+        bot_conf_file,
+        symbolize_names: true
+      )
+    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]
+
+      bot_conf_file = "#{option_choice.repo_root}/etc/bot_confs/#{option_choice.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/buy.rb

@@ -0,0 +1,144 @@
+# 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]
+        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 base_min_size.to_i >= 1
+          size = (
+            (calc_fiat_to_buy - total_limit_buy_orders_open_size).to_i - base_min_size.to_i
+          ).to_s
+        end
+
+        if size.to_f >= base_min_size.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,49 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Cancel Open Limit Orders
+  module Event
+    module Cancel
+      # Supported Method Parameters::
+      # Cryptum::Event::Cancel.open_orders(
+      # )
+      public_class_method def self.open_orders(opts = {})
+        option_choice = opts[:option_choice]
+        env = opts[:env]
+        event_history = opts[:event_history]
+        order_type = opts[:order_type]
+        order_action = opts[:order_action]
+
+        # Consume Latest Order History Justification from
+        # Order Book & cancel orders tagged as pie
+        # event_history = Cryptum::API.cancel_synced_oj_and_oh(
+        #   option_choice: option_choice,
+        #   env: env,
+        #   event_history: event_history,
+        #   order_type: order_type,
+        #   order_action: order_action
+        # )
+
+        # event_history
+        event_history.order_canceled = 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
+
+        Cryptum::API.cancel_all_open_orders(
+          env: env,
+          option_choice: option_choice,
+          order_type: order_type,
+          event_notes: event_history.event_notes
+        )
+      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/history.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Cancel Open Limit Orders
+  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,
+                    :order_book,
+                    :order_canceled,
+                    :order_submitted,
+                    :order_ready,
+                    :plan_no,
+                    :reconnected,
+                    :red_pill,
+                    :reset_market_trend,
+                    :start_time,
+                    :ticker_event,
+                    :time_between_orders,
+                    :time_between_orders_max,
+                    :time_between_orders_min,
+                    :time_between_orders_reset
+
+      def initialize(opts = {})
+        option_choice = opts[:option_choice]
+        start_time = opts[:start_time]
+        order_book = opts[:order_book]
+
+        self.bullish_trend = false
+        self.first_event = true
+        self.order_canceled = false
+        self.order_submitted = false
+        self.order_ready = false
+        self.order_book = order_book
+        self.plan_no = 0
+        self.start_time = start_time
+        self.reconnected = false
+        self.red_pill = false
+        self.reset_market_trend = false
+
+        # 60 seconds
+        self.time_between_orders = option_choice.market_trend_reset
+        self.time_between_orders_reset = self.time_between_orders
+
+        # 60 minutes
+        self.time_between_orders_max = self.time_between_orders_reset * 60
+
+        # 5 seconds
+        self.time_between_orders_min = 5
+      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 Cancel Open Limit Orders
+  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/sell.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Submit a Limit Order
+  # to Sell Crypto Currency
+
+  module Event
+    module Sell
+      # Supported Method Parameters::
+      # Cryptum::Event::Sell.crypto(
+      # )
+      public_class_method def self.crypto(opts = {})
+        option_choice = opts[:option_choice]
+        env = opts[:env]
+        bot_conf = opts[:bot_conf]
+        stuck_in_pos_status = opts[:stuck_in_pos_status]
+        event_history = opts[:event_history]
+        order_type = opts[:order_type]
+        fiat_smallest_decimal = opts[:fiat_smallest_decimal]
+        crypto_smallest_decimal = opts[:crypto_smallest_decimal]
+        base_min_size = opts[:base_min_size]
+        indicator_status = opts[:indicator_status]
+        quote_increment = opts[:quote_increment]
+
+        # Initialize some bot_conf variables
+        pie_in_sky_sell_percent = bot_conf[:pie_in_sky_sell_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_available = format(
+          '%0.8f',
+          symbol_portfolio.first[:available].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)
+        # limit_price = last_three_prices_arr.min
+        # limit_price = last_three_prices_arr.max
+
+        # Obtain our Target Price based on TPM configurations
+        target_symbol_price = stuck_in_pos_status[:target_symbol_price].to_f
+
+        case order_type
+        when :pie
+          pie_in_sky_sell_percent_cast_as_decimal = format(
+            '%0.2f',
+            pie_in_sky_sell_percent * 0.01
+          ).to_f
+
+          target_profit = target_symbol_price * pie_in_sky_sell_percent_cast_as_decimal
+          limit_price = target_symbol_price + target_profit
+
+        when :tpm
+          limit_price = target_symbol_price
+          order_type = :tpm
+        when :gtfo
+          # Attempt to get in front of falling price.
+          limit_price = last_three_prices_arr.sort[1]
+          gtfo_price = limit_price -= quote_increment.to_f
+          limit_price = gtfo_price if gtfo_price.positive?
+        else
+          raise "ERROR: Unknown order_type: #{order_type}"
+        end
+
+        price = format("%0.#{fiat_smallest_decimal}f", limit_price)
+
+        # Selling Available Crytpo Balance in its Entirety
+        # We Will Likely Want to Change this in the Future.
+        size = format(
+          "%0.#{crypto_smallest_decimal}f",
+          symbol_balance_available.floor(crypto_smallest_decimal)
+        )
+
+        size = symbol_balance_available if base_min_size.to_i == 1
+
+        if size.to_f >= base_min_size.to_f &&
+           price.to_f.positive?
+
+          # SUBMIT SELL 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: :sell,
+            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:
+         order_book = #{self}.crypto()
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/event.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Cryptum
+  # This plugin is used to parse Coinbase Pro Web Socket Events in the HTTP Response
+  module Event
+    autoload :Buy, 'cryptum/event/buy'
+    autoload :Cancel, 'cryptum/event/cancel'
+    autoload :History, 'cryptum/event/history'
+    autoload :KeyPress, 'cryptum/event/key_press'
+    autoload :Sell, 'cryptum/event/sell'
+
+    # Supported Method Parameters::
+    # Cryptum::Event.parse(
+    # )
+
+    public_class_method def self.parse(opts = {})
+      option_choice = opts[:option_choice]
+      env = opts[:env]
+      terminal_win = opts[:terminal_win]
+      event_history = opts[:event_history]
+      indicator_status = opts[:indicator_status]
+      indicator_history = opts[:indicator_history]
+      bot_conf = opts[:bot_conf]
+      ai_enabled = opts[:ai_enabled]
+
+      candles = event_history.order_book[:candles]
+      order_history = event_history.order_book[:order_history]
+      this_product = event_history.order_book[:this_product]
+      fiat = this_product[:quote_currency]
+      fiat_portfolio_file = "#{option_choice.repo_root}/order_books/#{fiat}_PORTFOLIO.json"
+
+      # Detect Key Press Events
+      Cryptum::Event::KeyPress.detect(terminal_win: terminal_win)
+
+      # Determine if Summary UI needs updated data
+      event_history = Cryptum::Portfolio::Balance.refresh(
+        env: env,
+        option_choice: option_choice,
+        terminal_win: terminal_win,
+        event_history: event_history,
+        fiat_portfolio_file: fiat_portfolio_file
+      )
+
+      # If the Terminal Window has been Resized, Resize the UI
+      if Curses.cols != terminal_win.cols
+        terminal_win.cols = Curses.cols
+        terminal_win.ticker_ui_resize = true
+        terminal_win.market_trend_ui_resize = true
+      end
+
+      Cryptum::UI::Portfolio.refresh(
+        option_choice: option_choice,
+        portfolio_win: terminal_win.portfolio_section,
+        event_history: event_history,
+        key_press_event: terminal_win.key_press_event,
+        indicator_status: indicator_status,
+        bot_conf: bot_conf,
+        fiat_portfolio_file: fiat_portfolio_file
+      )
+
+      if event_history.event_type == :ticker ||
+         terminal_win.ticker_ui_resize
+
+        ticker_event = event_history.ticker_event = event_history.event if event_history.event_type == :ticker
+        ticker_event = event_history.ticker_event if terminal_win.ticker_ui_resize
+        Cryptum::UI::Ticker.refresh(
+          option_choice: option_choice,
+          start_time: event_history.start_time,
+          ticker_win: terminal_win.ticker_section,
+          key_press_event: terminal_win.key_press_event,
+          order_book: event_history.order_book,
+          event: ticker_event
+        )
+      end
+
+      order_countdown = Cryptum::UI::OrderTimer.refresh(
+        option_choice: option_choice,
+        event_history: event_history,
+        order_timer_win: terminal_win.order_timer_section,
+        indicator_status: indicator_status,
+        key_press_event: terminal_win.key_press_event
+      )
+
+      if event_history.event_type == :l2update ||
+         terminal_win.market_trend_ui_resize
+
+        market_trend_event = event_history.market_trend_event = event_history.event if event_history.event_type == :l2update
+        market_trend_event = event_history.market_trend_event if terminal_win.market_trend_ui_resize
+        Cryptum::UI::MarketTrend.refresh(
+          option_choice: option_choice,
+          market_trend_win: terminal_win.market_trend_section,
+          event_history: event_history,
+          key_press_event: terminal_win.key_press_event,
+          event: market_trend_event,
+          indicator_status: indicator_status,
+          bot_conf: bot_conf
+        )
+      end
+
+      indicator_status = Cryptum::UI::SignalEngine.refresh(
+        option_choice: option_choice,
+        signal_engine_win: terminal_win.signal_engine_section,
+        event_history: event_history,
+        key_press_event: terminal_win.key_press_event,
+        indicator_status: indicator_status,
+        bot_conf: bot_conf,
+        fiat_portfolio_file: fiat_portfolio_file
+      )
+
+      Cryptum::UI::OrderPlan.refresh(
+        option_choice: option_choice,
+        order_plan_win: terminal_win.order_plan_section,
+        event_history: event_history,
+        key_press_event: terminal_win.key_press_event,
+        indicator_status: indicator_status,
+        bot_conf: bot_conf,
+        fiat_portfolio_file: fiat_portfolio_file
+      )
+
+      event_history = Cryptum::UI::OrderExecution.refresh(
+        option_choice: option_choice,
+        order_execute_win: terminal_win.order_execute_section,
+        env: env,
+        event_history: event_history,
+        key_press_event: terminal_win.key_press_event,
+        indicator_status: indicator_status,
+        bot_conf: bot_conf,
+        fiat_portfolio_file: fiat_portfolio_file
+      )
+
+      # Refresh Command Section for Cryptum Session Usage
+      Cryptum::UI::Command.refresh(
+        command_win: terminal_win.command_section,
+        key_press_event: terminal_win.key_press_event
+      )
+
+      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
+
+      event_history
+    rescue LoadError => e
+      # This happens when autoloading modules fail.
+      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
+      raise e
+    ensure
+      $stdout.flush
+    end
+
+    # Display Usage for this Module
+
+    public_class_method def self.help
+      constants.sort
+    end
+  end
+end