cryptum 0.0.230

data/lib/cryptum/web_sock/coinbase.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'faye/websocket'
+
+module Cryptum
+  # This plugin is used to Establish a Web
+  # Socket Connection with Coinbase
+  module WebSock
+    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
+        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,
+            ping: 30
+          )
+        else
+          ws = Faye::WebSocket::Client.new(
+            cb_pro_ws_feed,
+            [],
+            ping: 30
+          )
+        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\": [
+            \"heartbeat\",
+            \"level2\",
+            \"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

data/lib/cryptum/web_sock/event_machine.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'eventmachine'
+require 'json'
+
+module Cryptum
+  # This plugin is used to Establish a Web
+  # Socket Connection with Coinbase
+  module WebSock
+    module EventMachine
+      # Supported Method Parameters::
+      # Cryptum::WS.run(
+      # )
+      public_class_method def self.run(opts = {})
+        env = opts[:env]
+        option_choice = opts[:option_choice]
+        terminal_win = opts[:terminal_win]
+        event_history = opts[:event_history]
+        indicator_status = opts[:indicator_status]
+
+        max_conn_attempts = 30
+        conn_attempt = 0
+
+        begin
+          conn_attempt += 1
+          event_history.reconnected = true if conn_attempt > 1
+
+          # Automatically Create Bot Configs if they don't
+          # Exist and Initialize Automated Trading Parameters
+          bot_conf = Cryptum.read_bot_conf(option_choice: option_choice)
+
+          EM.run do
+            # Iterate as fast as possible
+            # This ensures candle timing is accurate
+            # and everything is fast as possible
+            # Defaults to 100ms, 5ms is the lowest possible
+            delay_ms = 5
+            delay_ms_cast_as_decimal = delay_ms * 0.001
+            EM.set_quantum(delay_ms)
+
+            ws = Cryptum::WebSock::Coinbase.connect(
+              option_choice: option_choice,
+              env: env
+            )
+
+            ws.on :open do |_event|
+              ws.send(
+                Cryptum::WebSock::Coinbase.subscribe_message(
+                  option_choice: option_choice,
+                  env: env
+                )
+              )
+            end
+
+            ws.on :message do |event|
+              ai_enabled = bot_conf[:artifical_intelligence]
+              event_history.event = JSON.parse(
+                event.data,
+                symbolize_names: true
+              )
+              event_history.event_type = event_history.event[:type].to_s.to_sym
+              event_history = Cryptum::Event.parse(
+                env: env,
+                terminal_win: terminal_win,
+                option_choice: option_choice,
+                event_history: event_history,
+                indicator_status: indicator_status,
+                bot_conf: bot_conf,
+                ai_enabled: ai_enabled
+              )
+
+              # Decent for Debugging Events
+              # puts event_history.inspect
+              # Decent for Debugging MACD & RSI History
+              # puts indicator_status.inspect
+
+              # Detect Key Press Events
+              Cryptum::Event::KeyPress.detect(terminal_win: terminal_win)
+
+              # Get the F* Out (GTFO) when
+              # G is pressed
+              if terminal_win.key_press_event.key_g
+                event_history = Cryptum::API.gtfo(
+                  option_choice: option_choice,
+                  env: env,
+                  event_history: event_history,
+                  bot_conf: bot_conf
+                )
+                terminal_win.key_press_event.key_g = false
+              end
+
+              # Only Reload Bot Conf when
+              # R is Pressed
+              if terminal_win.key_press_event.key_r
+                bot_conf = Cryptum.read_bot_conf(option_choice: option_choice)
+                terminal_win.key_press_event.key_r = false
+              end
+
+              # Only Write Order Book to File when
+              # W is Pressed
+              if terminal_win.key_press_event.key_w
+                order_book_file = event_history.order_book[:path]
+                File.open(order_book_file, 'w') do |f|
+                  f.puts event_history.order_book.to_json
+                end
+                terminal_win.key_press_event.key_w = false
+              end
+
+              # Exit if x is Pressed
+              if terminal_win.key_press_event.key_x
+                terminal_win.key_press_event.key_x = false
+                Cryptum.exit_gracefully(
+                  which_self: self,
+                  event_history: event_history,
+                  option_choice: option_choice,
+                  env: env
+                )
+              end
+            end
+
+            ws.on :close do
+              raise Errno::ECONNRESET
+            end
+
+            EM.add_periodic_timer(delay_ms_cast_as_decimal) do
+              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
+              )
+
+              event_history.order_ready = true if order_countdown.zero? ||
+                                                  order_countdown.negative?
+            end
+
+            EM.add_periodic_timer(option_choice.market_trend_reset) do
+              Cryptum::OrderBook::MarketTrend.reset(
+                option_choice: option_choice,
+                terminal_win: terminal_win,
+                event_history: event_history,
+                bot_conf: bot_conf
+              )
+            end
+          end
+        rescue Faye::WebSocket::API::ErrorEvent,
+               Errno::ECONNREFUSED,
+               Errno::ECONNRESET => 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
+
+          raise e if conn_attempt > max_conn_attempts
+
+          sleep 1
+          retry
+        end
+      rescue Interrupt
+        # Exit Gracefully if CTRL+C is Pressed During Session
+        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:
+          logger = #{self}.create()
+        "
+      end
+    end
+  end
+end

data/lib/cryptum/web_sock.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cryptum
+  # This plugin is used to Establish a Web
+  # Socket Connection with Coinbase
+  module WebSock
+    autoload :Coinbase, 'cryptum/web_sock/coinbase'
+    autoload :EventMachine, 'cryptum/web_sock/event_machine'
+
+    # Display Usage for this Module
+
+    public_class_method def self.help
+      constants.sort
+    end
+  end
+end

data/lib/cryptum.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'cryptum/version'
+require 'rbtrace'
+require 'yaml'
+require 'json'
+require 'fileutils'
+require 'tty-spinner'
+
+# Root-Level Namespace for cryptum
+module Cryptum
+  $stdout.sync = true
+  $stdout.flush
+
+  autoload :API, 'cryptum/api'
+  autoload :BotConf, 'cryptum/bot_conf'
+  autoload :Event, 'cryptum/event'
+  autoload :Indicator, 'cryptum/indicator'
+  autoload :Log, 'cryptum/log'
+  autoload :Matrix, 'cryptum/matrix'
+  autoload :Option, 'cryptum/option'
+  autoload :OrderBook, 'cryptum/order_book'
+  autoload :Portfolio, 'cryptum/portfolio'
+  autoload :ProbabilityEngine, 'cryptum/probability_engine'
+  autoload :UI, 'cryptum/ui'
+  autoload :WebSock, 'cryptum/web_sock'
+
+  public_class_method def self.bin
+    File.join root, 'bin'
+  end
+
+  public_class_method def self.etc
+    File.join root, 'etc'
+  end
+
+  public_class_method def self.lib
+    File.join root, 'lib'
+  end
+
+  public_class_method def self.order_book
+    File.join root, 'order_book'
+  end
+
+  public_class_method def self.root
+    File.dirname __dir__
+  end
+
+  public_class_method def self.open_symbol
+    "\u00f8"
+  end
+
+  public_class_method def self.up_arrow
+    "\u2191"
+  end
+
+  public_class_method def self.down_arrow
+    "\u2193"
+  end
+
+  public_class_method def self.flat_arrow
+    '_'
+  end
+
+  # Deserialize Cryptum Bot Conf
+  public_class_method def self.read_bot_conf(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_bot_conf_key(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
+
+  # Update Key/Value Pair in Bot Conf and Serialize to YAML File
+  public_class_method def self.beautify_large_number(opts = {})
+    value = opts[:value].to_s
+  
+    split_str_num = value.split('.')
+    whole_num = split_str_num.first
+    fraction = 0
+    fraction = split_str_num.last if split_str_num.length > 1
+
+    is_negative = false
+    is_negative = true if whole_num.split('').first == '-'
+    whole_num = whole_num[1..] if is_negative
+    beautify_whole = whole_num.reverse.scan(/.{1,3}/).join(',').reverse
+    beautify_num = "#{beautify_whole}.#{fraction}" unless is_negative
+    beautify_num = "-#{beautify_whole}.#{fraction}" if is_negative
+
+    return beautify_num
+  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.exit_gracefully(opts = {})
+    which_self = opts[:which_self]
+    event_history = opts[:event_history]
+    option_choice = opts[:option_choice]
+    env = opts[:env]
+
+    # Clear out candle data to ensure
+    # Cryptum Statistics Only Apply to
+    # Live Sessions
+    if event_history
+      order_book_file = event_history.order_book[:path]
+      File.open(order_book_file, 'w') do |f|
+        f.puts event_history.order_book.to_json
+      end
+    end
+
+    Curses.close_screen
+    puts "Interrupt detected in #{which_self}...goodbye."
+
+    exit 0
+  rescue NameError
+    puts "\nInterrupt detected in #{which_self}...goodbye."
+
+    exit 0
+  rescue StandardError => e
+    # Produce a Stacktrace for anything else
+    raise e
+  end
+
+  public_class_method def self.help
+    constants.sort
+  end
+end

data/reinstall_cryptum_gemset.sh

@@ -0,0 +1,29 @@
+#!/bin/bash --login
+# USE THIS SCRIPT WHEN UPGRADING VERSIONS IN Gemfile
+if [[ $CRYPTUM_ROOT == '' ]]; then
+  if [[ ! -d '/opt/cryptum' ]]; then
+    cryptum_root=$(pwd)
+  else
+    cryptum_root='/opt/cryptum'
+  fi
+else
+  cryptum_root="${CRYPTUM_ROOT}"
+fi
+
+if [[ -f '/etc/profile.d/rvm.sh' ]]; then
+  source /etc/profile.d/rvm.sh
+fi
+
+ruby_version=`cat ${cryptum_root}/.ruby-version`
+ruby_gemset=`cat ${cryptum_root}/.ruby-gemset`
+rvm use ruby-$ruby_version@global
+rvm gemset --force delete $ruby_gemset
+if [[ -f "${cryptum_root}/Gemfile.lock" ]]; then
+  rvmsudo rm $cryptum_root/Gemfile.lock
+fi
+
+rvm use ruby-$ruby_version@$ruby_gemset --create
+export rvmsudo_secure_path=1
+rvmsudo gem install bundler
+rvmsudo bundle install
+rvm --default ruby-$ruby_version@$ruby_gemset

data/spec/lib/cryptum/api_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::API do
+  it 'should display information for existing help method' do
+    help_response = Cryptum::API
+    expect(help_response).to respond_to :help
+  end
+end

data/spec/lib/cryptum/event_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::Event do
+  it 'should display information for existing help method' do
+    help_response = Cryptum::Event
+    expect(help_response).to respond_to :help
+  end
+end

data/spec/lib/cryptum/log_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::Log do
+  it 'should display information for existing help method' do
+    help_response = Cryptum::Log
+    expect(help_response).to respond_to :help
+  end
+end

data/spec/lib/cryptum/option_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::Option do
+  it 'should return data for help method' do
+    help_response = Cryptum::Option.help
+    expect(help_response).not_to be_nil
+  end
+end

data/spec/lib/cryptum/order_book/generate_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::OrderBook::Generate do
+  it 'should display information for existing help method' do
+    help_response = Cryptum::OrderBook::Generate
+    expect(help_response).to respond_to :help
+  end
+end

data/spec/lib/cryptum/order_book/market_trend_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::OrderBook::MarketTrend do
+  it 'should display information for existing help method' do
+    help_response = Cryptum::OrderBook::MarketTrend
+    expect(help_response).to respond_to :help
+  end
+end

data/spec/lib/cryptum/order_book_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::OrderBook do
+  it 'should display information for existing help method' do
+    help_response = Cryptum::OrderBook
+    expect(help_response).to respond_to :help
+  end
+end

data/spec/lib/cryptum/ui/command_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::UI::Command do
+  it 'should display information for existing help method' do
+    help_response = Cryptum::UI::Command
+    expect(help_response).to respond_to :help
+  end
+end

data/spec/lib/cryptum/ui/ticker_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::UI::Ticker do
+  it 'should display information for existing help method' do
+    help_response = Cryptum::UI::Ticker
+    expect(help_response).to respond_to :help
+  end
+end

data/spec/lib/cryptum/ui_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::UI do
+  it 'should return data for help method' do
+    help_response = Cryptum::UI.help
+    expect(help_response).not_to be_nil
+  end
+end

data/spec/lib/cryptum/web_sock_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum::WebSock do
+  it 'should display information for existing help method' do
+    help_response = Cryptum::WebSock
+    expect(help_response).to respond_to :help
+  end
+end

data/spec/lib/cryptum_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Cryptum do
+  it 'should return data for help method' do
+    help_response = Cryptum.help
+    expect(help_response).not_to be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'cryptum'

data/upgrade_Gemfile_gems.sh

@@ -0,0 +1,20 @@
+#!/bin/bash --login
+cat Gemfile | awk '{print $2}' | grep -E "^'.+$" | grep -v -e rubygems.org | while read gem; do 
+  this_gem=`echo $gem | sed "s/'//g" | sed 's/\,//g'`
+  latest_version=`gem search -r $this_gem | grep -E "^${this_gem}\s.+$" | awk '{print $2}' | sed 's/(//g' | sed 's/)//g' | sed 's/,//g'`
+  echo "${this_gem} => $latest_version"
+  os=`uname -s`
+  if [[ $os == 'Linux' ]]; then
+    if [[ $this_gem == 'bundler' ]]; then
+      sed -i "s/^gem '${this_gem}'.*$/gem '${this_gem}', '>=${latest_version}'/g" Gemfile
+    else
+      sed -i "s/^gem '${this_gem}'.*$/gem '${this_gem}', '${latest_version}'/g" Gemfile
+    fi
+  elif [[ $os == 'Darwin' ]]; then
+    if [[ $this_gem == 'bundler' ]]; then
+      sed -i '' "s/^gem '${this_gem}'.*$/gem '${this_gem}', '>=${latest_version}'/g" Gemfile
+    else
+      sed -i '' "s/^gem '${this_gem}'.*$/gem '${this_gem}', '${latest_version}'/g" Gemfile
+    fi
+  fi
+done

data/upgrade_cryptum.sh

@@ -0,0 +1,13 @@
+#!/bin/bash --login
+if [[ $CRYPTUM_ROOT == '' ]]; then
+  if [[ ! -d '/opt/cryptum' ]]; then
+    cryptum_root=$(pwd)
+  else
+    cryptum_root='/opt/cryptum'
+  fi
+else
+  cryptum_root="${CRYPTUM_ROOT}"
+fi
+
+export rvmsudo_secure_path=1
+rvmsudo /bin/bash --login -c "cd ${cryptum_root} && ./build_cryptum_gem.sh"