cryptum 0.0.359 → 0.0.360

data/lib/cryptum/ui.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require 'curses'
+require 'time'
+
+module Cryptum
+  # Cryptum::UI Module used for Presenting the
+  # Cryptum Curses Interface
+  module UI
+    require 'cryptum/ui/key_press_event'
+    require 'cryptum/ui/terminal_window'
+    require 'cryptum/ui/ticker'
+    require 'cryptum/ui/portfolio'
+    require 'cryptum/ui/order_plan'
+    require 'cryptum/ui/order_plan_details'
+    require 'cryptum/ui/order_timer'
+    require 'cryptum/ui/market_trend'
+    require 'cryptum/ui/signal_engine'
+    require 'cryptum/ui/order_execution'
+    require 'cryptum/ui/order_execute_details'
+    require 'cryptum/ui/command'
+
+    # Initialize the UI
+    public_class_method def self.init
+      # Initialize curses Screen
+      Curses.init_screen
+
+      # Ensure the cursor is invisible
+      Curses.curs_set(0)
+
+      # Do not echo keystrokes back to the UI
+      Curses.noecho
+
+      # Used to immediately evaluate characters submitted
+      # without pressing ENTER (e.g. b, r, & w key events)
+      Curses.crmode
+      # Curses.nocrmode
+      # Curses.raw # NO
+      # Curses.noraw
+      # Disable Line Buffering
+      Curses.ESCDELAY = 0
+
+      # Start Color!
+      Curses.start_color
+
+      # This is important to ensure -1 maintains
+      # the original background color in the terminal
+      # when defining color pairs
+      Curses.use_default_colors
+
+      # This object is used to pass all of the UI sections
+      # around to various Cryptum modules
+      Cryptum::UI::TerminalWindow.new
+    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
+
+    # Create New Curses Window
+    public_class_method def self.window(opts = {})
+      height = opts[:height].to_i
+      width = opts[:width].to_i
+      top = opts[:top].to_i
+      left = opts[:left].to_i
+
+      window = Curses::Window.new(
+        height,
+        width,
+        top,
+        left
+      )
+      window.nodelay = true
+
+      window
+    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
+
+    # Draw a Box Around a Window
+    public_class_method def self.line(opts = {})
+      ui_win = opts[:ui_win]
+      out_line_no = opts[:out_line_no].to_i
+      color = opts[:color]
+      color ||= :white
+
+      style = :normal
+      style = :bold unless color == :white
+
+      ui_win.setpos(out_line_no, 0)
+      colorize(
+        ui_win: ui_win,
+        color: color,
+        style: style,
+        string: "\u2500" * Curses.cols
+      )
+    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
+
+    # Jump to First Column
+    public_class_method def self.colorize(opts = {})
+      ui_win = opts[:ui_win]
+      color = opts[:color].to_s.to_sym
+      red = opts[:red].to_i
+      green = opts[:green].to_i
+      blue = opts[:blue].to_i
+
+      style = opts[:style].to_s.to_sym
+      style = :normal if opts[:style].nil?
+
+      bg = opts[:bg].to_i
+      bg = -1 if opts[:bg].nil?
+
+      string = opts[:string]
+
+      case color
+      when :black
+        # It's more Gray than Black
+        # color_id = 0
+        # color_fg = Curses::COLOR_BLACK
+        color_id = 256
+        Curses.init_color(color_id, 0, 0, 500)
+        color_fg = color_id
+        color_bg = bg
+      when :red
+        color_id = 1
+        color_fg = Curses::COLOR_RED
+        color_bg = bg
+      when :green
+        color_id = 2
+        color_fg = Curses::COLOR_GREEN
+        color_bg = bg
+      when :yellow
+        color_id = 3
+        color_fg = Curses::COLOR_YELLOW
+        color_bg = bg
+      when :blue
+        color_id = 4
+        color_fg = Curses::COLOR_BLUE
+        color_bg = bg
+      when :magenta
+        color_id = 5
+        color_fg = Curses::COLOR_MAGENTA
+        color_bg = bg
+      when :cyan
+        color_id = 6
+        color_fg = Curses::COLOR_CYAN
+        color_bg = bg
+      when :white
+        color_id = 7
+        color_fg = Curses::COLOR_WHITE
+        color_bg = bg
+      when :rainbow
+        color_id = 254
+        red = Random.rand(0..1000)
+        green = Random.rand(0..1000)
+        blue = Random.rand(0..1000)
+        Curses.init_color(color_id, red, green, blue)
+        color_fg = color_id
+        color_bg = bg
+      when :custom
+        color_id = 255
+        Curses.init_color(color_id, red, green, blue)
+        color_fg = color_id
+        color_bg = bg
+      else
+        raise "Color Not Implemented for this Method: #{color}"
+      end
+
+      case style
+      when :blink
+        font = Curses::A_BLINK
+      when :bold
+        font = Curses::A_BOLD
+      when :highlight
+        font = Curses::A_STANDOUT
+      when :normal
+        font = Curses::A_NORMAL
+      when :reverse
+        font = Curses::A_REVERSE
+      else
+        raise "Font Style Not Implemented for this Method: #{style}"
+      end
+
+      Curses.init_pair(color_id, color_fg, color_bg)
+      ui_win.attron(Curses.color_pair(color_id) | font) do
+        ui_win.addstr(string)
+      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
+      Curses.close_screen
+      raise e
+    end
+
+    # Jump to First Column
+    public_class_method def self.col_center(opts = {})
+      str = opts[:str]
+
+      str_divided_by_two = str.length / 2
+      (Curses.cols / 2) - str_divided_by_two
+    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
+
+    public_class_method def self.col_first
+      0
+    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
+
+    # Jump to Second Column
+    public_class_method def self.col_second
+      (Curses.cols / 8) + 5
+    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
+
+    # Jump to Third Column
+    public_class_method def self.col_third
+      ((Curses.cols / 8) * 3) + 2
+    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
+
+    # Jump to Fourth Column
+    public_class_method def self.col_fourth
+      ((Curses.cols / 4) * 3) - 3
+    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
+
+    public_class_method def self.detect_key_press_in_ui(opts = {})
+      key_press_event = opts[:key_press_event]
+      ui_win = opts[:ui_win]
+
+      key_press = ui_win.get_char
+
+      # Useful for detecting and logging actual key presses to file
+      # unless key_press.nil?
+      #   File.open('/tmp/detect_key_press_in_ui-cryptum.txt', 'a') do |f|
+      #     f.puts key_press.class
+      #     f.print key_press.inspect
+      #     f.puts "\n\n\n"
+      #   end
+      # end
+
+      case key_press
+      when 'C'
+        key_press_event.key_c = true
+      when 'G'
+        key_press_event.key_g = true
+      when 'r'
+        key_press_event.key_r = true
+      when 'u'
+        key_press_event.key_u = true
+      when 'w'
+        key_press_event.key_w = true
+      when 'x'
+        key_press_event.key_x = true
+      when "\e"
+        key_press_event.key_esc = true
+      when "\n"
+        key_press_event.key_enter = true
+      when "\t"
+        key_press_event.key_tab = true
+      end
+
+      # What a hack to detect special keys (-.-)
+      if key_press_event.key_esc
+        key_press_event.key_ansi = true if key_press == '['
+        if key_press_event.key_ansi
+          key_press_event.key_up_arrow = true if key_press == 'A'
+          key_press_event.key_down_arrow = true if key_press == 'B'
+          # NOTE: the ~ at the end of these keys are ignored
+          # which may result in other keys working in place of them
+          # e.g. home is \e[1~ but we know it's home as soon as
+          # \e[1 is detected.
+          key_press_event.key_page_up = true if key_press == '5'
+          key_press_event.key_page_down = true if key_press == '6'
+          key_press_event.key_home = true if key_press == '1'
+          key_press_event.key_end = true if key_press == '4'
+        end
+      end
+
+      key_press_event
+    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 a List of Every UI Module
+
+    public_class_method def self.help
+      constants.sort
+    end
+  end
+end

data/lib/cryptum/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Cryptum
+  VERSION = '0.0.360'
+end

data/lib/cryptum/web_sock/coinbase.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'faye/websocket'
+require 'websocket/extensions'
+require 'permessage_deflate'
+
+module Cryptum
+  # This plugin is used to Establish a Web
+  # Socket Connection with Coinbase
+  module WebSock
+    # This module is used to Establish a Web
+    # Socket Connection with Coinbase
+    module Coinbase
+      # Supported Method Parameters::
+      # Cryptum::WebSock.connect(
+      # )
+      public_class_method def self.connect(opts = {})
+        option_choice = opts[:option_choice]
+        env = opts[:env]
+
+        # cb_pro_ws_feed = 'wss://ws-feed.pro.coinbase.com'
+        # cb_pro_ws_feed = 'wss://ws-feed-public.sandbox.pro.coinbase.com' if env[:env] == :sandbox
+        cb_pro_ws_feed = 'wss://ws-feed.exchange.coinbase.com'
+        cb_pro_ws_feed = 'wss://ws-feed-public.sandbox.exchange.coinbase.com' if env[:env] == :sandbox
+
+        extensions = [PermessageDeflate]
+
+        if option_choice.proxy
+          tls_opts = {
+            verify_peer: false
+          }
+
+          proxy_opts = {
+            origin: option_choice.proxy
+          }
+
+          ws = Faye::WebSocket::Client.new(
+            cb_pro_ws_feed,
+            [],
+            tls: tls_opts,
+            proxy: proxy_opts,
+            extensions: extensions,
+            ping: 9
+          )
+        else
+          ws = Faye::WebSocket::Client.new(
+            cb_pro_ws_feed,
+            [],
+            extensions: extensions,
+            ping: 9
+          )
+        end
+
+        ws
+      rescue Interrupt
+        # Exit Gracefully if CTRL+C is Pressed During Session
+        Cryptum.exit_gracefully(which_self: self)
+      rescue StandardError => e
+        raise e
+      end
+
+      public_class_method def self.subscribe_message(opts = {})
+        option_choice = opts[:option_choice]
+        env = opts[:env]
+        product_id = option_choice.symbol.to_s.gsub('_', '-').upcase
+
+        api_secret = env[:api_secret]
+        api_signature_response = Cryptum::API.generate_signature(
+          api_secret: api_secret
+        )
+        api_key = env[:api_key]
+        api_passphrase = env[:api_passphrase]
+        api_timestamp = api_signature_response[:api_timestamp]
+        api_signature = api_signature_response[:api_signature]
+
+        "{
+          \"type\": \"subscribe\",
+          \"product_ids\": [
+            \"#{product_id}\"
+          ],
+          \"channels\": [
+            \"level2_batch\",
+            \"ticker\",
+            \"user\"
+          ],
+          \"key\": \"#{api_key}\",
+          \"passphrase\": \"#{api_passphrase}\",
+          \"timestamp\": \"#{api_timestamp}\",
+          \"signature\": \"#{api_signature}\"
+        }"
+      rescue StandardError => e
+        raise e
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          logger = #{self}.create()
+        "
+      end
+    end
+  end
+end