cryptum 0.0.230

data/lib/cryptum/order_book/profit_margin.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to indicate if the
+  # Projected Profit Margin is greater than
+  # the Target Profit Margin Outlined in the
+  # Respective Bot Conf
+
+  module OrderBook
+    module ProfitMargin
+      # Supported Method Parameters::
+      # Cryptum::OrderBook::ProfitMargin.status(
+      # )
+
+      public_class_method def self.status(opts = {})
+        indicator_hash = {}
+        target_profit_margin_percent = opts[:target_profit_margin_percent]
+        total_invested = opts[:total_invested]
+        total_projected_return = opts[:total_projected_return]
+        indicator_status = opts[:indicator_status]
+        invested = opts[:invested]
+
+        ave_profit_margin_percent = 100 - ((total_invested / total_projected_return) * 100)
+
+        if ave_profit_margin_percent > target_profit_margin_percent
+          indicator_hash[:color] = :green
+          pm_op = '>'
+        elsif ave_profit_margin_percent < target_profit_margin_percent
+          indicator_hash[:color] = :red
+          pm_op = '<'
+        else
+          indicator_hash[:color] = :yellow
+          pm_op = '=='
+        end
+
+        profit_margin_status_out = "Profit Margin #{pm_op} TPM"
+        indicator_hash[:invested] = invested
+        indicator_hash[:status] = profit_margin_status_out
+
+        indicator_status.profit_margin = indicator_hash
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+         weighted_ave_indicator_hash = #{self}.status(
+         )
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/order_book/weighted_avg.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to indicate if the Weighted Executed Buy Orders are less than the Weighted Excuted Sell Orders
+
+  module OrderBook
+    module WeightedAvg
+      # Supported Method Parameters::
+      # Cryptum::OrderBook::WeightedAvg.status(
+      #   order_book: 'required - order_book data structure'
+      # )
+
+      public_class_method def self.status(opts = {})
+        order_book = opts[:order_book]
+        order_history = order_book[:order_history]
+        indicator_status = opts[:indicator_status]
+        invested = opts[:invested]
+
+        indicator_hash = {}
+        indicator_hash[:invested] = invested
+
+        buy_orders_done = order_history.select do |orders|
+          orders[:side] == 'buy' &&
+            orders[:status] == 'done' &&
+            orders[:done_reason] == 'filled'
+        end
+
+        total_buy_orders_done = buy_orders_done.length
+        avg_buy_exec = format('%0.7f', 0.00).to_f
+        # total_buy_executed = 0.00
+        # total_invested = 0.00
+        # buy_fees = 0.00
+        if total_buy_orders_done.positive?
+          # Calculate Weighted Avg. of Completed Buy Orders
+          weighted_buy_prices_arr = []
+          buy_orders_done.each do |order|
+            weighted_hash = {}
+            executed_value = order[:executed_value].to_f
+            filled_size = order[:filled_size].to_f
+            weighted_hash[:price] = (executed_value / filled_size).to_f
+            weighted_hash[:filled_size] = filled_size
+            weighted_hash[:price_times_filled_size] = weighted_hash[:price] * filled_size
+            weighted_buy_prices_arr.push(weighted_hash)
+          end
+
+          price_times_filled_size = weighted_buy_prices_arr.sum do |orders|
+            orders[:price_times_filled_size].to_f
+          end
+
+          this_filled_size = weighted_buy_prices_arr.sum do |orders|
+            orders[:filled_size]
+          end
+
+          calc_avg_buy_exec = price_times_filled_size / this_filled_size
+          avg_buy_exec = format('%0.7f', calc_avg_buy_exec).to_f
+
+          executed_value = buy_orders_done.sum do |orders|
+            orders[:executed_value].to_f
+          end
+
+          # total_buy_executed = format('%0.7f', executed_value).to_f
+
+          # fill_fees = buy_orders_done.sum do |orders|
+          #   orders[:fill_fees].to_f
+          # end
+
+          # buy_fees = format('%0.7f', fill_fees).to_f
+
+          # calc_total_invested = total_buy_executed.to_f - buy_fees.to_f
+          # total_invested = format('%0.7f', calc_total_invested).to_f
+        end
+        order_book[:avg_buy_exec] = avg_buy_exec
+
+        sell_orders_done = order_history.select do |orders|
+          orders[:side] == 'sell' &&
+            orders[:status] == 'done' &&
+            orders[:done_reason] == 'filled'
+        end
+
+        total_sell_orders_done = sell_orders_done.length
+        avg_sell_exec = format('%0.7f', 0.00).to_f
+        # total_sell_executed = format('%0.7f', 0.00).to_f
+        # total_return = format('%0.7f', 0.00).to_f
+        # sell_fees = format('%0.7f', 0.00).to_f
+        if total_sell_orders_done.positive?
+          # Calculate Weighted Avg. of Completed Sell Orders
+          weighted_sell_prices_arr = []
+          sell_orders_done.each do |order|
+            weighted_hash = {}
+            executed_value = order[:executed_value].to_f
+            filled_size = order[:filled_size].to_f
+            weighted_hash[:price] = (executed_value / filled_size).to_f
+            weighted_hash[:filled_size] = filled_size
+            weighted_hash[:price_times_filled_size] = weighted_hash[:price] * filled_size
+            weighted_sell_prices_arr.push(weighted_hash)
+          end
+
+          price_times_filled_size = weighted_sell_prices_arr.sum do |orders|
+            orders[:price_times_filled_size].to_f
+          end
+
+          this_filled_size = weighted_sell_prices_arr.sum do |orders|
+            orders[:filled_size]
+          end
+
+          calc_avg_sell_exec = price_times_filled_size / this_filled_size
+          avg_sell_exec = format('%0.7f', calc_avg_sell_exec).to_f
+
+          executed_value = sell_orders_done.sum do |orders|
+            orders[:executed_value].to_f
+          end
+
+          # total_sell_executed = format('%0.7f', executed_value).to_f
+
+          # fill_fees = sell_orders_done.sum do |orders|
+          #   orders[:fill_fees].to_f
+          # end
+
+          # sell_fees = format('%0.7f', fill_fees).to_f
+          # calc_total_made = total_sell_executed.to_f - sell_fees.to_f
+          # total_return = format('%0.7f', calc_total_made).to_f
+        end
+        order_book[:avg_sell_exec] = avg_sell_exec
+
+        if avg_buy_exec < avg_sell_exec
+          indicator_hash[:color] = :green
+          weight_op = '<'
+        elsif avg_buy_exec > avg_sell_exec
+          indicator_hash[:color] = :red
+          weight_op = '>'
+        else
+          indicator_hash[:color] = :yellow
+          weight_op = '=='
+        end
+        weighted_avg_status_out = "VWAPB #{weight_op} VWAPS"
+        order_book[:candles].last[:weighted_avg_status] = weighted_avg_status_out
+        indicator_hash[:status] = weighted_avg_status_out
+        # indicator_hash[:order_book] = order_book
+
+        indicator_status.weighted_avg = indicator_hash
+        # indicator_hash
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+         weighted_avg_indicator_hash = #{self}.status(
+           order_book: 'required - order_book data structure'
+         )
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/order_book.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'logger'
+
+module Cryptum
+  # This module is used to define the Order Book Data Structure
+  module OrderBook
+    autoload :Generate, 'cryptum/order_book/generate'
+    autoload :Indicator, 'cryptum/order_book/indicator'
+    autoload :MarketTrend, 'cryptum/order_book/market_trend'
+    autoload :ProfitMargin, 'cryptum/order_book/profit_margin'
+
+    # Supported Method Parameters::
+    # Cryptum::OrderBook.get_populated_indicators(
+    #   indicator_status: 'required - indicator_status object instantiated via Cryptum::OrderBook::Indicators'
+    # )
+    public_class_method def self.get_populated_indicators(opts = {})
+      indicator_status = opts[:indicator_status]
+
+      indicator_type_hash = {}
+      indicator_type_hash[:trend_indicator_arr] = []
+      trend_indicator_arr = indicator_type_hash[:trend_indicator_arr]
+
+      indicator_type_hash[:health_indicator_arr] = []
+      health_indicator_arr = indicator_type_hash[:health_indicator_arr]
+
+      if indicator_status.order_trend
+        trend_indicator_arr.push(
+          indicator_status.order_trend
+        )
+      end
+
+      if indicator_status.weighted_avg
+        health_indicator_arr.push(
+          indicator_status.weighted_avg
+        )
+      end
+
+      if indicator_status.profit_margin
+        health_indicator_arr.push(
+          indicator_status.profit_margin
+        )
+      end
+
+      indicator_type_hash
+    rescue StandardError => e
+      raise e
+    end
+
+    # Supported Method Parameters::
+    # base_currency_overrides = Cryptum::OrderBook.base_currency_overrides
+    public_class_method def self.base_currency_overrides
+      %i[
+        1inch
+        aave
+        ada
+        amp
+        ankr
+        bal
+        band
+        bat
+        bnt
+        bond
+        cgld
+        chz
+        clv
+        comp
+        crv
+        ctsi
+        dot
+        enj
+        farm
+        fet
+        fil
+        forth
+        grt
+        gtc
+        icp
+        keep
+        lpt
+        lrc
+        mana
+        mask
+        matic
+        mir
+        mkr
+        mln
+        nkn
+        nmr
+        nu
+        ogn
+        poly
+        qnt
+        ren
+        rly
+        shib
+        skl
+        snx
+        sol
+        storj
+        sushi
+        trb
+        tribe
+        uma
+        uni
+        wbtc
+        yfi
+        zrx
+      ]
+    rescue StandardError => e
+      raise e
+    end
+
+    # Supported Method Parameters::
+    # Cryptum::OrderBook.analyze(
+    #   order_book_file: 'required - path to order book file'
+    # )
+    public_class_method def self.analyze(opts = {})
+      order_book_file = opts[:order_book_file]
+      option_choice = opts[:option_choice]
+      # TODO: Handle File that exists
+      # w/ Zero size...N number of
+      # attempts?  Timeout may be better.
+      order_book = JSON.parse(
+        File.read(order_book_file),
+        symbolize_names: true
+      )
+
+      order_book[:option_choice] = option_choice
+
+      bot_conf = Cryptum::BotConf.read(option_choice: option_choice)
+      order_book[:bot_conf] = bot_conf
+
+      env = Cryptum::Option.get_env(option_choice: option_choice)
+      order_book[:env] = env
+
+      order_book
+    rescue JSON::ParserError => 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 StandardError => e
+      raise e
+    end
+
+    # Display Usage for this Module
+    public_class_method def self.help
+      constants.sort
+    end
+  end
+end

data/lib/cryptum/portfolio/balance.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Cryptum
+  # This plugin is used to instantiate a Cryptum logger with a custom message format
+  module Portfolio
+    module Balance
+      # Supported Method Parameters::
+      # Cryptum::Event::Update.summary(
+      # )
+      public_class_method def self.refresh(opts = {})
+        option_choice = opts[:option_choice]
+        env = opts[:env]
+        terminal_win = opts[:terminal_win]
+        event_history = opts[:event_history]
+        fiat_portfolio_file = opts[:fiat_portfolio_file]
+
+        this_product = event_history.order_book[:this_product]
+        crypto = this_product[:base_currency]
+        fiat = this_product[:quote_currency]
+
+        if event_history.first_event ||
+           event_history.reconnected ||
+           event_history.event_type == :received ||
+           event_history.event_type == :open ||
+           event_history.event_type == :done ||
+           event_history.event_type == :match ||
+           event_history.event_type == :change ||
+           event_history.event_type == :activate ||
+           terminal_win.key_press_event.key_u
+
+          etype = event_history.event_type
+          manual_refresh = terminal_win.key_press_event.key_u
+          etype = :manual_refresh if manual_refresh
+          etype = :first_event if event_history.first_event
+          etype = :reconnected if event_history.reconnected
+          event_history.event_type = etype
+
+          # Prevent Multiple Order Events from Occuring --- #
+          ocancel = event_history.order_canceled
+          osubmit = event_history.order_submitted
+
+          # POTENTIAL STOP IN ORDERS WHEN
+          # event_history.order_canceled = true
+          # Verify it's not due to EMA being red.
+          # ocancel = false if (etype == :open || etype == :done) &&
+          #                    osubmit == false &&
+          #                    !manual_refresh
+
+          ocancel = false if etype == :done &&
+                             osubmit == true &&
+                             !manual_refresh
+
+          event_history.order_canceled = ocancel
+
+          osubmit = false if etype == :done &&
+                             !manual_refresh
+
+          event_history.order_submitted = osubmit
+          # ---------------------------------------------- #
+
+          enotes = event_history.event_notes
+          enotes = "{ \"event_type\": \"#{etype}\", \"cancel\": \"#{ocancel}\", \"submitted\": \"#{osubmit}\" }" if option_choice.proxy
+          event_history.event_notes = enotes
+
+          portfolio = Cryptum::API.get_portfolio(
+            option_choice: option_choice,
+            env: env,
+            crypto: crypto,
+            fiat: fiat,
+            fiat_portfolio_file: fiat_portfolio_file,
+            event_notes: event_history.event_notes
+          )
+          event_history.order_book[:portfolio] = portfolio unless portfolio.empty?
+
+          order_history = Cryptum::API.get_order_history(
+            option_choice: option_choice,
+            env: env
+          )
+          event_history.order_book[:order_history] = order_history unless order_history.empty?
+
+          fees = Cryptum::API.get_fees(
+            option_choice: option_choice,
+            env: env
+          )
+          event_history.order_book[:fees] = fees unless fees.empty?
+
+          terminal_win.key_press_event.key_u = false if manual_refresh
+          # First Event to Refresh No Longer Needed
+          event_history.first_event = false
+          # Reconnected Event to Refresh No Longer Needed
+          event_history.reconnected = false
+        end
+
+        # Always reload fiat portfolio as it's shared
+        # by all sessions (unless it's empty)
+        fpf = ''
+        fpf = File.read(fiat_portfolio_file) unless File.empty?(
+          fiat_portfolio_file
+        )
+
+        unless fpf.empty?
+          event_history.order_book[:fiat_portfolio] = JSON.parse(
+            fpf,
+            symbolize_names: true
+          )
+        end
+
+        event_history
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+      public_class_method def self.help
+        puts "USAGE:
+         event_history.order_book = #{self}.crypto()
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/portfolio.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Cryptum
+  # This plugin is used to instantiate a Cryptum logger with a custom message format
+  module Portfolio
+    autoload :Balance, 'cryptum/portfolio/balance'
+
+    # Display Usage for this Module
+    public_class_method def self.help
+      constants.sort
+    end
+  end
+end